100:\n x_max_bin = 100\n if x_max_bin < -100:\n x_max_bin = -100\n else:\n x_max_bin = x_max_scale * 37.8\n if x_max_bin < 13:\n x_max_bin = 13\n\n sum_like = 0\n for tel_count in self.image: # Loop over all telescopes\n # Calculate impact distance for all telescopes\n impact = np.sqrt(pow(self.tel_pos_x[tel_count] - core_x, 2)\n + pow(self.tel_pos_y[tel_count] - core_y, 2))\n # And the expected rotation angle\n phi = np.arctan2((self.tel_pos_y[tel_count] - core_y),\n (self.tel_pos_x[tel_count] - core_x)) # - (math.pi/2.)\n\n # Rotate and translate all pixels such that they match the\n # template orientation\n pix_x_rot, pix_y_rot = self.rotate_translate(\n self.pixel_x[tel_count] * -1,\n self.pixel_y[tel_count],\n source_x, source_y, phi\n )\n\n # Then get the predicted image, convert pixel positions to deg\n prediction = self.image_prediction(\n self.type[tel_count],\n zenith, azimuth, energy, impact, x_max_bin,\n pix_x_rot * (180 / math.pi),\n pix_y_rot * (180 / math.pi)\n )\n prediction[np.isnan(prediction)] = 0\n prediction[prediction < 1e-6] = 1e-6\n\n # Scale templates to match simulations\n prediction *= self.scale[self.type[tel_count]]\n # Get likelihood that the prediction matched the camera image\n like = poisson_likelihood_gaussian(self.image[tel_count],\n prediction,\n self.spe,\n self.ped[tel_count])\n if np.any(prediction == np.inf):\n print(\"inf found at \", self.type[tel_count], zenith,\n azimuth, energy, impact, x_max_bin)\n like[np.isnan(like)] = 1e9\n sum_like += np.sum(like)\n if np.sum(prediction) is 0:\n sum_like += 1e9\n\n return sum_like","def get_score_and_geo(images, labels, data_iter_type='ImageDetIter'):\n for i, image in enumerate(images):\n height, width = image.shape[1], image.shape[2]\n poly_mask = np.zeros((height, width), dtype=np.uint8)\n score_map = np.zeros((images.shape[0], height, width), dtype=np.uint8)\n geo_map = np.zeros((images.shape[0], height, width, 5), dtype=np.float32)\n if data_iter_type == 'MXDataIter':\n label = labels[i].asnumpy() # 1-D Array\n label = np.delete(label, np.where(label == -1)) # Delete all -1 padding\n c, h, w, label_width, header_length, bbox_label_width, orig_h, orig_w = label[:8]\n polys = np.reshape(label[8:], (int(len(label[8:]) / bbox_label_width), -1)) # (Num_of_polys, bbox_label_width)\n vocab_idx = polys[:, 1]\n polys = polys[:, 1:]\n\n elif data_iter_type == 'ImageDetIter':\n label = labels[i].asnumpy() # 1-D Array\n polys = np.delete(label, np.where(label[:, 0] == -1), axis=0)\n vocab_idx = polys[:, 1]\n polys = polys[:, 1:]\n\n # For each polygon (bounding box) in the label\n for poly in polys:\n poly = np.reshape(poly, (4, 2))\n poly[:, 0] = np.round(poly[:, 0] * height, 0)\n poly[:, 1] = np.round(poly[:, 1] * width, 0)\n\n poly = np.array(poly).astype(np.int32)\n # Draw polygon on the score mask (binary map)\n cv2.fillPoly(score_map[i], [poly], (1))\n # Draw polygon on the poly_mask (binary map) that will be used to create geo_map\n cv2.fillPoly(poly_mask, [poly], (1))\n\n fitted_parallelograms = []\n # For the number of sides (4) in the polygon\n for j in range(4):\n # Rotate the orientation at each iter\n p0 = poly[j]\n p1 = poly[(j + 1) % 4]\n p2 = poly[(j + 2) % 4]\n p3 = poly[(j + 3) % 4]\n\n edge = fit_line([p0[0], p1[0]], [p0[1], p1[1]])\n if point_dist_to_line(p0, p1, p2) > point_dist_to_line(p0, p1, p3):\n if edge[1] == 0:\n edge_opposite = [1, 0, -p2[0]]\n else:\n edge_opposite = [edge[0], -1, p2[1] - edge[0] * p2[0]]\n else:\n if edge[1] == 0:\n edge_opposite = [1, 0, -p3[0]]\n else:\n edge_opposite = [edge[0], -1, p3[1] - edge[0] * p3[0]]\n\n # move forward edge\n new_p0 = p0\n new_p1 = p1\n new_p2 = p2\n new_p3 = p3\n forward_edge = fit_line([p1[0], p2[0]], [p1[1], p2[1]])\n new_p2 = line_cross_point(forward_edge, edge_opposite)\n if point_dist_to_line(p1, new_p2, p0) > point_dist_to_line(p1, new_p2, p3):\n # across p0\n if forward_edge[1] == 0:\n forward_opposite = [1, 0, -p0[0]]\n else:\n forward_opposite = [forward_edge[0], -1, p0[1] - forward_edge[0] * p0[0]]\n else:\n # across p3\n if forward_edge[1] == 0:\n forward_opposite = [1, 0, -p3[0]]\n else:\n forward_opposite = [forward_edge[0], -1, p3[1] - forward_edge[0] * p3[0]]\n new_p0 = line_cross_point(forward_opposite, edge)\n new_p3 = line_cross_point(forward_opposite, edge_opposite)\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\n\n # or move backward edge\n new_p0 = p0\n new_p1 = p1\n new_p2 = p2\n new_p3 = p3\n backward_edge = fit_line([p0[0], p3[0]], [p0[1], p3[1]])\n new_p3 = line_cross_point(backward_edge, edge_opposite)\n if point_dist_to_line(p0, p3, p1) > point_dist_to_line(p0, p3, p2):\n # across p1\n if backward_edge[1] == 0:\n backward_opposite = [1, 0, -p1[0]]\n else:\n backward_opposite = [backward_edge[0], -1, p1[1] - backward_edge[0] * p1[0]]\n else:\n # across p2\n if backward_edge[1] == 0:\n backward_opposite = [1, 0, -p2[0]]\n else:\n backward_opposite = [backward_edge[0], -1, p2[1] - backward_edge[0] * p2[0]]\n new_p1 = line_cross_point(backward_opposite, edge)\n new_p2 = line_cross_point(backward_opposite, edge_opposite)\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\n\n areas = [Polygon(t).area for t in fitted_parallelograms]\n parallelogram = np.array(fitted_parallelograms[np.argmin(areas)][:-1], dtype=np.float32)\n\n # sort thie polygon\n parallelogram_coord_sum = np.sum(parallelogram, axis=1)\n min_coord_idx = np.argmin(parallelogram_coord_sum)\n parallelogram = parallelogram[\n [min_coord_idx, (min_coord_idx + 1) % 4, (min_coord_idx + 2) % 4, (min_coord_idx + 3) % 4]]\n\n rectangle = rectangle_from_parallelogram(parallelogram)\n rectangle, rotate_angle = sort_rectangle(rectangle)\n r0, r1, r2, r3 = rectangle\n\n # For all points of the polygon (bounding box), calculate geometric geo map\n Y, X = np.where(poly_mask == 1)\n for y, x in zip(Y, X):\n point = np.array([x, y], dtype=np.float32)\n # top\n geo_map[i, y, x, 0] = point_dist_to_line(r0, r1, point)\n # right\n geo_map[i, y, x, 1] = point_dist_to_line(r1, r2, point)\n # down\n geo_map[i, y, x, 2] = point_dist_to_line(r2, r3, point)\n # left\n geo_map[i, y, x, 3] = point_dist_to_line(r3, r0, point)\n # angle\n geo_map[i, y, x, 4] = rotate_angle\n\n print (geo_map.shape)\n exit()\n\n return score_map, geo_map","def _compute_bounds(self, axis, view):\n return None","def get_centers(file_path = \"./data/input.jpeg\", n_rows=10, n_cols=10, verbose=False, image_thresh=20, hough_thresh=20, minDist=20, maxRadius=20):\n print(\"looking for circles in the image\")\n cimg = cv2.imread(file_path, 1)\n gimg = cv2.cvtColor(cimg, cv2.COLOR_BGR2GRAY)\n gimg = cv2.medianBlur(gimg, 5)\n # threshold the image for better circle finding\n _, gimg = cv2.threshold(gimg, image_thresh, 255, cv2.THRESH_BINARY)\n\n\n # find circles on the image\n circles = cv2.HoughCircles(gimg, cv2.HOUGH_GRADIENT, dp=1, minDist=minDist, param1=1, param2=hough_thresh, minRadius=5,\n maxRadius=maxRadius)\n\n # re-sequence the circles found\n circles = circles[0, :, :].reshape((-1, 3))\n x_min = circles.min(axis=0)[0]\n x_max = circles.max(axis=0)[0]\n avg_spacing = (x_max - x_min) / (n_cols - 1)\n x_segment = [x_min - avg_spacing / 2 + avg_spacing * i for i in range(11)]\n def get_col_id(point):\n # return which col this point sits\n x = point[0]\n for i in range(n_cols):\n if x_segment[i] < x < x_segment[i + 1]:\n return i\n cols = [[] for i in range(n_cols)]\n for circle in circles:\n id = get_col_id(circle)\n cols[get_col_id(circle)].append(circle)\n for i, col in enumerate(cols):\n cols[i] = list(sorted(col, key=lambda p:p[1]))\n grid = np.zeros((n_rows, n_cols, 3))\n for c in range(n_cols):\n for r in range(n_rows):\n grid[r, c, :] = cols[c][r]\n\n # plot theses circles to make sure the sequence is correct\n gaussian_img = cv2.GaussianBlur(cv2.cvtColor(cimg, cv2.COLOR_BGR2GRAY), (5, 5), 0)\n for c in range(10):\n for r in range(10):\n pos = grid[r, c, :2].astype(np.int)\n radius = grid[r, c, 2].astype(np.int)\n # draw the outer circle\n cv2.circle(cimg, (pos[0], pos[1]), radius, (0, 255, 0), 2)\n # draw the center of the circle\n cv2.circle(cimg, (pos[0], pos[1]), 2, (0, 0, 255), 3)\n # find the avg intensity at each center\n grid[r, c, 2] = gaussian_img[pos[1], pos[0]]\n if verbose:\n cv2.imshow('circles found in the image', cimg)\n cv2.waitKey(10)\n\n if verbose:\n cv2.imshow('circles found in the image', cimg)\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n\n return grid","def detector(centre_x, centre_y, height_z, radius, distance):\r\n z = np.linspace(0, height_z, 50)\r\n z = [i+distance for i in z]\r\n \r\n theta = np.linspace(0, 2*np.pi, 50)\r\n theta_grid, z_grid=np.meshgrid(theta, z)\r\n \r\n x_grid = radius*np.cos(theta_grid) + centre_x\r\n y_grid = radius*np.sin(theta_grid) + centre_y\r\n return x_grid, y_grid, z_grid","def face_area(lon_b, lat_b, r_sphere = 6.375e6):\n \n # Convert inputs to radians\n lon_b_rad = lon_b * np.pi / 180.0\n lat_b_rad = lat_b * np.pi / 180.0\n \n r_sq = r_sphere * r_sphere\n n_cs = lon_b.shape[1] - 1\n \n # Allocate output array\n cs_area = np.zeros((n_cs,n_cs))\n \n # Ordering\n valid_combo = np.array([[1,2,4],[2,3,1],[3,2,4],[4,1,3]]) - 1\n \n for i_lon in range(n_cs):\n for i_lat in range(n_cs):\n lon_corner = np.zeros(4)\n lat_corner = np.zeros(4)\n xyz_corner = np.zeros((4,3))\n for i_vert in range(4):\n x_lon = i_lon + (i_vert > 1)\n x_lat = i_lat + (i_vert == 0 or i_vert == 3)\n lon_corner[i_vert] = lon_b_rad[x_lon,x_lat]\n lat_corner[i_vert] = lat_b_rad[x_lon,x_lat]\n for i_vert in range(4):\n xyz_corner[i_vert,:] = ll2xyz(lon_corner[i_vert],lat_corner[i_vert])\n tot_ang = 0.0\n for i_corner in range(4):\n curr_combo = valid_combo[i_corner,:]\n xyz_mini = np.zeros((3,3))\n for i_mini in range(3):\n xyz_mini[i_mini,:] = xyz_corner[curr_combo[i_mini],:]\n curr_ang = sphere_angle(xyz_mini[0,:],xyz_mini[1,:],xyz_mini[2,:])\n tot_ang += curr_ang\n cs_area[i_lon,i_lat] = r_sq * (tot_ang - (2.0*np.pi))\n \n return cs_area","def project_gravity_core(xyz):\n ver = []\n hor = []\n \n # mean for each axis\n G = [np.mean(xyz[:, 0]), np.mean(xyz[:, 1]), np.mean(xyz[:, 2])]\n G_norm = G/np.sqrt(sum(np.power(G, 2)) + 0.0000001)\n \n # The projection is here\n for i in range(len(xyz[:, 0])):\n ver.append(float(np.dot([xyz[i, :]], G)))\n hor.append(float(np.sqrt(np.dot(xyz[i, :]-ver[i]*G_norm, xyz[i, :]-ver[i]*G_norm))))\n \n ver = np.reshape(np.asarray(ver), len(ver))\n return Vectors.dense(ver), Vectors.dense(hor)","def get_zscore_roi_centers(self, timeWindow=(0, 0.5), zscoreThr=2):\n zscoreROION,zscoreROIOFF,zscoreROIALL,allAltPos,allAziPos = self.get_zscore_rois(timeWindow, zscoreThr)\n if zscoreROION is not None:\n centerON = zscoreROION.get_weighted_center_in_coordinate(allAltPos, allAziPos)\n else:\n centerON = None\n\n if zscoreROIOFF is not None:\n centerOFF = zscoreROIOFF.get_weighted_center_in_coordinate(allAltPos, allAziPos)\n else:\n centerOFF = None\n\n if zscoreROIALL is not None:\n centerALL = zscoreROIALL.get_weighted_center_in_coordinate(allAltPos, allAziPos)\n else:\n centerALL = None\n return centerON, centerOFF, centerALL","def compute_bounding_box(homography, w, h):\n corners = np.array([[0,0],\n [0,h],\n [w,0],\n [w,h]])\n t_corners = apply_homography(corners, homography)\n return np.array([t_corners.min(axis=0),t_corners.max(axis=0)],\n dtype= np.int)\n #[top-left, btm-right]","def best_coords(self):\n lat, lon = None, None\n for term in self.terms:\n # print(term)\n # print(term['weight'])\n geo = term.get(\"geo\")\n if geo:\n osm = geo['osm']\n gm = geo['gm']\n geo_data = None\n if osm:\n geo_data = osm\n elif gm:\n geo_data = gm\n if geo_data:\n g = geo_data[0]\n lat, lon = g['latitude'], g['longitude']\n break\n return lat, lon, self.region","def scan(self, cut_off, r0 = 4, dr = 2, rmax = 80, bg_global = 3419, sigma = 3.5 * 13.8):\r\n \r\n start_time = time.time()\r\n for trial in range(self.dimension):\r\n \r\n max_count, max_rank = self.pick_largest(cut_off = cut_off)\r\n fitted = 0 # galaxy not fitted to a circle\r\n point = [] # \r\n circle_number = 0\r\n \r\n if max_count == -1:\r\n print(\"Scan completed, number of galaxies found is \", len(self.galaxies), \"run time is\", time.time() - start_time)\r\n break\r\n \r\n if max_count >= 0: # That means a value that is larger than cut_off exists\r\n ypos,xpos = self.rank_yx(max_rank)\r\n # print(\"max_count, y, x\", max_count, ypos, xpos) \r\n \r\n \r\n for r in range(r0, rmax, dr): # r = radius, we know the largest radius can't be >80 by inspecting the pic.\r\n print(\"locating the galaxy position at\", ypos, xpos, \"at a radius r =\", r) \r\n if fitted == 1 or r == 80:\r\n # print(\"max_count, yx\",max_count, ypos, xpos, \"cut =\", no_cut, len(new_point)/2)\r\n \r\n self.mask_region(ypos, xpos, r - dr)\r\n # print(bg_local, no_bg)\r\n if r - dr > r0: # it must be a galaxy\r\n \r\n # getting the local bg\r\n if no_bg > 3: # check if enough data to deduce bg\r\n bg = bg_local / no_bg \r\n else:\r\n bg = bg_global\r\n \r\n if circle_number >= np.pi* 2* (r - dr)**2:\r\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\r\n\r\n else:\r\n if no_cut < circle_number/2 and circle_number*2 >= np.pi * (r0**2):\r\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\r\n\r\n print(\"\\ngalaxy scan completed,radius =\", r - dr, \"position =\", ypos, xpos, \"max count =\", max_count, \"time = \", time.time() - start_time)\r\n\r\n break\r\n \r\n ##### Resetting parameters ####\r\n no_bg = 0 # number 0f background pixels\r\n bg_local = 0 # sum of local background noises\r\n no_cut = 0 # number of counts below cut off\r\n new_point = [] # pending pixels to be added\r\n ###############################\r\n \r\n if fitted == 0:\r\n \r\n if r == r0:\r\n \r\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\r\n \r\n # Check if it is within the circle radius = 2\r\n if int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\r\n \r\n i,j =[int(i), int(j)]\r\n if self.raw_image_data[j,i] == self.raw_image_data[j,i] *self.masked[j,i]: # Append the ppoint if not masked (masked = 1)\r\n\r\n if self.raw_image_data[j,i] <= cut_off:\r\n no_cut += 1\r\n\r\n if self.raw_image_data[j,i] > cut_off:\r\n point.append(self.raw_image_data[j, i])\r\n circle_number += 1\r\n\r\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\r\n bg_local += self.raw_image_data[j,i]\r\n no_bg += 1\r\n \r\n if no_cut >= len(point)/2 or 2*circle_number < np.pi * r0**2:\r\n fitted = 1\r\n else:\r\n pass\r\n \r\n#######################################################################################################\r\n if r > r0:\r\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): \r\n \r\n # Check if data are in between the previous and the new circle\r\n if (r - dr)**2 < int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\r\n i,j =[int(i), int(j)] # just incase \r\n \r\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]:\r\n\r\n if self.raw_image_data[j,i] <= cut_off:\r\n no_cut += 1\r\n if self.raw_image_data[j,i] > cut_off:\r\n new_point.append(self.raw_image_data[j, i]) # points are pending to be added in\r\n circle_number += 1\r\n\r\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\r\n bg_local += self.raw_image_data[j,i]\r\n no_bg += 1\r\n \r\n # Check if half of the new data points are inside cut off region\r\n if no_cut <= int(len(new_point)/2) or circle_number*2 < np.pi * r**2:\r\n for rannk in range(len(new_point)):\r\n point.append(new_point[rannk])\r\n\r\n else:\r\n fitted = 1","def find_indexName(chosenTile, pointSHP, maskCLD, maskWTR):\n meanindexName = chosenTile[:-4]+'_MEAN.tif'\n if glob.glob(meanindexName) == []: # -- not created yet \n #cloud mask\n command1 = 'gdal_calc.py -A' + chosenTile + ' -B ' + maskCLD + ' --outfile=out1.tif --calc=\"A*(B == 0)+99*(B > 0)\"'\n os.system(command1) \n #water mask\n command2 = 'gdal_calc.py -A out1.tif -B ' + maskWTR + ' --outfile=out2.tif --calc=\"A*(B == 99)+99*(B < 1)\"' \n os.system(command2)\n #no data\n command3 = 'gdal_translate -a_nodata 99 out2.tif ' + meanindexName\n os.system(command3)\n #remove files\n os.remove('out1.tif')\n os.remove('out2.tif')\n stats = zonal_stats(pointSHP, meanindexName)\n indexName_value = stats[0]['mean']\n print '********* VALEUR',indexName_value\n return indexName_value","def check_location_confidence(self):\n\t\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\n\t\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\n\t\tepsilon_meters = .08\n\t\tpixel_distances = []\n\t\tactual_distances = []\n\t\tnum_observed = 0\n\t\tfor ti in self.targs:\n\t\t\tif ti.props_are_set:\n\t\t\t\tfor tj in self.targs:\n\t\t\t\t\tif tj.props_are_set: \n\t\t\t\t\t\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\n\t\t\t\t\t\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\n\t\t\t\t\t\tif pixel_dist == 0:\n\t\t\t\t\t\t\tpixel_dist = 10000 #ignore two of the same points\n\t\t\t\t\t\t\tactual_dist = 10000\n\t\t\t\t\t\tpixel_distances.append(pixel_dist)\t\n\t\t\t\t\t\tactual_distances.append(actual_dist)\n\t\t\t\t\telse:\n\t\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\t\tactual_distances.append(10000)\n\t\t\telse:\n\t\t\t\tfor _ in self.targs:\n\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\tactual_distances.append(10000)\n\t\tmin_ind_pixel = np.argmin(pixel_distances)\n\t\tmin_ind_actual = np.argmin(actual_distances)\n\t\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\n\t\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\n\t\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\n\t\t\t#measurements are not trustworthy, return nothing\n\t\t\treturn None\n\n\t\treturn best_guys","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).transpose()\n bottem_right_x, bottem_right_y = apply_homography(np.array([[w, h]]), homography).transpose()\n\n min_x = min([top_left_x, top_right_x, bottem_left_x, bottem_right_x])[0]\n max_x = max([top_left_x, top_right_x, bottem_left_x, bottem_right_x])[0]\n min_y = min([top_left_y, top_right_y, bottem_left_y, bottem_right_y])[0]\n max_y = max([top_left_y, top_right_y, bottem_left_y, bottem_right_y])[0]\n return np.array([[min_x, min_y], [max_x, max_y]]).astype(int)","def get_bounding_box(self):\n lon, lat = self.coordinates\n\n ll = (np.min(lon),np.min(lat))\n ul = (np.min(lon),np.max(lat))\n ur = (np.max(lon),np.max(lat))\n lr = (np.max(lon),np.min(lat))\n\n return (ll, ul, ur, lr)","def challenge2(self):\n # Let's try an octree-type approach\n # For each grid cube we should be able to find whether a nanobot:\n # 1) is not in range (is outside grid cube and not in range of nearest face)\n # 2) is in range of whole cube (all 8 corners are in range)\n # 3) is in range of part of the cube (i.e. not 1 or 2)\n # Root node: figure out extent of whole space\n mins = []\n maxs = []\n for axis in range(3):\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\n\n for count in range(len(self.nanobots), 0, -1):\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\n if results and results[0].count >= count:\n break\n\n print(f\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\")\n\n # Find result coord closest to origin\n closest_dist = np.iinfo(np.int32).max\n best_coord = None\n for result in results:\n for corner in itertools.product(*zip(result.mins, result.maxs)):\n d = manhattan_dist(corner, (0, 0, 0))\n if d < closest_dist:\n closest_dist = d\n best_coord = corner\n\n print(f\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\")","def get_bounds(self):\n log.debug(str(inspect.stack()[1][3]) + \"--> OC.get_bounds()\")\n\n # TODO: Move the operation out of here.\n\n xmin = Inf\n ymin = Inf\n xmax = -Inf\n ymax = -Inf\n\n # for obj in self.object_list:\n for obj in self.get_list():\n try:\n gxmin, gymin, gxmax, gymax = obj.bounds()\n xmin = min([xmin, gxmin])\n ymin = min([ymin, gymin])\n xmax = max([xmax, gxmax])\n ymax = max([ymax, gymax])\n except Exception as e:\n log.warning(\"DEV WARNING: Tried to get bounds of empty geometry. %s\" % str(e))\n\n return [xmin, ymin, xmax, ymax]","def average_normal_projections(fr,mvec,pivot,maxflux,do_inflate=False):\n\tglobal surf,surfs,mesh\n\t#---! getting: calcs/codes/mesh.py:24: RuntimeWarning: invalid value encountered in divide ... in vecnorm\n\t#---inflate the instantaneous surface\n\tthis_surf_inflated = surfs[fr]#inflate_lateral(surfs[fr],inflate_factor)\n\t#---find the points on the instantaneous surface which are nearest the points on the regular grid on the average\n\t#---convert instantaneous points to XYZ with the reference box vectors mvec\n\tinstant_all = boxstuff(height_recenter(literalize(this_surf_inflated,mvec),pivot=pivot,maxflux=maxflux),mvec)\n\t#---after literalizing the inflated points, we take only the points which are relevant to the base structure\n\t#---! is the order correct?\n\tif do_inflate:\n\t\tsource = surf_average_base\n\t\tinds = np.concatenate(np.transpose(np.meshgrid(*[np.arange(-inflate_factor,i+inflate_factor+1) \n\t\t\tfor i in source.shape])))\n\t\tbase = np.where(np.all((np.all(inds>0,axis=1),np.all(np.array(source.shape)>=inds,axis=1)),axis=0))[0]\n\t\tinstant = instant_all[base]\n\telse: instant = instant_all\n\t#---note that we make a tree from the instantaneous points then probe over the average surface\n\t#---! more efficient to do this in reverse, however it might not cover all of the average/reference points?\n\t#---prepare a KDTree. we use a fudge factor of 1000 epsilon to avoid angry errors about being outside the box\n\ttree = scipy.spatial.ckdtree.cKDTree(instant,boxsize=np.concatenate((mvec,mvec))+1000.*eps)\n\t#---find the nearest reference points for each instantaneous point\n\tclose,nns = tree.query(surf,k=1)\n\t#---given a mapping between instantaneous point and target position (on XY), project the instantaneous point\n\t#---...onto the tangent plane given by the reference point. note that this is obviously a minor approximation in \n\t#---...which we assume that the point is hovering \"above\" the reference point close enough that the projection onto\n\t#---...that tangent plane is correct. a more literal form of this might actually try to find the exact distance to \n\t#---...the triangle adjacent to the nearest reference vertex, but this would require adding extra neighbor\n\t#---...information and I think it takes the surface a bit too literally.\n\t#---! note that we could use the real points instead of regular grid points for the instantaneous point?\n\tdeviations = np.array([\n\t\tget_normal_fluctuation(\n\t\t\tnormal=mesh['vertnorms'][index],\n\t\t\ttarget=surf[index],\n\t\t\thover=instant[nns][index],\n\t\t\tvec=mvec) \n\t\tfor ii,index in enumerate(nns)])\n\t#---corners fail for whatever reason. could not get the do_inflate method working\n\tdeviations[np.isnan(deviations)] = 0.0\n\treturn deviations","def empirical_cor(l):\n\n global fig_dphi\n\n # first clean los\n maps_temp = np.matrix.copy(maps[:,:,l]) - np.matrix.copy(models[:,:,l])\n\n # no estimation on the ref image set to zero \n if np.nansum(maps[:,:,l]) != 0:\n\n maxlos,minlos=np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],float(arguments[\"--perc_los\"])),np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],100-float(arguments[\"--perc_los\"]))\n logger.debug('Set Max-Min LOS for empirical estimation: {0}-{1}'.format(maxlos,minlos))\n kk = np.nonzero(np.logical_or(maps_temp==0.,np.logical_or((maps_temp>maxlos),(maps_temp<minlos))))\n maps_temp[kk] = float('NaN')\n\n itemp = ibeg_emp\n for lign in range(ibeg_emp,iend_emp,10):\n if np.isnan(np.nanmean(maps[lign:lign+10,:,l])):\n itemp = lign\n else:\n break\n logger.debug('Begining of the image: {}'.format(itemp))\n\n if arguments[\"--topofile\"] is not None:\n ax_dphi = fig_dphi.add_subplot(4,int(N/4)+1,l+1)\n else:\n ax_dphi = None\n\n logger.debug('Threshold RMS: {}'.format(float(arguments[\"--threshold_rms\"])))\n\n # selection pixels\n index = np.nonzero(np.logical_and(elev<maxtopo,\n np.logical_and(elev>mintopo,\n np.logical_and(mask_flat>float(arguments[\"--threshold_mask\"]),\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(~np.isnan(rmsmap),\n np.logical_and(~np.isnan(elev),\n np.logical_and(rmsmap<float(arguments[\"--threshold_rms\"]),\n np.logical_and(rmsmap>1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>ibeg_emp,\n np.logical_and(pix_az<iend_emp,\n np.logical_and(pix_rg>jbeg_emp,\n np.logical_and(pix_rg<jend_emp, \n slope>0.,\n ))))))))\n ))))))\n\n # extract coordinates for estimation\n temp = np.array(index).T\n x = temp[:,0]; y = temp[:,1]\n # clean maps\n los_clean = maps_temp[index].flatten()\n topo_clean = elev[index].flatten()\n rms_clean = rmsmap[index].flatten()\n \n logger.debug('Number of points for empirical estimation: {}'.format(len(los_clean)))\n if len(los_clean) < 1:\n logger.critical('No points left for empirical estimation. Exit!')\n logger.critical('threshold RMS: {0}, threshold Mask: {1}, Min-Max LOS: {2}-{3}, Min-Max topo: {4}-{5}, lines: {6}-{7}, \\\n cols: {8}- {9}'.format(float(arguments[\"--threshold_rms\"]),float(arguments[\"--threshold_mask\"]),minlos,maxlos,mintopo,maxtopo,ibeg_emp,iend_emp,jbeg_emp,jend_emp))\n sys.exit()\n\n # print itemp, iend_emp\n if flat>5 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\n logger.warning('Image too short in comparison to master, set flat to 5')\n temp_flat=5\n else:\n temp_flat=flat\n\n if ivar>0 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\n logger.warning('Image too short in comparison to master, set ivar to 0')\n ivar_temp=0\n nfit_temp=0\n else:\n ivar_temp=ivar\n nfit_temp=nfit\n\n # call ramp estim\n los = as_strided(maps[:,:,l]).flatten()\n samp = int(arguments[\"--emp_sampling\"])\n\n map_ramp, map_flata, map_topo, rmsi = estim_ramp(los,los_clean[::samp],topo_clean[::samp],x[::samp],\\\n y[::samp],temp_flat,rms_clean[::samp],nfit_temp, ivar_temp, l, ax_dphi)\n\n if (lin_start is not None) and (lin_end is not None):\n # try:\n indexref = np.nonzero(np.logical_and(elev<maxtopo,\n np.logical_and(elev>mintopo,\n np.logical_and(mask_flat>float(arguments[\"--threshold_mask\"]),\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(~np.isnan(rmsmap),\n np.logical_and(~np.isnan(elev),\n np.logical_and(rmsmap<float(arguments[\"--threshold_rms\"]),\n np.logical_and(rmsmap>1.e-6,\n np.logical_and(~np.isnan(maps_temp),\n np.logical_and(pix_az>lin_start,\n np.logical_and(pix_az<lin_end,\n np.logical_and(pix_rg>col_start,\n np.logical_and(pix_rg<col_end, \n slope>0.,\n ))))))))))))\n ))\n \n if len(indexref[0]) == 0:\n logger.warning('Ref zone is empty! Re-define --ref_zone argument. Exit!')\n sys.exit()\n\n ## Set data minus temporal model to zero in the ref area\n zone = as_strided(map_flata[:,:] - models[:,:,l])\n los_ref2 = zone[indexref].flatten()\n rms_ref = rmsmap[indexref].flatten()\n amp_ref = 1./rms_ref\n amp_ref = amp_ref/np.nanmax(amp_ref)\n # weigth avera of the phase\n cst = np.nansum(los_ref2*amp_ref) / np.nansum(amp_ref)\n logger.info('Re-estimation of a constant within lines {0}-{1} and cols {2}-{3}'.format(lin_start,lin_end,col_start,col_end))\n logger.info('Average phase within ref area: {0}:'.format(cst))\n if np.isnan(cst):\n cst = 0.\n map_ramp, map_flata = map_ramp + cst, map_flata - cst\n del zone\n \n else:\n map_flata = np.copy(maps[:,:,l])\n map_ramp, map_topo = np.zeros(np.shape(map_flata)), np.zeros(np.shape(map_flata))\n rmsi = 1\n\n # set ramp to NaN to have ramp of the size of the images\n kk = np.nonzero(np.isnan(map_flata))\n ramp = as_strided(map_ramp)\n ramp[kk] = float('NaN')\n topo = as_strided(map_topo)\n topo[kk] = float('NaN')\n del ramp, topo\n \n return map_ramp, map_flata, map_topo, rmsi","def bounds(self):\n return self._bboxes[0][0] #TODO: merge all coverages","def search_coord_with_max_nanobots(self, mins, maxs, fully_in_range, maybe_partially_in_range, best_count=0):\n # Figure out how many of maybe_partially_in_range are actually in range of this whole cube\n # or if they're completely out of range\n cube = OctreeNode(mins, maxs)\n new_fully_in_range = fully_in_range.copy()\n new_partially_in_range = []\n for nanobot in maybe_partially_in_range:\n if cube.nanobot_in_range_of_whole_node(nanobot):\n new_fully_in_range.append(nanobot)\n elif cube.in_node(nanobot.coord) or cube.in_range_if_outside(nanobot):\n new_partially_in_range.append(nanobot)\n\n # If we're not potentially at least as good as best_count, no results worth returning\n if len(new_fully_in_range) + len(new_partially_in_range) < best_count:\n return []\n\n # If none are partially in range, we know the answer for this node!\n if not new_partially_in_range:\n return [SearchResult(mins, maxs, len(new_fully_in_range))]\n\n # If this node is only 0 or 1 units long in each direction, we can't subdivide\n big_enough = False\n for axis in range(3):\n if maxs[axis] - mins[axis] > 1:\n big_enough = True\n\n all_results = []\n if not big_enough:\n # Manually test all 8 corners (ignoring duplicate corners, if any)\n points_tested = set()\n for corner in itertools.product(*zip(mins, maxs)):\n if corner not in points_tested:\n points_tested.add(corner)\n new_best_count = len(new_fully_in_range) + len([nanobot for nanobot in new_partially_in_range\n if manhattan_dist(nanobot.coord, corner) <= nanobot.r])\n if new_best_count >= best_count:\n best_count = new_best_count\n all_results += [SearchResult(corner, corner, new_best_count)]\n \n else:\n # Otherwise, divide into 8 subcubes and recursively search\n midpoint = []\n for axis in range(3):\n midpoint.append((mins[axis] + maxs[axis]) // 2)\n\n axis_coords = list(zip(mins, midpoint, maxs))\n for corner_index in itertools.product(*zip([0, 0, 0], [1, 1, 1])):\n subcube_mins = []\n subcube_maxs = []\n for axis in range(3):\n subcube_mins.append(axis_coords[axis][corner_index[axis]])\n subcube_maxs.append(axis_coords[axis][corner_index[axis] + 1])\n\n results = self.search_coord_with_max_nanobots(subcube_mins,\n subcube_maxs,\n new_fully_in_range,\n new_partially_in_range,\n best_count)\n \n # Result counts should all be the same\n if results and results[0].count >= best_count:\n all_results += results\n\n # Keep the result(s) with the highest count\n return [result for result in all_results if result.count == best_count]","def do_intensity_projection(points, proj_W , proj_H, proj_fov_up, proj_fov_down, fn, idx):\n\n # print(points.shape)\n\n points = points[points.any(axis=1)]\n\n proj_range = np.zeros((proj_H, proj_W),\n dtype=np.float64)\n\n # unprojected range (list of depths for each point)\n unproj_range = np.zeros((0, 1), dtype=np.float32)\n\n # projected point cloud xyz - [H,W,3] xyz coord (-1 is no data)\n proj_xyz = np.full((proj_H, proj_W, 4), -1,\n dtype=np.float32)\n\n # projected remission - [H,W] intensity (-1 is no data)\n proj_remission = np.full((proj_H, proj_W), -1,\n dtype=np.float32)\n\n # projected index (for each pixel, what I am in the pointcloud)\n # [H,W] index (-1 is no data)\n proj_idx = np.full((proj_H, proj_W), -1,\n dtype=np.int32)\n\n # for each point, where it is in the range image\n proj_x = np.zeros((0, 1), dtype=np.int32) # [m, 1]: x\n proj_y = np.zeros((0, 1), dtype=np.int32) # [m, 1]: y\n\n # mask containing for each pixel, if it contains a point or not\n proj_mask = np.zeros((proj_H, proj_W),\n dtype=np.int32) # [H,W] mask\n\n\n\n\n # laser parameters\n fov_up = proj_fov_up / 180.0 * np.pi # field of view up in rad\n fov_down = proj_fov_down / 180.0 * np.pi # field of view down in rad\n fov = abs(fov_down) + abs(fov_up) # get field of view total in rad\n\n\n \n depth = np.linalg.norm(points[:,:3], 2, axis=1)\n\n # print(points[:10,:])\n \n\n # get scan components\n scan_x = points[:, 0]\n scan_y = points[:, 1]\n scan_z = points[:, 2]\n\n # get angles of all points\n yaw = -np.arctan2(scan_y, scan_x) \n pitch = np.arcsin(scan_z / depth)\n\n # get projections in image coords\n proj_x = 0.5 * (yaw / np.pi + 1.0) # in [0.0, 1.0]\n proj_y = 1.0 - (pitch + abs(fov_down)) / fov # in [0.0, 1.0]\n\n proj_x = np.nan_to_num(proj_x)\n\n proj_y = np.nan_to_num(proj_y)\n # scale to image size using angular resolution\n proj_x *= proj_W # in [0.0, W]\n proj_y *= proj_H # in [0.0, H]\n\n \n \n\n # round and clamp for use as index\n proj_x = np.floor(proj_x)\n proj_x = np.minimum(proj_W - 1, proj_x)\n proj_x = np.maximum(0, proj_x).astype(np.int32) # in [0,W-1]\n proj_x = np.copy(proj_x) # store a copy in orig order\n\n proj_y = np.floor(proj_y)\n proj_y = np.minimum(proj_H - 1, proj_y)\n proj_y = np.maximum(0, proj_y).astype(np.int32) # in [0,H-1]\n\n proj_y = np.copy(proj_y) # stope a copy in original order\n\n\n # # copy of depth in original order\n # unproj_range = np.copy(depth)\n\n # indices = np.arange(depth.shape[0])\n # order = np.argsort(depth)[::-1]\n # depth = depth[order]\n # indices = indices[order]\n # points = points[order]\n\n # proj_y = proj_y[order]\n # proj_x = proj_x[order]\n \n\n if DATASET_TYPE == \"kitti\":\n intensities = points[:,3]\n print(\"kitti\")\n # intensities = np.minimum(intensities, 1000)\n # i_min = intensities.min()\n # i_max = intensities.max()\n # intensities = (intensities - i_min)/(i_max - i_min)\n\n\n\n if DATASET_TYPE == \"mulran\" or DATASET_TYPE == \"mulran2\":\n intensities = points[:,3]\n intensities = np.minimum(intensities, 1000)\n i_min = intensities.min()\n i_max = intensities.max()\n \n intensities = (intensities - i_min)/(i_max - i_min)\n\n if DATASET_TYPE == \"dso\":\n \n \n \n intensities = points[:,4]\n \n\n minval = np.percentile(intensities, 2)\n maxval = np.percentile(intensities, 98)\n intensities = np.clip(intensities, minval, maxval)\n # intensities = np.maximum(intensities, 5000)\n # intensities = np.sqrt(intensities)\n\n \n\n\n \n i_min = intensities.min()\n i_max = intensities.max()\n\n intensities = (intensities - i_min)/(i_max - i_min)\n\n \n\n\n \n\n \n\n \n \n\n\n \n \n \n \n \n pixel_tracker = {}\n pc_tracker = {}\n # print(proj_x.shape)\n # print(scan_x.shape)\n\n \n proj_3d_corres = np.zeros((proj_H, proj_W, 3),\n dtype=np.float64)\n\n # print(proj_x[:20])\n # print(proj_y[:70])\n \n \n for i in range(proj_x.shape[0]):\n x_val = proj_x[i]\n y_val = proj_y[i]\n\n \n\n if proj_range[y_val, x_val] != 0:\n continue\n\n \n \n intensity = intensities[i]\n \n \n \n \n proj_range[y_val, x_val] = intensity\n \n proj_3d_corres[y_val,x_val, :] = np.array([scan_x[i], scan_y[i], scan_z[i]])\n \n\n\n \n proj_range *= 255\n\n\n \n \n \n \n proj_range = np.array(proj_range, dtype=np.uint8)\n\n \n newPicPath = None\n\n\n \n\n\n img = Image.fromarray(proj_range, 'L')\n pc_name = fn.split('.')[0]\n newPicPath = os.path.join(CURRENT_DIR, \"intensity_images\", \"mulran_\" + (str(idx)) + \".png\")\n img.save(newPicPath)\n\n\n return newPicPath, proj_3d_corres, proj_range","def detect(self, score_map, geo_map, score_map_thresh=common.SCORE_MAP_THRESH,\n box_thresh=common.BOX_THRESH, nms_thres=common.NMS_TRESH):\n if len(score_map.shape) == 4:\n score_map = score_map[0, :, :, 0]\n geo_map = geo_map[0, :, :, ]\n # filter the score map\n xy_text = np.argwhere(score_map > score_map_thresh)\n # sort the text boxes via the y axis\n xy_text = xy_text[np.argsort(xy_text[:, 0])]\n # restore\n text_box_restored = restore_rectangle(xy_text[:, ::-1] * 4, geo_map[xy_text[:, 0], xy_text[:, 1], :]) # N*4*2\n boxes = np.zeros((text_box_restored.shape[0], 9), dtype=np.float32)\n boxes[:, :8] = text_box_restored.reshape((-1, 8))\n boxes[:, 8] = score_map[xy_text[:, 0], xy_text[:, 1]]\n # nms part\n boxes = lanms.merge_quadrangle_n9(boxes.astype('float32'), nms_thres)\n\n if boxes.shape[0] == 0:\n return boxes\n\n # here we filter some low score boxes by the average score map, this is different from the orginal paper\n for i, box in enumerate(boxes):\n mask = np.zeros_like(score_map, dtype=np.uint8)\n cv2.fillPoly(mask, box[:8].reshape((-1, 4, 2)).astype(np.int32) // 4, 1)\n boxes[i, 8] = cv2.mean(score_map, mask)[0]\n boxes = boxes[boxes[:, 8] > box_thresh]\n\n return boxes","def get_grid_mappings(weighed_sum,\n use_defaults=True,min_index_row_peaks =40):\n # Detect peaks\n col_peaks = indices_highest_peaks(weighed_sum, 0)\n row_peaks = indices_highest_peaks(weighed_sum, 1)\n \n # Map col_peaks to Hz values\n if len(col_peaks) == len(HZ):\n mapping_Hz = dict(zip(HZ,col_peaks)) \n \n # Map adjusted col_peaks to Hz values\n else:\n try: \n col_peaks =adjust_arr_peaks(weighed_sum,col_peaks,len(HZ),0)\n mapping_Hz = dict(zip(HZ,col_peaks)) \n \n # Map adjusted HZ values to default coordinates if need be\n if use_defaults:\n for i,key in enumerate(HZ):\n if mapping_Hz[key] > UPPER_LIMIT_HZ_COORD[i] or mapping_Hz[key] < LOWER_LIMIT_HZ_COORD[i]:\n mapping_Hz[key] = DEFAULT_HZ_COORD[i]\n except:\n if use_defaults:\n mapping_Hz = dict(zip(HZ,DEFAULT_HZ_COORD )) \n else: \n return np.nan,np.nan,np.nan,np.nan\n \n \n row_peaks = row_peaks[row_peaks > min_index_row_peaks]\n \n try:\n row_100 = row_peaks[0] #Should be around 30 for 100 km\n row_200 = row_peaks[1] #Should be around 30 for 100 km\n except:\n if use_defaults:\n row_100 = KM_DEFAULT_100\n row_200 = KM_DEFAULT_200 \n else: \n return np.nan,np.nan,np.nan,np.nan\n \n if use_defaults:\n if abs(row_100 - KM_DEFAULT_100) > abs(KM_DEFAULT_200 - KM_DEFAULT_100):\n row_100 = KM_DEFAULT_100\n if abs(row_200 - KM_DEFAULT_200) > abs(KM_DEFAULT_200 - KM_DEFAULT_100):\n row_200 = KM_DEFAULT_200 \n \n mapping_km = {100:row_100,200:row_200}\n\n return col_peaks,row_peaks,mapping_Hz, mapping_km","def bounds(self, pos):","def _area(bounds):\n return (bounds[0, 1] - bounds[0, 0]) * (bounds[1, 1] - bounds[1, 0])","def get_geo_extents(nc, possible_units, std_name, axis_name, short_name):\n\n geo_extent_vars = {}\n geo_extent_units = []\n\n # variables must have units\n for var in nc.get_variables_by_attributes(units=lambda x: x is not None):\n \n geo_extent_vars[var.name] = 0\n # units in this set\n if var.units in possible_units:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n\n # standard name\n if hasattr(var, 'standard_name') and var.standard_name == std_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n # axis of \"X\"\n if hasattr(var, 'axis') and var.axis == axis_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n \n\n if var.name == std_name or var.name == short_name:\n geo_extent_vars[var.name] += 1\n geo_extent_units.append(var.units)\n\n if len(geo_extent_vars) == 0:\n return\n\n # filter out any zero scores\n geo_extent_vars = dict(filter(lambda x: x[1]>0, geo_extent_vars.items()))\n\n # sort by criteria passed\n final_geo_vars = sorted(geo_extent_vars, key=lambda x: geo_extent_vars[x], reverse=True)\n\n obs_mins = [np.nanmin(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n obs_maxs = [np.nanmax(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n\n # Let's just pick one\n geo_vals = nc.variables[final_geo_vars[0][:]]\n if geo_vals.size == 1:\n obs_res = [0.0]\n else:\n obs_res = [np.nanmean(np.diff(nc.variables[var])) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\n\n geo_min = round(float(min(obs_mins)), 5)\n geo_max = round(float(max(obs_maxs)), 5)\n geo_extent_units = [nc.variables[k].units for k, v in geo_extent_vars.items()][0]\n geo_res = \"{} {}\".format(round(float(abs(np.mean(obs_res))), 5), geo_extent_units)\n\n print('<attribute name=\"geospatial_{}_min\" value=\"{}\" />'.format(short_name, geo_min))\n print('<attribute name=\"geospatial_{}_max\" value=\"{}\" />'.format(short_name, geo_max))\n print('<attribute name=\"geospatial_{}_resolution\" value=\"{}\" />'.format(short_name, geo_res))\n print('<attribute name=\"geospatial_{}_units\" value=\"{}\" />'.format(short_name, geo_extent_units))","def background_detection(dataset, radius, normal_threshold):\n length = len(dataset)\n normal_list = []\n tree = scipy.spatial.cKDTree(dataset)\n for x, y, z in zip(original_x_int_array, original_y_int_array, original_z_int_array):\n indices = tree.query_ball_point([x, y, z], radius)\n if len(indices) <= 3:\n normal_list.append(0)\n continue\n idx = tuple(indices)\n data = np.vstack([dataset[idx, 0], dataset[idx, 1], dataset[idx, 2]])\n cov = np.cov(data)\n evals, evects = la.eigh(cov)\n evals = np.abs(evals)\n index = evals.argsort()[::-1]\n evects = evects[:, index]\n normal = evects[2][2]\n normal_list.append(normal)\n\n # codes below were region growing algorithm implemented based pseudocode in\n # http://pointclouds.org/documentation/tutorials/region_growing_segmentation.php#region-growing-segmentation\n # awailable voxel list index\n seeds = np.logical_or(np.array(normal_list) > normal_threshold, np.array(normal_list) < -normal_threshold)\n\n seeds = list(np.where(seeds)[0])\n\n voxel_set = np.vstack([original_x_int_array[seeds], original_y_int_array[seeds],\n original_z_int_array[seeds]]).transpose()\n regions = region_growing(voxel_set, GROUND_NEIGHBOR / VOXEL_SIZE)\n\n seeds = np.array(seeds)\n ground = []\n max_len = 0\n if len(regions) == 1:\n ground += seeds[regions[0]]\n else:\n for region in regions:\n if len(region) > max_len:\n max_len = len(region)\n ground = []\n ground = seeds[region]\n # if float(len(region)) / length < 0.2:\n # continue\n # else:\n # ground += list(seeds[region])\n # if len(ground) == 0:\n # ground.append(temp_ground)\n return normal_list, ground","def get_object_centers(data, north_offset, east_offset, drone_altitude, safety_distance):\n points = []\n for i in range(data.shape[0]):\n north, east, alt, d_north, d_east, d_alt = data[i, :]\n if alt + d_alt + safety_distance > drone_altitude:\n points.append([north - north_offset, east - east_offset])\n return points;","def fit_galaxy(self, ypos, xpos, r_in, r_out = 0):\r\n count_out = []\r\n count_in = []\r\n for j, i in product(np.arange(ypos - (r_out + r_in), ypos + r_out + r_in + 1),np.arange(xpos - (r_out + r_in), xpos + 1 + r_out + r_in)): # Create square\r\n if (j - ypos) ** 2 + (i - xpos) ** 2 <= r_in ** 2 and 0<= j <= self.shapes[0] - 1 and 0<= i <= self.shapes[1] - 1: # make sure points are in a circle\r\n j = int(j)\r\n i = int(i)\r\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]:\r\n count_in.append(self.raw_image_data[j,i])\r\n self.masked[j,i] = 0 # self.mask_region runs the for loop again\r\n if r_in ** 2 < (j - ypos) ** 2 + (i - xpos) ** 2 <= (r_in + r_out)**2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1: # in the outer ring\r\n j = int(j)\r\n i = int(i)\r\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]: \r\n count_out.append(self.raw_image_data[j][i]) \r\n self.masked[j,i]\r\n return count_in, count_out","def getVisualFieldOrigin(self):\r\n\r\n if not hasattr(self, 'finalPatchesMarked'):\r\n raise LookupError('Please mark the final patches first!!')\r\n\r\n if not hasattr(self, 'altPosMapf'):\r\n _ = self._getSignMap()\r\n\r\n try:\r\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\r\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\r\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\r\n\r\n overlap = 0 # number of overlaping pixels\r\n iterNum = 1 # number of iteration\r\n while overlap < 1:\r\n # print 'Iteration number for finding overlapping pixel:', iterNum\r\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\r\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\r\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\r\n totalField = V1 + LM + RL\r\n # plt.imshow(totalField)\r\n overlap = len(np.argwhere(totalField == 3))\r\n iterNum += 1\r\n # print 'Number of overlapping pixels:', overlap\r\n # plt.show()\r\n\r\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\r\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\r\n\r\n except KeyError:\r\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\nSetting origins to 0 ...')\r\n altPosOrigin = 0.\r\n aziPosOrigin = 0.\r\n\r\n return altPosOrigin, aziPosOrigin","def box_results_for_corloc(scores, boxes): # NOTE: support single-batch\n num_classes = cfg.MODEL.NUM_CLASSES + 1\n cls_boxes = [[] for _ in range(num_classes)]\n # Apply threshold on detection probabilities and apply NMS\n # Skip j = 0, because it's the background class\n for j in range(1, num_classes):\n max_ind = np.argmax(scores[:, j])\n cls_boxes[j] = np.hstack((boxes[max_ind, :].reshape(1, -1),\n np.array([[scores[max_ind, j]]])))\n\n im_results = np.vstack([cls_boxes[j] for j in range(1, num_classes)])\n boxes = im_results[:, :-1]\n scores = im_results[:, -1]\n return scores, boxes, cls_boxes","def get_bounding_box(self, maxdist):\n lon = self.location.longitude\n lat = self.location.latitude\n maxradius = self._get_max_rupture_projection_radius()\n a1 = (maxdist + maxradius) * KM_TO_DEGREES\n a2 = angular_distance(maxdist + maxradius, lat)\n return lon - a2, lat - a1, lon + a2, lat + a1","def get_score(location, grid, shape):","def extract_k_space_center(samples, samples_locations,\n thr=None, img_shape=None):\n if thr is None:\n if img_shape is None:\n raise ValueError('target image cartesian image shape must be fill')\n raise NotImplementedError\n else:\n samples_thresholded = np.copy(samples)\n samples_thresholded *= (samples_locations[:, 0] <= thr)\n samples_thresholded *= (samples_locations[:, 1] <= thr)\n return samples_thresholded","def get_bounds(self):\n x_max = self.data['x'].max()\n y_max = self.data['y'].max()\n z_max = self.data['z'].max()\n print(\"x={}; y={}; z={}\".format(x_max, y_max, z_max))\n return (x_max, y_max, z_max)","def getSearchSpaceCoords(self):","def nms_all_class(bound_corr_objs, nms_thresh):\n bboxs, scores, masks, labels = [], [], [], []\n for obj in bound_corr_objs:\n bboxs.append(obj['box'])\n scores.append(obj['score'])\n # masks.append(obj['mask'])\n # labels.append(obj['label'])\n bboxs = np.asarray(bboxs)\n scores = np.asarray(scores)\n # masks = np.asarray(masks)\n # labels = np.asarray(labels)\n x1 = bboxs[:, 0]\n y1 = bboxs[:, 1]\n x2 = bboxs[:, 2]\n y2 = bboxs[:, 3]\n areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n # cfvalid_ids = np.where(scores >= cf_thresh)[0]\n # scores = scores[cfvalid_ids]\n\n order = scores.argsort()[::-1]\n # mask_sizes = np.sum(masks, axis=(1, 2))\n # order = mask_sizes.argsort()[::-1]\n keep = []\n suppress = []\n while order.size > 0:\n i = order[0]\n keep.append(i)\n xx1 = np.maximum(x1[i], x1[order[1:]])\n yy1 = np.maximum(y1[i], y1[order[1:]])\n xx2 = np.minimum(x2[i], x2[order[1:]])\n yy2 = np.minimum(y2[i], y2[order[1:]])\n w = np.maximum(0.0, xx2 - xx1 + 1)\n h = np.maximum(0.0, yy2 - yy1 + 1)\n inter = w * h\n iou = inter / (areas[i] + areas[order[1:]] - inter)\n\n # mask_other = masks[order[1:], :, :]\n # mask_cur = masks[i, :, :]\n # mask_inter = np.sum(mask_cur & mask_other, axis=(1, 2))\n # mask_union = np.sum(mask_cur | mask_other, axis=(1, 2))\n # mask_iou = mask_inter / mask_union\n\n # inds = np.where((iou <= nms_thresh) & (mask_iou <= nms_thresh))[0]\n inds = np.where(iou <= nms_thresh)[0]\n order = order[inds + 1]\n\n # masks = masks[keep]\n # ids = ids[keep]\n return keep","def rectCenter(rect):\n return np.array([rect[:2].mean(), rect[2:].mean()])","def eval_detection(gt_mask, r):\n ids = np.unique(r['class_ids'])\n merged_masks = {}\n qualities = dict([(1,0), (2,0), (3,0)])\n\n for i in ids:\n merged_masks[i] = (np.zeros_like(r['masks'][:,:,0]) > 0)\n n_masks = r['masks'].shape[-1]\n for c in range(n_masks):\n if i != r['class_ids'][c] or r['scores'][c] < .7:\n continue\n\n mask = r['masks'][:,:,c]\n merged_masks[i] |= mask\n\n gt_mask_i = (gt_mask[:,:,i-1] > 0)\n intersection = gt_mask_i & merged_masks[i]\n union = gt_mask_i | merged_masks[i]\n qualities[i] = np.sum(intersection) / np.sum(union)\n \n return qualities, merged_masks","def get_bounds_halo(self):\n bottom_right = np.asarray([self.coords_halo[k][0] for k in range(self.dim)])\n upper_left = np.asarray([self.coords_halo[k][-1] for k in range(self.dim)])\n return bottom_right, upper_left","def normal_nms(self, all_boxes, all_scores, thresh=0.5, max_boxes=100):\n x1 = all_boxes[:, 0]\n y1 = all_boxes[:, 1]\n x2 = all_boxes[:, 2]\n y2 = all_boxes[:, 3]\n areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n order = all_scores.argsort()[::-1]\n keep = []\n while order.size > 0:\n i = order[0]\n keep.append(i)\n if len(keep) >= max_boxes:\n break\n xx1 = np.maximum(x1[i], x1[order[1:]])\n yy1 = np.maximum(y1[i], y1[order[1:]])\n xx2 = np.minimum(x2[i], x2[order[1:]])\n yy2 = np.minimum(y2[i], y2[order[1:]])\n w = np.maximum(0.0, xx2 - xx1 + 1)\n h = np.maximum(0.0, yy2 - yy1 + 1)\n inter = w * h\n ovr = inter / (areas[i] + areas[order[1:]] - inter)\n inds = np.where(ovr <= thresh)[0]\n order = order[inds + 1]\n return keep","def compute_crowd_metrics(bbox, virtual_radius=0.45):\n\n # 0. all_det\n all_det = np.shape(bbox)[0]\n\n # 1. all_dist: all pedestrain from qolo\n # all_dist = np.linalg.norm(bbox[:, [0, 1]], axis=1)\n bbox_xy = bbox[:, [0, 1]]\n all_dist = np.linalg.norm(bbox_xy, axis=1)\n\n # consider qolo capsule\n # print(\"Considered virtual radius is {} m.\".format(virtual_radius))\n capsule_qolo = Capsule(0.18, -0.5, virtual_radius)\n all_dist_capsuled = np.ones([all_det]) * np.inf\n for idx in range(all_det):\n x_dist = bbox_xy[idx, 0]\n y_dist = bbox_xy[idx, 1]\n all_dist_capsuled[idx] = capsule_qolo.distanceLocal(x_dist, y_dist)\n\n # 2. within_det\n within_det2_5 = np.sum(np.less(all_dist, 2.5))\n within_det3 = np.sum(np.less(all_dist, 3.0))\n within_det5 = np.sum(np.less(all_dist, 5.0))\n within_det10 = np.sum(np.less(all_dist, 10.0))\n\n # 3. min_dist/proximity: all_dist_capsuled or all_dist\n # only consider the dist larger than )\n min_dist = min(all_dist_capsuled)\n\n # 4. crowd_density\n crowd_density2_5 = within_det2_5 / (np.pi * 2.5 ** 2)\n crowd_density3 = within_det3 / (np.pi * 3.0 ** 2)\n crowd_density5 = within_det5 / (np.pi * 5.0 ** 2)\n crowd_density10 = within_det10 / (np.pi * 10.0 ** 2)\n\n return (\n all_det,\n within_det2_5,\n within_det3,\n within_det5,\n within_det10,\n crowd_density2_5,\n crowd_density3,\n crowd_density5,\n crowd_density10,\n min_dist,\n )","def calculate_laser_center(self):\n image = np.copy(self.camera_fiber.temp_image)\n brightest = np.unravel_index(image.argmax(), image.shape)\n self.laser_center = self.calculate_gaussian_centroid(image, brightest[0], brightest[1], crop_size=25)","def center(coords):\n for c in coords:\n if 'avg' not in locals():\n avg = c\n else:\n avg += c\n return avg / len(coords)","def grid_area(cs_grid=None,cs_res=None):\n # Calculate area on a cubed sphere\n if cs_res is None:\n cs_res = cs_grid['lon_b'].shape[-1] - 1\n elif cs_grid is None:\n cs_grid = cubedsphere.csgrid_GMAO(cs_res)\n elif cs_grid is not None and cs_res is not None:\n assert cs_res == cs_grid['lon_b'].shape[-1], 'Routine grid_area received inconsistent inputs' \n cs_area = np.zeros((6,cs_res,cs_res))\n cs_area[0,:,:] = face_area(cs_grid['lon_b'][0,:,:],cs_grid['lat_b'][0,:,:])\n for i_face in range(1,6):\n cs_area[i_face,:,:] = cs_area[0,:,:].copy()\n return cs_area","def fix_sphere_h (center_x, center_y, center_z, radius, centers, radii, len_points, list_of_a):\n g_x = []\n g_y = []\n g_z = []\n points = [hydrogen_coord_gen(center_x, center_y, center_z, radius) for i in range(0, len_points)] \n x = [points[i][0] for i in range(0, len(points))] \n y = [points[i][1] for i in range(0, len(points))]\n z = [points[i][2] for i in range(0, len(points))]\n for i in range(0, len(points)):\n check = 0\n check_b = 0\n j = 0\n while (j <= (len(centers) - 1) and (check == 0)): \n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], centers[j][0], centers[j][1], centers[j][2]) < radii[j]):\n check += 1\n j += 1\n h = 0\n while ((check_b == 0) and (h <= len(list_of_a) -1)):\n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], list_of_a[h].x, list_of_a[h].y, list_of_a[h].z) <= 1.50): \n check_b += 1\n h += 1\n if ((check == 0) and (check_b == 0)):\n g_x.append(x[i])\n g_y.append(y[i])\n g_z.append(z[i])\n return g_x, g_y, g_z","def get_raw_bounds(self) -> [Vector, Vector]:\n\t\tverts = np.array([v.co for mesh in self._meshes for v in mesh.data.vertices])\n\t\tbbox_min = Vector([*np.min(verts, axis=0)])\n\t\tbbox_max = Vector([*np.max(verts, axis=0)])\n\t\treturn bbox_min, bbox_max","def find_centroid(event_file):\n \n print('Finding the centroid of the event file...\\n')\n \n make_img(event_file,clobber=True)\n \n fits = pyfits.open('temp.fits')\n \n #Previously used the RA and DEC headers to find the centre, now trying a more nuanced\n #max pixel value method\n \n #source_ra = fits[1].header['RA_TARG']\n #source_dec = fits[1].header['DEC_TARG']\n \n #return source_ra,source_dec\n \n data = fits[0].data\n \n #As the data from make_img is 1024x1024 based on the centre of the image, use modulo\n #arithmetic to find the physical x and y coordinates\n \n argmax = np.argmax(data)\n \n x = argmax%1024 + 3584\n y = int(argmax/1024) + 3584\n \n return x,y","def bounds(self):\n return self._bboxes[0][0] #TODO: merge all coverages","def _get_clip_loc_in_array(self):\r\n\r\n # coordinates of upperleft and lowerright points of binding box\r\n box_ulx, box_uly, box_lrx, box_lry = self.clip_box[0][0], self.clip_box[0][1], \\\r\n self.clip_box[1][0], self.clip_box[1][1]\r\n\r\n # Get the offsets that correspond to the bounding box corner coordinates.\r\n offsets_ul = gdal.ApplyGeoTransform(self.inv_gt, box_ulx, box_uly)\r\n offsets_lr = gdal.ApplyGeoTransform(self.inv_gt, box_lrx, box_lry)\r\n\r\n # The offsets are returned as floating point, but we need integers.\r\n self.off_ulx, self.off_uly = map(int, offsets_ul)\r\n self.off_lrx, self.off_lry = map(int, offsets_lr)\r\n\r\n # Compute the numbers of rows and columns to extract, based on the offsets.\r\n self.row = self.off_lry - self.off_uly\r\n self.column = self.off_lrx - self.off_ulx","def _getRawBound(self):\n if self._colormap is None:\n return None\n elif self._index == 0:\n return self._colormap.getVMin()\n else: # self._index == 1\n return self._colormap.getVMax()","def get_response_weights_vector(zenith,azimuth,binsize=5,cut=57.4):\n\n # assuming useful input:\n # azimuthal angle is periodic in the range [0,360[\n # zenith ranges from [0,180[ \n # checking azimuth range (can be exactly 360?)\n azimuth[azimuth == 360] -= 0.01\n \n # check which pixel (index) was hit on regular grid\n hit_pixel_zi = np.floor(zenith/binsize).astype(int)\n hit_pixel_ai = np.floor(azimuth/binsize).astype(int)\n\n # and which pixel centre\n hit_pixel_z = (hit_pixel_zi+0.5)*binsize\n hit_pixel_a = (hit_pixel_ai+0.5)*binsize\n\n # check which zeniths are beyond threshold\n bad_idx = np.where(hit_pixel_z > cut) \n \n # calculate nearest neighbour pixels indices\n za_idx = np.array([[np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize+0.5)],\n [np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize-0.5)],\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize+0.5)],\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize-0.5)]]).astype(int)\n\n # take care of bounds at zenith (azimuth is allowed to be -1!)\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] < 0)] += 1\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] >= 180/binsize)] = int(180/binsize-1)\n # but azimuth may not be larger than range [0,360/binsize[\n (za_idx[:,0,:])[np.where(za_idx[:,0,:] >= 360/binsize)] = 0\n \n # and pixel centres of neighbours\n azimuth_neighbours = (za_idx[:,0]+0.5)*binsize\n zenith_neighbours = (za_idx[:,1]+0.5)*binsize\n\n # calculate angular distances to neighbours\n dists = angular_distance(azimuth_neighbours,zenith_neighbours,azimuth,zenith)\n\n # inverse weighting to get impact of neighbouring pixels\n n_in = len(zenith)\n weights = (1/dists)/np.sum(1/dists,axis=0).repeat(4).reshape(n_in,4).T\n # if pixel is hit directly, set weight to 1.0\n weights[np.isnan(weights)] = 1\n # set beyond threshold weights to zero\n weights[:,bad_idx] = 0\n\n return za_idx,weights","def compute_iso0(radar, ml_top, iso0_field='height_over_iso0'):\n iso0_data = np.ma.masked_all((radar.nrays, radar.ngates))\n for ind_ray in range(radar.nrays):\n iso0_data[ind_ray, :] = (\n radar.gate_altitude['data'][ind_ray, :]-ml_top[ind_ray])\n\n iso0_dict = get_metadata(iso0_field)\n iso0_dict['data'] = iso0_data\n\n return iso0_dict","def ap_index_bounds(self, qa_lows, qa_highs, ap_coordinates):\n\n # Treat the first alignment area separately. Its lower bound is the first alignment point.\n qa_ap_index_lows = [0]\n\n # Starting with the second alignment point, search for the first one on the upper area\n # border or beyond it. Take it as the upper index bound.\n for ap_index, ap_value in enumerate(ap_coordinates[1:]):\n if ap_value >= qa_highs[0]:\n qa_ap_index_highs = [ap_index + 2]\n break\n\n # For interior quality areas\n for qa_index_m1, qa_low in enumerate(qa_lows[1:-1]):\n\n # The index of the quality area (qa_index) has to be increased by one because the list\n # used for the enumerator starts with the second entry.\n qa_index = qa_index_m1 + 1\n qa_high = qa_highs[qa_index]\n\n # For the lower index bound, look for the first alignment point on the lower border\n # or beyond in reversed order.\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\n if ap_value <= qa_low:\n qa_ap_index_lows.append(ap_index)\n break\n\n # For the upper index bound, look for the first alignment point on the upper border\n # or beyond.\n for ap_index, ap_value in enumerate(ap_coordinates):\n if ap_value >= qa_high:\n qa_ap_index_highs.append(ap_index + 1)\n break\n\n # The last alignment point index was removed from the search. If this is the upper bound\n # for the last inner quality area, it has not been assigned to the index_highs list. In\n # this case this list is one entry short. In this case add the index of the last alignment\n # point as the upper index bound.\n if len(qa_ap_index_highs) < len(qa_ap_index_lows):\n qa_ap_index_highs.append(len(ap_coordinates))\n\n # In analogy to the first quality area, treat the case of the last quality area separately\n # as well.\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\n if ap_value <= qa_lows[-1]:\n qa_ap_index_lows.append(ap_index)\n break\n # The upper index bound is always the last alignment point index.\n qa_ap_index_highs.append(len(ap_coordinates))\n\n return qa_ap_index_lows, qa_ap_index_highs","def grid_cloud_top(data, xradar, yradar, xgrid, ygrid, theta_3db=1.5, rmax=150e3, gatespacing=250):\n if xradar.shape != data.shape:\n raise IndexError(\"Bad dimensions\")\n\n if len(xgrid.shape) < len(xradar.shape):\n xgrid, ygrid = np.meshgrid(xgrid, ygrid)\n\n eth_out = np.zeros(xgrid.shape) + np.NaN\n\n for i in range(len(xgrid)):\n for j in range(len(ygrid)):\n cnt = 0\n zmax = 0\n xi = xgrid[j, i]\n yi = ygrid[j, i]\n\n if xi ** 2 + yi ** 2 > rmax ** 2:\n continue\n\n width = 0.5 * (np.sqrt(xi ** 2 + yi ** 2) * theta_3db * np.pi / 180)\n if width < gatespacing:\n width = gatespacing\n\n for k in range(data.shape[1]):\n for l in range(data.shape[0]):\n xr = xradar[l, k]\n yr = yradar[l, k]\n\n if (\n xr >= xi - width\n and xr < xi + width\n and yr >= yi - width\n and yr < yi + width\n ):\n if data[l, k] > 0:\n zmax = zmax + data[l, k]\n cnt = cnt + 1\n\n if cnt != 0:\n eth_out[j, i] = zmax / cnt\n\n return eth_out","def get_bounds(self, crs=\"default\"):\n\n if crs == \"default\":\n crs = podpac.settings[\"DEFAULT_CRS\"]\n\n bounds = {}\n for coords in self.find_coordinates():\n ct = coords.transform(crs)\n for dim, (lo, hi) in ct.bounds.items():\n if dim not in bounds:\n bounds[dim] = (lo, hi)\n else:\n bounds[dim] = (min(lo, bounds[dim][0]), max(hi, bounds[dim][1]))\n\n return bounds, crs","def getBoundingBoxCenter(self, shell=False, *args, **kwargs):\n if shell:\n self.grabShell()\n uvBB = pm.polyEvaluate(boundingBoxComponent2d=True)\n uvCenter = [((uvBB[0][1] + uvBB[0][0]) / 2), ((uvBB[1][1] + uvBB[1][0]) / 2)]\n return uvCenter","def gen_centers(self):\n\n \"\"\"x_track = self.cs.discrete_rollout()\n t = np.arange(len(x_track))*self.dt\n # choose the points in time we'd like centers to be at\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\n self.c = np.zeros(len(c_des))\n for ii, point in enumerate(c_des):\n diff = abs(t - point)\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\"\"\"\n\n # desired activations throughout time\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\n\n self.c = np.ones(len(des_c))\n for n in range(len(des_c)):\n # finding x for desired times t\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\n self.c = jnp.array(self.c)","def on_max_hit_points(self):\n pass","def total_crimes_in_bounds(user_coords):\n\n crimes_coords = {'crimes': []}\n\n # takes in user_coords point a and point b\n # in order to determine top left and bottom right coordinates.\n point_a = user_coords['point_a']\n point_b = user_coords['point_b']\n\n # compare latitude to see what's the top coord, tupleize\n # add 0.005 to latitude, and subtract 0.02 to longitude\n top_left_coord = {'lat': max(point_a['lat'], point_b['lat']) + 0.005,\n 'lng': min(point_a['lng'], point_b['lng']) - 0.02}\n\n # subtract 0.005 to latitude, and add 0.02 to longitude\n bottom_right_coord = {'lat': min(point_a['lat'], point_b['lat']) - 0.005,\n 'lng': max(point_a['lng'], point_b['lng']) + 0.02}\n\n # once the bounds are generated, we will want to do a query for all of the\n # geohashes that are within those bounds. Let's do that now.\n # some raw sql to get the center coords of geohash\n geohash_in_bounds_sql = \"SELECT *, \" + \\\n \"ST_AsText(ST_PointFromGeoHash(geohash)) AS lat_lng \" + \\\n \"FROM nyc_crimes_by_geohash \" + \\\n \"WHERE ST_Contains(\" + \\\n \"ST_MakeBox2D(\" + \\\n \"ST_Point(%f, %f), ST_Point(%f, %f)), ST_PointFromGeoHash(geohash));\" \\\n % (top_left_coord['lat'], top_left_coord['lng'],\n bottom_right_coord['lat'], bottom_right_coord['lng'])\n # execute the raw sql, there should be many\n geohash_in_bounds_query = db.engine.execute(geohash_in_bounds_sql).fetchall()\n\n for row in geohash_in_bounds_query:\n # strip the lat, lngs before putting them in\n # some string splitting to extract data\n location = row[4].strip(\"POINT(\").rstrip(\")\").split()\n latitude = location[0]\n longitude = location[1]\n\n format_loc_dict = {'latitude': latitude, 'longitude': longitude,\n 'total_crimes': row[2]}\n\n # append to crimes_coords inner list\n crimes_coords['crimes'].append(format_loc_dict)\n\n return crimes_coords","def get_max_score(location_list, grid, shape):","def find_components(image,deltaPix,lens_rad_arcsec = 6.0,lens_rad_ratio = None,\n center_x = None,center_y = None, gal_rad_ratio = 0.1,\n min_size_arcsec=0.7,thresh=0.5, many_sources = True,\n show_locations=False, title = None):\n\n # convert minimum component size in pixel units\n min_size = int(min_size_arcsec / deltaPix)\n \n #Convert lens radius and central galaxy radius to pixels\n if lens_rad_ratio == None:\n lens_rad = int(lens_rad_arcsec / deltaPix)\n else: lens_rad = int(len(image) * lens_rad_ratio)\n gal_rad = int(len(image) * gal_rad_ratio)\n \n \n# im2[im2 < im2.min() + 10.*thresh] = 0.\n \n # downscale source image to data resolution (for speed + easier for converting to data units)\n #down = image_util.re_size(image, factor=supersampling_factor_source)\n \n # apply laplacian of gaussian (LoG) filter to enhance maxima\n LoG = - gaussian_laplace(deepcopy(image), sigma = min_size, mode='constant', cval=0.) \n \n# LoG = - gaussian_laplace(deepcopy(im2), sigma = 2., mode='constant', cval=0.)\n \n filtered = deepcopy(LoG)\n \n# print(LoG.min(),LoG.max(),np.abs(LoG.min()) + thresh )\n \n# print(type(filtered))\n \n #background mean and std of filtered image \n corners = np.zeros([4,5,5])\n corners[0] = LoG[0:5,0:5]\n corners[1] = LoG[-5:,0:5]\n corners[2] = LoG[0:5,-5:]\n corners[3] = LoG[-5:,-5:]\n means = []\n stds = []\n for c in corners:\n mn,med,s = sigma_clipped_stats(c,sigma=3.0)\n means.append(mn)\n stds.append(s)\n \n stds=np.array(stds)\n means = np.array(means)\n means_std = np.std(means)\n# means_good = means[(means >= means.mean() - 1.0 * means_std) & (means <= means.mean() + 1.0 * means_std)]\n means_good = means[(np.abs(means) <= np.abs(means).min() + 1.0 * means_std)]\n mean_bg = np.mean(means_good)\n std_bg = np.mean(stds[(np.abs(means) <= np.abs(means).min() + 1.0 * means_std)])\n# print('LoG means: {}, Log means std: {}, Log means good: {}, LoG avg mean: {}'.format(means,means_std,means_good,mean_bg))\n# print('min: {}, max: {}, cut: {}'.format(LoG.min(),LoG.max(),mean_bg + thresh))\n# print(LoG.min(),LoG.max(),filtered.min() + thresh)\n \n \n # assume all value below max*threshold can not be maxima, so put all to zero\n# filtered[filtered < thresh*filtered.max()] = 0.\n \n# assume all value below min*threshold can not be maxima, so put all to zero\n# filtered[filtered < filtered.min() + thresh * np.abs(filtered.min())] = 0.\n# filtered[filtered < mean_bg + thresh] = 0.\n filtered[filtered < mean_bg + 6.*std_bg] = 0. #set pixels below the mean + 6x threshold to 0\n \n # find coordinates of local maxima\n #print(int(0.5 * min_size))\n max_idx_2d_small = peak_local_max(filtered, min_distance=0) #All bright pixels\n max_idx_2d_large = peak_local_max(filtered, min_distance=1) #peaks with min size of 1 pixel\n \n x_list_small, y_list_small = max_idx_2d_small[:, 1], max_idx_2d_small[:, 0]\n x_list_large, y_list_large = max_idx_2d_large[:, 1], max_idx_2d_large[:, 0]\n \n im_center_x, im_center_y = len(image) / 2., len(image) / 2. #center of image\n \n if (center_x == None) & (center_y == None):\n new_center_x, new_center_y = im_center_x,im_center_y\n else:\n new_center_x, new_center_y = center_x,center_y #new \"center\" = location of lens galaxy\n \n \n #distance of each detected peak from center\n R_small = np.sqrt((x_list_small - new_center_x)**2 + (y_list_small - new_center_y)**2) \n R_large = np.sqrt((x_list_large - new_center_x)**2 + (y_list_large - new_center_y)**2)\n \n #Contaminant light is only bright pixels further from center than lens_rad\n x_sats, y_sats = x_list_small[R_small > lens_rad], y_list_small[R_small > lens_rad]\n \n if many_sources:\n x_lens, y_lens = deepcopy(x_list_small), deepcopy(y_list_small)\n else:\n x_lens, y_lens = deepcopy(x_list_large), deepcopy(y_list_large)\n \n# x_lens, y_lens = x_list_small[R_small <= lens_rad], y_list_small[R_small <= lens_rad]\n \n if (len(x_lens) == 0) & (len(y_lens) == 0):\n x_lens = [0,15]\n y_lens = [0,15]\n \n sources = QTable([x_lens, y_lens],names={'x_local_peak','y_local_peak'}) #make table of all detected objects\n# print(x_list_large)\n# print(y_list_large)\n# print(sources)\n \n # show maxima on image for debug\n \n if show_locations:\n# fig = plt.figure(figsize=(4, 4))\n #plt.imshow(image, origin='lower', cmap=cmap_flux, norm=LogNorm(1e-2))\n \n f, axes = plt.subplots(1, 5, figsize=(20,5), sharex=False, sharey=False)\n# plt.figure(figsize = (8,8))\n# plt.subplot(1,2,1)\n \n axes[0].imshow(image, origin='lower', norm=SymLogNorm(5))\n axes[0].set_title('Image')\n axes[0].set_axis_off()\n \n \n axes[1].imshow(LoG, origin='lower', norm=SymLogNorm(5))\n axes[1].set_title('LoG Filtered Image')\n axes[1].set_axis_off()\n\n# plt.subplot(1,2,2)\n axes[2].imshow(filtered, origin='lower', norm=SymLogNorm(5))\n axes[2].set_title('Final Filtered Image')\n axes[2].set_axis_off()\n \n axes[3].imshow(image, origin='lower', norm=SymLogNorm(5))\n for i in range(len(x_lens)):\n axes[3].scatter([x_lens[i]], [y_lens[i]], c='red', s=60, marker='+')\n \n for i in range(len(x_list_large)):\n axes[3].scatter([x_list_large[i]], [y_list_large[i]], c='black', s=100, marker='x')\n axes[3].set_title('Detected Objects')\n axes[3].set_axis_off()\n \n axes[4].imshow(image, origin='lower', norm=SymLogNorm(5))\n \n for i in range(len(x_sats)):\n axes[4].scatter([x_sats[i]], [y_sats[i]], c='red', s=60, marker='+')\n \n# plt.annotate(i+1, (x_list[i], y_list[i]), color='black')\n \n# for i in range(len(x_mask)):\n# plt.scatter([x_mask[i]], [y_mask[i]], c='red', s=100, marker='*')\n# plt.annotate(i+1, (x_mask[i], y_mask[i]), color='red')\n axes[4].scatter(new_center_x, new_center_y,c='red', s=100, marker='*')\n \n draw_lens_circle = Circle((new_center_x, new_center_y),lens_rad ,fill=False)\n draw_gal_circle = Circle((new_center_x, new_center_y),gal_rad, fill = False)\n# plt.gcf().gca().add_artist(draw_lens_circle)\n# plt.gcf().gca().add_artist(draw_gal_circle)\n axes[4].add_patch(draw_lens_circle)\n# axes[4].add_patch(draw_gal_circle)\n \n axes[4].set_title('Pixels to Mask: \\n r = {:.3f}'.format(lens_rad_arcsec))\n axes[4].text(1, 1, \"detected components\", color='red')\n axes[4].set_axis_off()\n \n if title != None:\n f.suptitle(title, fontsize = 15)\n# plt.show()\n \n \n return (x_sats, y_sats), (new_center_x, new_center_y), sources","def get_center_ball_dist(output, x_true, y_true, num_classes=256):\n max_dist = 5\n success, fail = 0, 0\n dists = []\n Rx = 640 / 1280\n Ry = 360 / 720\n\n for i in range(len(x_true)):\n x, y = -1, -1\n # Reshape output\n cur_output = output[i].reshape((360, 640))\n\n # cv2 image must be numpy.uint8, convert numpy.int64 to numpy.uint8\n cur_output = cur_output.astype(np.uint8)\n\n # reshape the image size as original input image\n heatmap = cv2.resize(cur_output, (640, 360))\n\n # heatmap is converted into a binary image by threshold method.\n if num_classes == 256:\n ret, heatmap = cv2.threshold(heatmap, 127, 255, cv2.THRESH_BINARY)\n else:\n heatmap *= 255\n\n # find the circle in image with 2<=radius<=7\n circles = cv2.HoughCircles(heatmap, cv2.HOUGH_GRADIENT, dp=1, minDist=1, param1=50, param2=2, minRadius=2,\n maxRadius=7)\n # check if there have any tennis be detected\n if circles is not None:\n # if only one tennis be detected\n if len(circles) == 1:\n\n x = int(circles[0][0][0])\n y = int(circles[0][0][1])\n\n if x_true[i] < 0:\n if x < 0:\n success += 1\n else:\n fail += 1\n dists.append(-2)\n else:\n if x < 0:\n fail += 1\n dists.append(-1)\n else:\n dist = np.linalg.norm(((x_true[i] * Rx) - x, (y_true[i] * Ry) - y))\n dists.append(dist)\n if dist < max_dist:\n success += 1\n else:\n fail += 1\n\n return dists, success, fail","def get_bounds(self):\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)","def calc_R(center):\r\n xc = center[0]\r\n yc = center[1]\r\n return np.sqrt((x-xc)**2 + (y-yc)**2)","def _find_centroid_sphere(ch_pos, group_names):\n cartesian_positions = np.array([ch_pos[ch_name] for ch_name in group_names])\n sphere_positions = _cart_to_sph(cartesian_positions)\n cartesian_pos_centroid = np.average(cartesian_positions, axis=0)\n sphere_pos_centroid = _cart_to_sph(cartesian_pos_centroid)\n # average the radius and overwrite it\n avg_radius = np.average(sphere_positions, axis=0)[0]\n sphere_pos_centroid[0, 0] = avg_radius\n # convert back to cartesian\n pos_centroid = _sph_to_cart(sphere_pos_centroid)[0, :]\n return pos_centroid","def grid_search(self,\n images,\n labels,\n max_rot,\n max_dx,\n max_dy,\n by_score=False,\n generate_samples=False,\n stop_on_success=True,\n include_unsuccessful=False):\n\n rotation_range = range(-max_rot, max_rot)\n dx_range = range(-max_dx, max_dx)\n dy_range = range(-max_dy, max_dy)\n cartesian_product = [i for i in itertools.product(rotation_range, dx_range, dy_range)]\n\n def get_abs_sum(arg):\n return abs(arg[0]) + abs(arg[1]) + abs(arg[2])\n\n if by_score:\n cartesian_product.sort(key=get_abs_sum)\n else:\n random.shuffle(cartesian_product)\n\n adv_status = torch.ones(images.shape[0], dtype=torch.bool).to(self.device)\n\n for args in cartesian_product:\n print(args)\n advs = F.affine(images, args[0], [args[1], args[2]], 1.0, [0.0, 0.0])\n if self.parse_adversarials(advs,\n labels,\n adv_status,\n images,\n include_unsuccessful=include_unsuccessful,\n generate_samples=generate_samples,\n stop_on_success=stop_on_success):\n break","def get_final_bounding_box(boxes, nms_idx, width: int, height: int):\n x1 = np.inf\n y1 = np.inf\n x2 = -np.inf\n y2 = -np.inf\n\n bx = [boxes[i] for i in nms_idx]\n for box in bx:\n xmin = np.min(box[[0, 2]])\n xmax = np.max(box[[0, 2]])\n ymin = np.min(box[[1, 3]])\n ymax = np.max(box[[1, 3]])\n\n x1 = np.min([xmin, x1])\n y1 = np.min([ymin, y1])\n x2 = np.max([xmax, x2])\n y2 = np.max([ymax, y2])\n return x1, y1, x2, y2","def __nc_geo_bounds(self, extent, data_sel):\n indx = None\n if extent is not None:\n if len(extent) != 4:\n raise ValueError('parameter extent must have 4 elements')\n\n lats = self.fid['/instrument/latitude_center'][:].reshape(\n self.scanline, self.ground_pixel)\n lons = self.fid['/instrument/longitude_center'][:].reshape(\n self.scanline, self.ground_pixel)\n\n indx = np.where((lons >= extent[0]) & (lons <= extent[1])\n & (lats >= extent[2]) & (lats <= extent[3]))\n data_sel = np.s_[indx[0].min():indx[0].max(),\n indx[1].min():indx[1].max()]\n\n gid = self.fid['/instrument']\n lat_bounds = gid['latitude_corners'][:].data.reshape(\n self.scanline, self.ground_pixel, 4)\n lon_bounds = gid['longitude_corners'][:].data.reshape(\n self.scanline, self.ground_pixel, 4)\n if data_sel is not None:\n lat_bounds = lat_bounds[data_sel + (slice(None),)]\n lon_bounds = lon_bounds[data_sel + (slice(None),)]\n\n return (data_sel, lon_bounds, lat_bounds)","def multi_gaussian_lens(self, kwargs_lens, n_comp=20):\n kwargs_lens_copy = copy.deepcopy(kwargs_lens)\n if 'center_x' in kwargs_lens_copy[0]:\n center_x = kwargs_lens_copy[0]['center_x']\n center_y = kwargs_lens_copy[0]['center_y']\n else:\n raise ValueError('no keyword center_x defined!')\n theta_E = self.LensModel.effective_einstein_radius(kwargs_lens)\n r_array = np.logspace(-4, 2, 200) * theta_E\n #r_array = np.logspace(-2, 1, 50) * theta_E\n lens_model_internal_bool = self.kwargs_model.get('lens_model_internal_bool', [True] * len(kwargs_lens))\n kappa_s = np.zeros_like(r_array)\n for i in range(len(kwargs_lens_copy)):\n if lens_model_internal_bool[i]:\n if 'center_x' in kwargs_lens_copy[0]:\n kwargs_lens_copy[i]['center_x'] -= center_x\n kwargs_lens_copy[i]['center_y'] -= center_y\n kappa_s += self.LensModel.kappa(r_array, np.zeros_like(r_array), kwargs_lens_copy, k=i)\n amplitudes, sigmas, norm = mge.mge_1d(r_array, kappa_s, N=n_comp)\n return amplitudes, sigmas, center_x, center_y","def calcFaceAreas(x,y,z):\n (nLonP1, nLatP1) = x.shape\n (nLon, nLat) = (nLonP1-1, nLatP1-1)\n\n area = numpy.zeros((nLon, nLat))\n\n for i in range(nLon):\n for j in range(nLat):\n left = distance( (x[i,j], y[i,j], z[i,j]), (x[i,j+1], y[i,j+1], z[i,j+1]) )\n right = distance( (x[i+1,j], y[i+1,j], z[i+1,j]), (x[i+1,j+1], y[i+1,j+1], z[i+1,j+1]) )\n top = distance( (x[i,j+1], y[i,j+1], z[i,j+1]), (x[i+1,j+1], y[i+1,j+1], z[i+1,j+1]) )\n bot = distance( (x[i,j], y[i,j], z[i,j]), (x[i+1,j], y[i+1,j], z[i+1,j]) )\n \n area[i,j] = 0.5*(left+right) * 0.5*(top+bot)\n\n return area","def detect(self, mask):\n # 1) Return Non zero indices\n det_idx = np.where(mask > 0.0)\n idx_x, idx_y = det_idx[0], det_idx[1]\n # 2) Create 1x1 box for each pixel detected.\n detections = []\n for i in range(0, len(idx_x)):\n x, y = idx_x[i], idx_y[i]\n detections.append((x, y, x+1, y+1, 1)) # x1, y1, x2, y2, area\n # 3) merge boxes\n bounding_boxes = self.bounding_boxes(detections)\n return bounding_boxes"],"string":"[\n \"def _getTopCenterIndices(self, resolution, rectangular):\\n # get x, y indices to get away from the ring basis.\\n # indices starts with (0, 0) in the middle, with (r2, p1) -> (1, 0), etc. (x is on the pos 1 ray)\\n\\n numAxialLevels = 2 * resolution\\n xi, yi = self.indices()\\n if rectangular:\\n topCenterI = 2 + (3 * resolution) * xi\\n else:\\n # 4*d b/c each increase in xi moves you back by numstacks/2\\n topCenterI = 1 + (4 * resolution) * xi + (yi * numAxialLevels)\\n topCenterJ = 1 + xi * numAxialLevels // 2 + numAxialLevels * yi\\n return topCenterI, topCenterJ\",\n \"def find_center(file):\\n\\n data = pyfits.getdata(file)\\n chipx = data.field('X')\\n chipy = data.field('Y')\\n#\\n#--- because the array is too large to handle in one swipe, divide it into 8x8 segments\\n#\\n xmin = min(chipx)\\n ymin = min(chipy)\\n xmax = max(chipx)\\n ymax = max(chipy)\\n xstep = int((xmax-xmin) / 8 )\\n ystep = int((ymax-ymin) / 8 )\\n#\\n#--- find the interval which contains largest samples \\n#\\n cposx = 0\\n cposy = 0\\n cmax = 0\\n for i in range (0, 8):\\n xstart = xstep * i + xmin\\n xstop = xstart + xstep\\n for j in range (0, 8):\\n ystart = ystep * j + ymin\\n ystop = ystart + ystep\\n\\n mask = (data.field('X') >= xstart) & (data.field('X') < xstop) & (data.field('Y') >= ystart) & (data.field('Y') < ystop)\\n temp = data[mask]\\n chipx_p = temp.field('X')\\n chipy_p = temp.field('Y')\\n if len(chipx_p) > cmax:\\n cmax = len(chipx_p)\\n cposx = i\\n cposy = j\\n#\\n#--- extract the area of the highest count\\n#\\n xpos_list = []\\n ypos_list = []\\n maxv_list = []\\n xstart = xstep * cposx + xmin\\n xstop = xstart + xstep\\n\\n ystart = ystep * cposy + ymin\\n ystop = ystart + ystep\\n\\n mask = (data.field('X') >= xstart) & (data.field('X') < xstop) & (data.field('Y') >= ystart) & (data.field('Y') < ystop)\\n temp = data[mask]\\n chipx_p = temp.field('X')\\n chipy_p = temp.field('Y')\\n#\\n#--- count up the events. bin to 2x2 so that we get enough count in each bin\\n#\\n xmin = min(chipx_p)\\n xmax = max(chipx_p)\\n xdim = int(0.5 * (xmax - xmin)) + 1\\n ymin = min(chipy_p)\\n ymax = max(chipy_p)\\n ydim = int(0.5 * (ymax - ymin)) + 1\\n\\n cbin = [[0 for y in range(0, ydim)] for x in range(0, xdim)]\\n for j in range(0, len(chipy_p)):\\n xpos = int(0.5 * (chipx_p[j]-xmin))\\n ypos = int(0.5 * (chipy_p[j]-ymin))\\n cbin[xpos][ypos] += 1\\n#\\n#--- now find max position\\n#\\n vmax = 0\\n xx = 0\\n yy = 0\\n for m in range(0, xdim):\\n for n in range(0, ydim):\\n if cbin[m][n] > vmax:\\n vmax = cbin[m][n]\\n xx = m\\n yy = n\\n#\\n#--- take the mddle of the bin as the brightest spot\\n#\\n xv = int(xx * 2.0 + 1.0 + xmin)\\n yv = int(yy * 2.0 + 1.0 + ymin)\\n\\n return [xv, yv]\",\n \"def find_location_gs(source_name, source_alt_az,\\n minute, hour, day, month, year,\\n plot_grids=True):\\n\\n alt, az = source_alt_az\\n source_obj = Vizier.query_object(source_name, catalog='V/50')[0]\\n source_ra_dec = (source_obj['RAJ2000'][0], source_obj['DEJ2000'][0])\\n\\n source_ra_hms = tuple(map(float, source_ra_dec[0].split()))\\n source_dec_dms = tuple(map(float, source_ra_dec[1].split()))\\n\\n source_ra = Angle(source_ra_hms, unit='hourangle').degree\\n source_dec = Angle(source_dec_dms, unit=u.deg).degree\\n\\n lats = np.arange(-90., 90, res)\\n longs = np.arange(-180, 180, res)\\n\\n ra_grid = np.zeros((len(lats), len(longs)))\\n dec_grid = np.zeros((len(lats), len(longs)))\\n score_grid = np.zeros((len(lats), len(longs)))\\n\\n # Run the grid\\n lat_counter, long_counter = 0, 0\\n for i in range(len(lats)):\\n for j in range(len(longs)):\\n # Need to sort out angular units\\n lat, long = lats[i], longs[j]\\n\\n ra, dec = altaz_to_radec((alt, az), pos=(lat, long),\\n minute=minute, hour=hour, day=day,\\n month=month, year=year, tz_offset=5)\\n\\n # pos_grid[i, j] = {'RA': ra, 'DEC': dec}\\n ra_grid[i, j] = ra\\n dec_grid[i, j] = dec\\n\\n # Bad - planar:\\n score = np.sqrt((ra - source_ra)**2 + (dec - source_dec)**2)\\n\\n # Good - spherical:\\n # score = np.arccos(np.sin(dec) * np.sin(source_dec) + np.cos(dec) * np.cos(source_dec) * np.cos(abs(ra - source_ra)))\\n\\n score_grid[i, j] = score\\n\\n verbose = False\\n if verbose is True:\\n print('RA, Source RA:', ra, source_ra)\\n print('DEC, Source DEC:', dec, source_dec)\\n print('Score:', score)\\n print('\\\\n')\\n else:\\n step = long_counter + lat_counter * len(lats)\\n print (str(step) + '/' + str(len(lats) * len(longs)))\\n long_counter += 1\\n\\n outname = 'latlong-gridsearch-results_' + str(res)\\n score_df = pd.DataFrame(score_grid)\\n score_df.to_csv(outname + '.csv')\\n\\n if plot_grids is True:\\n lat_coord = (90 + local_latlong[0]) * res\\n long_coord = (180 + local_latlong[1]) * res\\n\\n plt.contour(score_grid)\\n plt.plot([lat_coord], [long_coord], 'or')\\n plt.matshow(score_grid, cmap='magma')\\n\\n xtick_locs = np.arange(0, len(longs), len(longs)/6)\\n xtick_labs = [int(longs[i]) for i in xtick_locs]\\n plt.xticks(xtick_locs, xtick_labs)\\n\\n # plt.ylim(max(lats), min(lats))\\n ytick_locs = np.arange(0, len(lats), len(lats)/10)\\n ytick_labs = [int(lats[i]) for i in ytick_locs]\\n plt.yticks(ytick_locs, ytick_labs)\\n\\n plt.savefig(outname + '.png', dpi=200)\\n plt.show(block=False)\\n\\n\\n return {'RA': ra_grid, 'DEC': dec_grid, 'SCORE': score_grid}\",\n \"def find_area(self):\\n min_lat_point = self.latitude_min\\n max_lat_point = self.latitude_max\\n min_lon_point = self.longitude_min\\n max_lon_point = self.longitude_max\\n self.rename_latitude()\\n self.rename_longitude()\\n all_lat_bounds = self.cube.coord('latitude').bounds\\n all_lon_bounds = self.cube.coord('longitude').bounds\\n # print(all_lat_bounds)\\n # print(all_lon_bounds)\\n for i, lat in enumerate(all_lat_bounds):\\n for j, lon in enumerate(all_lon_bounds):\\n lat_bounds = lat # 2D array of the lower and upper lat bounds\\n lon_bounds = lon # 2D array of the lower and upper lon bounds\\n if lat_bounds[0] <= min_lat_point < lat_bounds[1]:\\n if lon_bounds[0] <= min_lon_point < lon_bounds[1]:\\n nlat_min = i\\n nlon_min = j\\n else:\\n pass\\n else:\\n pass\\n\\n for k, lat in enumerate(all_lat_bounds):\\n for l, lon in enumerate(all_lon_bounds):\\n lat_bounds = lat # 2D array of the lower and upper lat bounds\\n lon_bounds = lon # 2D array of the lower and upper lon bounds\\n if lat_bounds[0] <= max_lat_point < lat_bounds[1]:\\n if lon_bounds[0] <= max_lon_point < lon_bounds[1]:\\n nlat_max = k\\n nlon_max = l\\n else:\\n pass\\n else:\\n pass\\n\\n area_subset = self.cube[:, nlat_min:nlat_max+1, nlon_min:nlon_max+1]\\n # print(area_subset.coord('latitude').points)\\n # print(area_subset.coord('longitude').points)\\n area_mean = area_subset.collapsed(['latitude', 'longitude'],\\n iris.analysis.MEAN)\\n\\n return area_mean\",\n \"def compute_cell_center(seg_img: np.ndarray, labels: np.ndarray, results: np.ndarray) \\\\\\n -> np.ndarray:\\n for label in labels:\\n if label != 0:\\n all_points_z, all_points_x, all_points_y = np.where(seg_img == label)\\n avg_z = np.round(np.mean(all_points_z))\\n avg_x = np.round(np.mean(all_points_x))\\n avg_y = np.round(np.mean(all_points_y))\\n results[label] = [avg_z, avg_x, avg_y]\\n\\n return results\",\n \"def find_location(source_name, source_alt_az,\\n minute=minute_now, hour=hour_now, day=day_now,\\n month=month_now, year=year_now, plot_grids=True):\\n\\n alt, az = source_alt_az\\n source_obj = Vizier.query_object(source_name, catalog='V/50')[0]\\n source_ra_dec = (source_obj['RAJ2000'][0], source_obj['DEJ2000'][0])\\n\\n source_ra_hms = tuple(map(float, source_ra_dec[0].split()))\\n source_dec_dms = tuple(map(float, source_ra_dec[1].split()))\\n\\n source_ra = Angle(source_ra_hms, unit='hourangle').degree\\n source_dec = Angle(source_dec_dms, unit=u.deg).degree\\n\\n\\n lat_crit = 0.01\\n step = 20\\n lats = np.linspace(-90, 90, step)\\n longs = np.linspace(-180., 180., 2*step)\\n lat_min, lat_max = 0, len(lats) - 1\\n long_min, long_max = 0, len(longs) - 1\\n\\n real_lat, real_long = 41.55, -72.65\\n\\n counter = 0\\n while abs(lats[1] - lats[0]) > lat_crit:\\n lats = np.linspace(lats[lat_min], lats[lat_max], step)\\n longs = np.linspace(longs[long_min], longs[long_max], 2*step)\\n\\n score_grid = np.zeros((len(lats), len(longs)))\\n\\n # Run the grid\\n for i in range(len(lats)):\\n for j in range(len(longs)):\\n lat, long = lats[i], longs[j]\\n\\n ra, dec = altaz_to_radec((alt, az), pos=(lat, long),\\n minute=minute, hour=hour, day=day,\\n month=month, year=year, tz_offset=5)\\n\\n score = np.sqrt((ra - source_ra)**2 + (dec - source_dec)**2)\\n score_grid[i, j] = score\\n\\n idx = np.where(score_grid == np.nanmin(score_grid))\\n lat_min = idx[0][0] - 2 if idx[0][0] > 1 else 0\\n lat_max = idx[0][0] + 2 if idx[0][0] < len(lats) - 2 else len(lats) - 1\\n\\n long_min = idx[1][0] - 2 if idx[1][0] > 1 else 0\\n long_max = idx[1][0] + 2 if idx[1][0] < len(longs) - 2 else len(longs) - 1\\n\\n plt.matshow(score_grid, cmap='magma_r')\\n plt.contour(score_grid, cmap='magma')\\n xtick_locs = np.arange(0, len(longs), len(longs)/6)\\n xtick_labs = [int(longs[i]) for i in xtick_locs]\\n plt.xticks(xtick_locs, xtick_labs)\\n\\n ytick_locs = np.arange(0, len(lats), len(lats)/6)\\n ytick_labs = [int(lats[i]) for i in ytick_locs]\\n plt.yticks(ytick_locs, ytick_labs)\\n\\n i, j = 0, 0\\n while longs[i] < real_long and i < len(longs) - 1:\\n i += 1\\n while lats[j] < real_lat and j < len(lats) - 1:\\n j += 1\\n\\n print i, j\\n if i != 0 and j != 0 and i != len(longs) and i != len(lats):\\n plt.plot([i], [j], 'or')\\n plt.savefig('window-evolution' + str(counter) + '.png')\\n plt.close\\n\\n counter += 1\\n\\n return (lats[idx[0][0]], longs[idx[1][0]])\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n outname = 'latlong-gridsearch-results_' + str(res)\\n score_df = pd.DataFrame(score_grid)\\n score_df.to_csv(outname + '.csv')\\n\\n if plot_grids is True:\\n lat_coord = (90 + local_latlong[0]) * res\\n long_coord = (180 + local_latlong[1]) * res\\n\\n plt.contour(score_grid)\\n plt.plot([lat_coord], [long_coord], 'or')\\n plt.matshow(score_grid, cmap='magma')\\n\\n xtick_locs = np.arange(0, len(longs), len(longs)/6)\\n xtick_labs = [int(longs[i]) for i in xtick_locs]\\n plt.xticks(xtick_locs, xtick_labs)\\n\\n # plt.ylim(max(lats), min(lats))\\n ytick_locs = np.arange(0, len(lats), len(lats)/10)\\n ytick_labs = [int(lats[i]) for i in ytick_locs]\\n plt.yticks(ytick_locs, ytick_labs)\\n\\n plt.savefig(outname + '.png', dpi=200)\\n plt.show(block=False)\\n\\n\\n return {'RA': ra_grid, 'DEC': dec_grid, 'SCORE': score_grid}\",\n \"def heliographic(self, *args):\\n\\n\\t\\txScl = self.im_raw.scale[0].value\\n\\t\\tyScl = self.im_raw.scale[1].value\\n\\t\\t\\n\\t\\t# Check for single coordinate or ndarray object.\\n\\t\\tif isinstance(args[0], np.ndarray):\\n\\t\\t\\t# Retrieve integer dimensions and create arrays holding\\n\\t\\t\\t# x and y coordinates of each pixel\\n\\t\\t\\txdim = np.int(np.floor(self.im_raw.dimensions[0].value))\\n\\t\\t\\tydim = np.int(np.floor(self.im_raw.dimensions[1].value))\\n\\t\\t\\ttry:\\n\\t\\t\\t\\txrow = (np.arange(0, xdim) - self.X0 + args[1])*xScl\\n\\t\\t\\t\\tyrow = (np.arange(0, ydim) - self.Y0 + args[2])*yScl\\n\\t\\t\\t\\tself.xg, self.yg = np.meshgrid(xrow, yrow, indexing='xy')\\n\\t\\t\\t\\tself.rg = np.sqrt(self.xg**2 + self.yg**2)\\n\\t\\t\\t\\tx = self.xg\\n\\t\\t\\t\\ty = -self.yg\\n\\t\\t\\texcept IndexError:\\n\\t\\t\\t\\txrow = (np.arange(0, xdim) - self.X0)*xScl\\n\\t\\t\\t\\tyrow = (np.arange(0, ydim) - self.Y0)*yScl\\n\\t\\t\\t\\tself.xg, self.yg = np.meshgrid(xrow, yrow, indexing='xy')\\n\\t\\t\\t\\tself.rg = np.sqrt(self.xg**2 + self.yg**2)\\n\\t\\t\\t\\tx = self.xg\\n\\t\\t\\t\\ty = -self.yg\\n\\t\\telse:\\n\\t\\t\\t# Have to switch coordinate conventions because calculations\\n\\t\\t\\t# assume standard cartesian whereas python indexing is \\n\\t\\t\\t# [row, column]\\n\\t\\t\\tx = (args[1] - self.X0)*xScl/60.0\\n\\t\\t\\ty = (self.Y0 - args[0])*yScl/60.0\\n\\n\\t\\tb0_r = np.deg2rad(self.B0)\\n\\t\\tradius = self.rsun\\n\\t\\tRobs = 1/np.tan(np.deg2rad(radius/60))\\n\\n\\t\\txxat = np.tan(np.deg2rad(x/60))\\n\\t\\tyyat = np.tan(np.deg2rad(y/60))\\n\\n\\t\\trat2 = (xxat**2 + yyat**2)\\n\\t\\tphi = 0*rat2\\n\\t\\tw_rat2 = np.where(rat2 is not 0)\\n\\t\\tphi[w_rat2] = np.arctan2(xxat[w_rat2], yyat[w_rat2])\\n\\n\\t\\tmax_ra = np.arcsin(1.0/Robs)\\n\\t\\tmax_rat2 = np.tan(max_ra)*np.tan(max_ra)\\n\\n\\t\\tii = np.where(rat2 > max_rat2)\\n\\t\\tif ii[0].any() > 0:\\n\\t\\t\\trat2[ii] = max_rat2\\n\\t\\t\\t#offlimb[ii] = 1\\n\\n\\t\\t###############################################\\n\\t\\tras2 = 0*rat2\\n\\t\\tras2[w_rat2] = 1.0/(1.0 + 1.0/rat2[w_rat2])\\n\\t\\td1 = (1.0 - ras2)\\n\\t\\td2 = (1.0 - (Robs**2*ras2))\\n\\t\\tx = ras2*Robs + np.sqrt(d1)*np.sqrt(d2)\\n\\t\\trr = np.sqrt(rat2*Robs)\\n\\t\\tt1 = np.sin(phi)*rr\\n\\t\\tt2 = np.cos(phi)*rr\\n\\n\\t\\thglt = np.arcsin(t2)\\n\\t\\thgln = np.arctan2(x, t1)\\n\\n\\n\\n\\n\\t\\t# Only add the instance attribute if it doesn't exist.\\n\\t\\tif isinstance(args[0], np.ndarray) and not hasattr(self, 'lonh'):\\n\\t\\t\\tself.lonh = np.rad2deg(hgln)\\n\\t\\t\\tself.lath = np.rad2deg(hglt)\\n\\n\\t\\treturn np.rad2deg(hgln), np.rad2deg(hglt)\",\n \"def get_response_from_pixelhit_vector(Response,zenith,azimuth,binsize=5,cut=60):\\n\\n # assuming useful input:\\n # azimuthal angle is periodic in the range [0,360[\\n # zenith ranges from [0,180[\\n\\n # checking azimuth range (can be exactly 360?)\\n azimuth[azimuth == 360] -= 0.01\\n \\n # check which pixel (index) was hit on regular grid\\n hit_pixel_zi = np.floor(zenith/binsize).astype(int)\\n hit_pixel_ai = np.floor(azimuth/binsize).astype(int)\\n\\n #print('hit_pixel_zi',hit_pixel_zi)\\n #print('hit_pixel_ai',hit_pixel_ai)\\n \\n # and which pixel centre\\n hit_pixel_z = (hit_pixel_zi+0.5)*binsize\\n hit_pixel_a = (hit_pixel_ai+0.5)*binsize\\n\\n #print('hit_pixel_z',hit_pixel_z)\\n #print('hit_pixel_a',hit_pixel_a)\\n \\n \\n # check which zeniths are beyond threshold\\n bad_idx = np.where(hit_pixel_z > cut)\\n\\n # set hit pixels to output array\\n za_idx = np.array([hit_pixel_zi,hit_pixel_ai]).astype(int)\\n\\n #print(za_idx)\\n # weight array includes ones and zeros only (no neighbouring pixels included)\\n # bad_idx get zeros (outside range)\\n weights = np.ones(len(zenith))\\n weights[bad_idx] = 0\\n\\n # check for negative weights and indices and remove\\n weights[za_idx[0,:] < 0] = 0.\\n weights[za_idx[1,:] < 0] = 0.\\n za_idx[0,za_idx[0,:] < 0] = 0.\\n za_idx[1,za_idx[1,:] < 0] = 0.\\n \\n # get responses at pixels\\n rsp = Response[za_idx[0,:],za_idx[1,:],:]*weights[:,None]\\n\\n return rsp\",\n \"def get_landmark_range_limits_v3(stack=None, label_indices_lookup=None, filtered_labels=None, mid_index=None):\\n\\n print 'label_indices_lookup:'\\n\\n print\\n for label in sorted(label_indices_lookup.keys()):\\n print label, label_indices_lookup[label]\\n print\\n\\n print 'Estimated mid-sagittal image index = %d' % (mid_index)\\n\\n landmark_limits = {}\\n\\n structures_sided = set(label_indices_lookup.keys())\\n\\n if filtered_labels is not None:\\n structures_sided = set(label_indices_lookup.keys()) & set(filtered_labels)\\n\\n structures_unsided = set(map(convert_to_unsided_label, structures_sided))\\n\\n for name_u in structures_unsided:\\n\\n if name_u in singular_structures:\\n # single\\n sections = sorted(label_indices_lookup[name_u]) if name_u in label_indices_lookup else []\\n assert len(sections) > 0\\n\\n landmark_limits[name_u] = (np.min(sections), np.max(sections))\\n else:\\n # paired\\n\\n lname = convert_to_left_name(name_u)\\n rname = convert_to_right_name(name_u)\\n\\n confirmed_left_sections = sorted(label_indices_lookup[lname]) if lname in label_indices_lookup else []\\n confirmed_right_sections = sorted(label_indices_lookup[rname]) if rname in label_indices_lookup else []\\n unconfirmed_side_sections = sorted(label_indices_lookup[name_u]) if name_u in label_indices_lookup else []\\n\\n sections = sorted(confirmed_left_sections + confirmed_right_sections + unconfirmed_side_sections)\\n assert len(sections) > 0\\n\\n # Initialize votes according to whether a section is to the left or right of the mid-sagittal section.\\n votes = {sec: 1 if sec > mid_index else -1 for sec in sections}\\n\\n if len(sections) == 1:\\n sys.stderr.write('Structure %s has a label on only one section. Use its side relative to the middle section.\\\\n' % name_u)\\n sec = sections[0]\\n if sec < mid_index:\\n landmark_limits[lname] = (sec, sec)\\n else:\\n landmark_limits[rname] = (sec, sec)\\n continue\\n\\n else:\\n for sec in confirmed_left_sections:\\n for s in sections:\\n if s <= sec:\\n votes[s] -= 1\\n\\n for sec in confirmed_right_sections:\\n for s in sections:\\n if s >= sec:\\n votes[s] += 1\\n\\n print sorted(votes.items())\\n\\n unknown_side_sections = sorted([vote for sec, vote in votes.iteritems() if vote == 0])\\n if len(unknown_side_sections) > 0:\\n print 'unknown_side_sections', unknown_side_sections\\n\\n inferred_left_sections = sorted([sec for sec, vote in votes.iteritems() if vote < 0])\\n if len(inferred_left_sections) > 0:\\n minL = np.min(inferred_left_sections)\\n maxL = np.max(inferred_left_sections)\\n else:\\n minL = None\\n maxL = None\\n\\n inferred_right_sections = sorted([sec for sec, vote in votes.iteritems() if vote > 0])\\n if len(inferred_right_sections) > 0:\\n minR = np.min(inferred_right_sections)\\n maxR = np.max(inferred_right_sections)\\n else:\\n minR = None\\n maxR = None\\n\\n landmark_limits[lname] = (minL, maxL)\\n landmark_limits[rname] = (minR, maxR)\\n\\n return landmark_limits\",\n \"def prepare_score_metrics_by_chr(\\n hzxys, region_ids, homolog_center_zxys, \\n prev_homolog_hzxys=None, local_range=5,\\n ) -> np.ndarray:\\n from scipy.spatial.distance import cdist\\n # return empty of empty coords\\n if len(hzxys) == 0:\\n return np.array([])\\n if prev_homolog_hzxys is not None and len(prev_homolog_hzxys) != len(homolog_center_zxys):\\n raise IndexError(f\\\"length of prev_homolog_hzxys doesn't match\\\")\\n # init metric\\n _metrics = np.ones([3, len(homolog_center_zxys), len(hzxys)]) * np.nan\\n # 1. intensities\\n _metrics[0,:,:] = hzxys[:,0]\\n # 2. chr_center distance\\n _metrics[1,:,:] = cdist(homolog_center_zxys, hzxys[:,1:])\\n # 3. chr_local distance\\n ## no prev zxys, then assign everything nearby\\n if prev_homolog_hzxys is None:\\n for _i, _id in enumerate(region_ids):\\n _sel_inds = np.where((region_ids>=_id-local_range) & (region_ids<=_id+local_range))[0]\\n _sel_inds = np.setdiff1d(_sel_inds, [_i])\\n if len(_sel_inds) > 0:\\n _zxy = hzxys[_i,1:]\\n _dist = np.linalg.norm(_zxy - np.nanmean(hzxys[_sel_inds,1:], axis=0))\\n _metrics[2,:,_i] = _dist\\n else:\\n for _i, _id in enumerate(region_ids):\\n _sel_ref_inds = np.arange(max(0,_id-local_range), min(len(prev_homolog_hzxys[0]), _id+local_range+1))\\n _sel_ref_inds = np.setdiff1d(_sel_ref_inds, [_i])\\n if len(_sel_ref_inds) == 0:\\n continue\\n for _ihomo, _ref_hzxys in enumerate(prev_homolog_hzxys):\\n _zxy = hzxys[_i,1:]\\n _dist = np.linalg.norm(_zxy - np.nanmean(_ref_hzxys[_sel_ref_inds,1:], axis=0))\\n _metrics[2, _ihomo, _i] = _dist\\n return _metrics\",\n \"def create_centers(img_input, r, color_treshold):\\n\\n # make a copy of the input image\\n img_np = np.copy(img_input[:,:,2])\\n\\n # cast radius to int\\n r = np.int32(r)\\n\\n # define the dimensions of extended image\\n ext1 = img_np.shape[0]+2*r\\n ext2 = img_np.shape[1]+2*r\\n\\n # create the extended image \\n img_ext = np.zeros((ext1, ext2))\\n \\n # indexing for copying all img_np pixels into img_ext\\n left_index = (r,r)\\n right_index = (img_ext.shape[0]-r, img_ext.shape[1]-r)\\n \\n # select axis0 and axis1 values of img_ext which are to be \\n # replaced with img_np values.\\n img_ext[left_index[0]:right_index[0], left_index[1]:right_index[1]] = img_np\\n #io.imshow(img_ext)\\n #io.show()\\n #print(img_ext)\\n\\n # define the circular mask of radius r. \\n mask = mk.circular_mask(r)\\n\\n \\n # WHILE INSTANTIATION\\n # This loop finds out the positions of intensity values maxcol \\n # in the image. maxcol is initially set to 255, but \\n # gets updated during the loop and will correspond to the maximum\\n # intensity value found in the image. Then, all pixels will be \\n # selected with the same intensity value. \\n \\n maxcol = 255\\n\\n # create an empty list to save the maximum intensity value corresponding \\n # to the center of a nucleus. \\n \\n save_c_max = []\\n\\n while maxcol > color_treshold:\\n # find maximum intensity value in img_ext.\\n maxcol = np.amax(img_ext)\\n\\n # find position of maxcol value\\n img_whitex, img_whitey = np.where(img_ext == maxcol)\\n\\n # select the first position with maximum intensity value\\n first = (img_whitex[0], img_whitey[0])\\n \\n # specify indices where to apply the mask\\n left_index = (first[0]-r, first[1]-r)\\n right_index = (first[0]+r, first[1]+r)\\n \\n # create a squared subselection of the img_ext whose size is equal to mask\\n submattochange = img_ext[left_index[0]:right_index[0], left_index[1]:right_index[1]]\\n \\n # apply the mask\\n img_ext[left_index[0]:right_index[0], left_index[1]:right_index[1]] = np.multiply(submattochange,mask)\\n \\n # show the cells replaced by the mask\\n # io.imshow(img_ext)\\n # io.show()\\n \\n # save the values of position and intensity\\n list_save = [first[0]-r, first[1]-r, maxcol]\\n \\n # put list_save list into save_c_max\\n save_c_max.append(list_save)\\n\\n # cast save_c_max to int\\n save_c_max = np.int32(np.array(save_c_max))\\n\\n i = 0\\n while i < save_c_max.shape[0]:\\n \\n # This while iterates over all found center pixels of\\n # the nuclei and replaces their color with red \\n # (channel 0, intensity 255). \\n \\n img_input[save_c_max[i,0], save_c_max[i,1], 0] = 255\\n i = i+1\\n \\n #r\\\"\\\"\\\"\\n #Display image of the nuclei whose found center pixel \\n #is colored red. \\n #\\\"\\\"\\\"\\n #plt.figure()\\n #io.imshow(img_input)\\n #io.show()\\n \\n return save_c_max # np.array that contains int of position and intensity of the centers\",\n \"def intersect(self, ray):\\n # TODO A5 (Step3 and Step4) implement this function\\n # For step 4, check if uvs and normals are not None (respectively)\\n # If so, then interpolate them\\n\\n # batch_intersect returns t, beta, gamma, i\\n posns = self.posns\\n uvs = self.uvs\\n inds = self.inds\\n normals = self.normals\\n t, beta, gamma, i = batch_intersect(posns[inds[:, :]], ray)\\n if (t == np.inf):\\n return no_hit\\n vs = posns[inds[i, :]]\\n P = ray.origin + t * ray.direction\\n\\n if (t == np.inf):\\n return no_hit\\n else:\\n\\n alpha = 1 - beta - gamma\\n\\n if uvs is not None:\\n\\n uv0 = uvs[inds[i][0]]\\n uv1 = uvs[inds[i][1]]\\n uv2 = uvs[inds[i][2]]\\n\\n uv = alpha * uv0 + beta * uv1 + gamma * uv2\\n\\n else:\\n\\n A = np.linalg.norm(np.cross(vs[1] - vs[0], vs[2] - vs[0])) / 2\\n areaA = np.linalg.norm(np.cross(vs[1] - P, vs[2] - P)) / 2\\n areaB = np.linalg.norm(np.cross(vs[0] - P, vs[2] - P)) / 2\\n areaC = np.linalg.norm(np.cross(vs[0] - P, vs[1] - P)) / 2\\n u = areaB / A\\n v = areaC / A\\n uv = vec([u, v])\\n\\n if normals is not None:\\n\\n n0 = normals[inds[i][0]]\\n n1 = normals[inds[i][1]]\\n n2 = normals[inds[i][2]]\\n\\n unit_normal = normalize(alpha * n0 + beta * n1 + gamma * n2)\\n\\n else:\\n unit_normal = normalize(np.cross(vs[0] - vs[2], vs[1] - vs[2]))\\n\\n return Hit(t, P, unit_normal, uv, self.material)\",\n \"def find_window_centroids(self, warped):\\n window_width = self.window_width\\n window_height = self.window_height\\n margin = self.margin\\n \\n window_centroids = [] # store the (left,right) window centroids positions per level\\n window = np.ones(window_width) # Create window templates for doing convolutions\\n \\n # First find the two starting positions right and left lines by using np.sum to get the vertical image slice\\n # and then np.convolve the vertical image slice with the window template\\n \\n # sum the bottom quarter of image to get slice\\n l_sum = np.sum(warped[int(3*warped.shape[0]/4):,:int(3*warped.shape[1]/2)], axis=0)\\n l_center = np.argmax(np.convolve(window,l_sum)) - window_width/2\\n r_sum = np.sum(warped[int(3*warped.shape[0]/4):int(3*warped.shape[1]/2),:], axis=0)\\n r_center = np.argmax(np.convolve(window,r_sum)) - window_width/2 + int(warped.shape[1]/2)\\n \\n # add what we found for the first layer\\n window_centroids.append((l_center,r_center))\\n \\n # Go through each layer looking for max pixel location\\n for level in range(1,(int)(warped.shape[0]/window_height)):\\n # convolve the window into the vertical slice of the image\\n image_layer = np.sum(warped[int(warped.shape[0]-(level+1)*window_height):int(warped.shape[0]-level*window_height),:], axis=0)\\n conv_signal = np.convolve(window,image_layer)\\n # Find the best left centroid by using past left center as a reference \\n # Use window_width/2 as offset because convolution signal reference is at right side of window, not center of window\\n offset = window_width/2\\n l_min_index = int(max(l_center+offset-margin,0))\\n l_max_index = int(max(l_center+offset+margin,warped.shape[1]))\\n l_center = np.argmax(conv_signal[l_min_index:l_max_index]) + l_min_index - offset\\n \\n # Find the best right centroid by using past right center as a reference\\n r_min_index = int(max(r_center+offset-margin,0))\\n r_max_index = int(max(r_center+offset+margin,warped.shape[1]))\\n r_center = np.argmax(conv_signal[r_min_index:r_max_index]) + r_min_index - offset\\n # Add what we found for the layer\\n window_centroids.append((l_center,r_center))\\n \\n self.recent_centers.append(window_centroids)\\n # return averaged value of of the line centers, helps to keep the markers from jumping around too much\\n average_line_centers = np.average(self.recent_centers[-self.smooth_factor:], axis=0)\\n return average_line_centers\",\n \"def _extract_shape(idx, x, j, cur_center, normalize=True):\\r\\n _a = []\\r\\n for i in range(len(idx)):\\r\\n if idx[i] == j:\\r\\n if cur_center.sum() == 0:\\r\\n opt_x = x[i]\\r\\n else:\\r\\n _, opt_x = _sbd(cur_center, x[i])\\r\\n _a.append(opt_x)\\r\\n a = np.array(_a)\\r\\n\\r\\n if len(a) == 0:\\r\\n return np.zeros((1, x.shape[1]))\\r\\n columns = a.shape[1]\\r\\n if normalize:\\r\\n y = zscore(a, axis=1, ddof=1)\\r\\n s = np.dot(y.transpose(), y)\\r\\n\\r\\n p = np.empty((columns, columns))\\r\\n p.fill(1.0/columns)\\r\\n p = np.eye(columns) - p\\r\\n\\r\\n m = np.dot(np.dot(p, s), p)\\r\\n _, vec = eigh(m)\\r\\n else: \\r\\n s = np.dot(a.transpose(), a)\\r\\n m = s \\r\\n _, vec = eigh(m)\\r\\n \\r\\n centroid = vec[:, -1]\\r\\n finddistance1 = math.sqrt(((a[0] - centroid) ** 2).sum())\\r\\n finddistance2 = math.sqrt(((a[0] + centroid) ** 2).sum())\\r\\n\\r\\n if finddistance1 >= finddistance2:\\r\\n centroid *= -1\\r\\n \\r\\n return zscore(centroid, ddof=1) if normalize else centroid\",\n \"def gonio_axis_align():\\n \\n # Invert camera image, so dark pin on light image becomes a peak\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # High threshold, so AD centroid doesn't interpret background\\n cam_8ThresholdOld = cam_8.stats4.centroid_threshold.get()\\n cam_8.stats4.centroid_threshold.put(150)\\n cam_7ThresholdOld = cam_7.stats4.centroid_threshold.get()\\n cam_7.stats4.centroid_threshold.put(150)\\n \\n # HiMag\\n # Copy ROI2 geometry (HiMag Mag3) to ROI4 and use ROI4 centroid plugin\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get())\\n cam_8.roi4.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get())\\n cam_8.roi4.size.x.put(cam_8.roi2.size.x.get() * 0.20)\\n cam_8.roi4.size.y.put(cam_8.roi2.size.y.get())\\n cam_8.roi4.min_xyz.min_x.put(cam_8.roi2.min_xyz.min_x.get() + cam_8.roi2.size.x.get()/2 - cam_8.roi4.size.x.get()/2)\\n \\n # LoMag\\n # Copy ROI2 geometry (LoMag Mag1) to ROI4 and use ROI4 centroid plugin\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get())\\n cam_7.roi4.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get())\\n cam_7.roi4.size.x.put(cam_7.roi2.size.x.get() * 0.05)\\n cam_7.roi4.size.y.put(cam_7.roi2.size.y.get())\\n cam_7.roi4.min_xyz.min_x.put(cam_7.roi2.min_xyz.min_x.get() + cam_7.roi2.size.x.get()/2 - cam_7.roi4.size.x.get()/2)\\n \\n centerPinYHiMag0 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag0 = centroid_avg(cam_7.stats4)[1]\\n yield from bps.mvr(gonio.o,180)\\n time.sleep(2)\\n centerPinYHiMag180 = centroid_avg(cam_8.stats4)[1]\\n centerPinYLoMag180 = centroid_avg(cam_7.stats4)[1]\\n centerPinYHiMag = (centerPinYHiMag0 + centerPinYHiMag180)/2\\n centerPinYLoMag = (centerPinYLoMag0 + centerPinYLoMag180)/2\\n\\n centerPinOffsYHiMag = centerPinYHiMag - cam_8.roi4.size.y.get() / 2\\n centerPinOffsYLoMag = centerPinYLoMag - cam_7.roi4.size.y.get() / 2\\n \\n # Correct Mag 3 (cam_8 ROI2)\\n cam_8.roi2.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + centerPinOffsYHiMag)\\n # Correct Mag 4 (cam_8 ROI1)\\n cam_8.roi1.min_xyz.min_y.put(cam_8.roi2.min_xyz.min_y.get() + (cam_8.roi2.size.y.get()-cam_8.roi1.size.y.get())/2)\\n \\n # Correct Mag 1 (cam_7 ROI2)\\n cam_7.roi2.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + centerPinOffsYLoMag)\\n # Correct Mag 2 (cam_7 ROI3)\\n cam_7.roi3.min_xyz.min_y.put(cam_7.roi2.min_xyz.min_y.get() + (cam_7.roi2.size.y.get()-cam_7.roi3.size.y.get())/2)\\n\\n # De-invert image\\n cam_7.proc1.scale.put(-1)\\n cam_8.proc1.scale.put(-1)\\n \\n # Set thresold to previous value\\n cam_8.stats4.centroid_threshold.put(cam_8ThresholdOld)\\n cam_7.stats4.centroid_threshold.put(cam_7ThresholdOld)\\n \\n return\",\n \"def locatePeaks(self,thresholds,norm=False):\\n\\n\\t\\tassert thresholds is not None\\n\\t\\tif isinstance(thresholds,tuple):\\n\\t\\t\\tassert len(thresholds)==2\\n\\t\\t\\tthresholds = np.array(thresholds)\\n\\n\\t\\t#Check if the map is masked\\n\\t\\tif self._masked:\\n\\n\\t\\t\\tif not hasattr(self,\\\"_full_mask\\\"):\\n\\t\\t\\t\\tself.maskBoundaries()\\n\\n\\t\\t\\tmask_profile = self._full_mask\\n\\n\\t\\telse:\\n\\n\\t\\t\\tmask_profile = None \\n\\n\\t\\t#Decide if normalizing thresholds\\n\\t\\tif norm:\\n\\t\\t\\t\\n\\t\\t\\tif self._masked:\\n\\t\\t\\t\\tsigma = self.data[self._full_mask].std()\\n\\t\\t\\telse:\\n\\t\\t\\t\\tsigma = self.data.std()\\n\\n\\t\\telse:\\n\\t\\t\\tsigma = 1.0\\n\\n\\t\\t#Count the number of pixels between the selected thresholds\\n\\t\\trelevant_pixels = ((self.data>=thresholds[0]*sigma) * (self.data<=thresholds[-1]*sigma)).sum()\\n\\n\\t\\t#Return the result of the C backend call, scaled to the proper units\\n\\t\\tpeak_values,peak_locations = _topology.peakLocations(self.data,mask_profile,thresholds,sigma,relevant_pixels)\\n\\n\\t\\treturn peak_values,(peak_locations*self.resolution).to(self.side_angle.unit)\",\n \"def compute_bounding_box(homography, w, h):\\n\\n # todo in what step to do int??\\n # todo should i do -1? if so why?\\n\\n\\n all_corners = np.array([[0, 0], [w, 0], [0, h], [w, h]])\\n all_corners = apply_homography(all_corners,homography)\\n top_left = [np.min(all_corners[:,0]),np.min(all_corners[:,1])]\\n bottom_right = [np.max(all_corners[:,0]),np.max(all_corners[:,1])]\\n return np.array([top_left,bottom_right]).astype(np.int)\",\n \"def getPixelVisualCenter(self, altMap, aziMap):\\r\\n\\r\\n altPatch = self.array * altMap\\r\\n meanAlt = np.mean(altPatch[altPatch != 0])\\r\\n aziPatch = self.array * aziMap\\r\\n meanAzi = np.mean(aziPatch[aziPatch != 0])\\r\\n\\r\\n return meanAlt, meanAzi\",\n \"def rf_extents(rf_dict):\\n x_min, y_min, x_max, y_max = np.inf, np.inf, -np.inf, -np.inf\\n for rf in rf_dict:\\n x_min = np.min([rf['on_center_x'], x_min])\\n x_max = np.max([rf['on_center_x'], x_max])\\n y_min = np.min([rf['on_center_y'], y_min])\\n y_max = np.max([rf['on_center_y'], y_max])\\n if x_min == x_max:\\n x_max += 1\\n if y_min == y_max:\\n y_max += 1\\n return {\\n 'x_min': x_min,\\n 'x_max': x_max,\\n 'y_min': y_min,\\n 'y_max': y_max\\n }\",\n \"def _get_centers(self, lwidth, lheight, batch_size):\\n x_left, y_left = tf.meshgrid(tf.range(0, lheight), tf.range(0, lwidth))\\n x_y = K.stack([x_left, y_left], axis = -1)\\n x_y = tf.cast(x_y, dtype = self.dtype)/tf.cast(lwidth, dtype = self.dtype)\\n x_y = tf.repeat(tf.expand_dims(tf.repeat(tf.expand_dims(x_y, axis = -2), self._num, axis = -2), axis = 0), batch_size, axis = 0)\\n return x_y\",\n \"def cloud_top_height(\\n r,\\n azimuth,\\n elevation,\\n st_sweep,\\n ed_sweep,\\n refl,\\n eth_thld=0,\\n noise_thld=-2,\\n min_range=15e3,\\n verbose=False,\\n):\\n earth_radius = 6371000\\n\\n na0 = st_sweep[1]\\n nsweep = len(st_sweep)\\n cloudtop = np.zeros((na0, len(r))) + np.NaN\\n ground_range = np.zeros((nsweep, len(r)))\\n elev_ref = elevation[0]\\n\\n for i, st in enumerate(st_sweep):\\n ground_range[i, :] = r * np.cos(np.pi * elevation[st + 1] / 180)\\n\\n for i in range(1, len(st_sweep)):\\n st = st_sweep[i]\\n ed = ed_sweep[i]\\n elev_ref = elevation[st_sweep[i - 1]]\\n elev_iter = elevation[st]\\n\\n st_ref = st_sweep[i - 1]\\n ed_ref = ed_sweep[i - 1]\\n\\n if verbose:\\n print(i, st, ed, elev_iter, elev_ref)\\n\\n for j in range(na0):\\n nbeam_ref = np.argmin(np.abs(azimuth[st_ref:ed_ref] - azimuth[j])) + st_ref\\n nbeam_iter = np.argmin(np.abs(azimuth[st:ed] - azimuth[j])) + st\\n\\n if np.abs(azimuth[nbeam_ref] - azimuth[nbeam_iter]) > 5:\\n continue\\n\\n for k in range(len(r)):\\n if r[k] < min_range:\\n continue\\n\\n gr_ref = ground_range[i - 1, k]\\n npos = np.argmin(np.abs(ground_range[i, :] - gr_ref))\\n\\n if np.abs(ground_range[i, npos] - ground_range[0, k] > 1000):\\n continue\\n\\n refb = refl[nbeam_ref, k]\\n refa = refl[nbeam_iter, npos]\\n\\n if refb < noise_thld:\\n continue\\n\\n if refa < noise_thld or np.isnan(refa):\\n refa = noise_thld\\n\\n height = np.NaN\\n if refb > eth_thld and refa < eth_thld:\\n if elev_iter == 90:\\n theta_total = elev_iter + 0.5\\n else:\\n theta_total = (eth_thld - refa) * (elev_ref - elev_iter) / (refb - refa) + elev_ref\\n\\n # Include correction for Earth sphericity.\\n height = (r[k] * np.sin(np.pi * theta_total / 180) +\\n np.sqrt(r[k] ** 2 + earth_radius ** 2) - earth_radius)\\n\\n if np.isnan(height):\\n continue\\n\\n if height > cloudtop[j, k] or np.isnan(cloudtop[j, k]):\\n cloudtop[j, k] = height\\n\\n return cloudtop\",\n \"def compute_centers(landmarks):\\n b = landmarks.shape[0]\\n lms = landmarks.reshape((b, -1, 3))\\n\\n eye_left_centers = lms[:, EYE_LEFT_CONTOUR, :2].mean(axis=1)\\n eye_right_centers = lms[:, EYE_RIGHT_CONTOUR, :2].mean(axis=1)\\n mouth_centers = lms[:, MOUTH_INNER_CONTOUR, :2].mean(axis=1)\\n\\n a = np.concatenate((eye_left_centers, eye_right_centers, mouth_centers), axis=1)\\n\\n return a\",\n \"def find_max_score_location(grid, shape):\",\n \"def create_pos_overlap_metric(anchor_boxes):\\n y, x, h, w = np.transpose(anchor_boxes)\\n y0 = y - h // 2\\n x0 = x - w // 2\\n y1 = y + h // 2\\n x1 = x + w // 2\\n\\n def pos_overlap(gt_boxes):\\n pos_overlaps = []\\n for gt_box in gt_boxes:\\n gt_y0, gt_x0, gt_y1, gt_x1 = gt_box\\n gt_area = (gt_x1 - gt_x0) * (gt_y1 - gt_y0)\\n int_y0 = np.maximum(gt_y0, y0)\\n int_x0 = np.maximum(gt_x0, x0)\\n int_y1 = np.minimum(gt_y1, y1)\\n int_x1 = np.minimum(gt_x1, x1)\\n int_area = np.maximum(0, int_x1 - int_x0) * np.maximum(0, int_y1 - int_y0)\\n pos_overlaps.append(int_area / gt_area)\\n # Group by anchor boxes\\n pos_overlaps = np.transpose(pos_overlaps)\\n # Get max metric index\\n gt_indices = np.argmax(pos_overlaps, axis=1)\\n # Choose max metric\\n pos_overlaps = np.squeeze(np.take_along_axis(pos_overlaps, gt_indices[:, np.newaxis], axis=1))\\n # Take respective ground-truth boxes. No reason to return indices, at least in RPN\\n gt_boxes = np.take(gt_boxes, gt_indices, axis=0)\\n return pos_overlaps, gt_boxes\\n return pos_overlap\",\n \"def _get_grid_cell_indexes(proj, xs, ys, bounding_box):\\n # Unpack values from the projection\\n eq_rad = proj.semi_major_axis\\n polar_rad = proj.semi_minor_axis\\n h = proj.perspective_point_height + eq_rad\\n lon0 = proj.longitude_of_projection_origin\\n \\n # Unpack values from the area we want to grab the data\\n min_lat, min_lon = bounding_box.sw_corner()\\n max_lat, max_lon = bounding_box.ne_corner()\\n \\n with np.errstate(invalid='ignore'):\\n # Calculate the lat and lon grids\\n xs, ys = np.meshgrid(xs, ys)\\n a_vals = np.power(np.sin(xs), 2.0) + \\\\\\n np.power(np.cos(xs), 2.0) * (np.power(np.cos(ys), 2.0) + \\\\\\n eq_rad * eq_rad / polar_rad / polar_rad * np.power(np.sin(ys), 2.0))\\n b_vals = -2 * h * np.cos(xs) * np.cos(ys)\\n c_val = h * h - eq_rad * eq_rad\\n \\n rs = (-b_vals - np.sqrt(np.power(b_vals, 2.0) - 4 * a_vals * c_val)) / (2 * a_vals)\\n \\n sx = rs * np.cos(xs) * np.cos(ys)\\n sy = -rs * np.sin(xs)\\n sz = rs * np.cos(xs) * np.sin(ys)\\n \\n lats = np.arctan((eq_rad *eq_rad * sz) \\\\\\n / (polar_rad * polar_rad * np.sqrt(np.power(h - sx, 2.0) + np.power(sy, 2.0))))\\n lats = np.degrees(lats)\\n \\n lons = np.radians(lon0) - np.arctan(sy / (h - sx))\\n lons = np.degrees(lons)\\n \\n # Flatten the arrays so we get a 1D list of indexes\\n lats = lats.flatten()\\n lons = lons.flatten()\\n \\n # Filter out values not in our bounding box\\n lats = np.where(np.logical_and(lats >= min_lat, lats <= max_lat))[0]\\n lons = np.where(np.logical_and(lons >= min_lon, lons <= max_lon))[0]\\n idxs = list(set(lons).intersection(set(lats)))\\n \\n return idxs\",\n \"def nms(bounds, classes, scores): # pylint: disable=too-many-locals, no-member\\n best_bounds = []\\n best_scores = []\\n best_classes = []\\n for i in list(np.unique(classes)):\\n mask_class = classes == i\\n bounds_class = bounds[mask_class, :]\\n scores_class = scores[mask_class]\\n while bounds_class.size > 0:\\n max_index = np.argmax(scores_class)\\n best_bound = bounds_class[max_index]\\n best_bounds.append(best_bound)\\n best_scores.append(scores_class[max_index])\\n best_classes.append(i)\\n bounds_class = np.delete(bounds_class, max_index, axis=0)\\n scores_class = np.delete(scores_class, max_index)\\n if bounds_class.size == 0:\\n break\\n best_area = (best_bound[2] - best_bound[0]) * (best_bound[3] - best_bound[1])\\n areas = (bounds_class[:, 2] - bounds_class[:, 0]) * (bounds_class[:, 3] - bounds_class[:, 1])\\n xmax = np.maximum(best_bound[0], bounds_class[:, 0])\\n xmin = np.minimum(best_bound[2], bounds_class[:, 2])\\n ymax = np.maximum(best_bound[1], bounds_class[:, 1])\\n ymin = np.minimum(best_bound[3], bounds_class[:, 3])\\n width = np.maximum(0, xmin - xmax + 1)\\n height = np.maximum(0, ymin - ymax + 1)\\n areas_intersection = width * height\\n iou = areas_intersection / (best_area + areas - areas_intersection)\\n mask_iou = iou < 0.45\\n bounds_class = bounds_class[mask_iou, :]\\n scores_class = scores_class[mask_iou]\\n return best_bounds, best_classes, best_scores\",\n \"def bounds(self, resids: NDArray) -> List[Tuple[float, float]]:\",\n \"def get_likelihood(self, source_x, source_y, core_x, core_y,\\n energy, x_max_scale):\\n\\n # First we add units back onto everything. Currently not\\n # handled very well, maybe in future we could just put\\n # everything in the correct units when loading in the class\\n # and ignore them from then on\\n\\n zenith = 90 * u.deg - self.array_direction[0]\\n azimuth = self.array_direction[1]\\n # Geometrically calculate the depth of maximum given this test position\\n\\n if self.fit_xmax:\\n x_max = self.get_shower_max(source_x, source_y,\\n core_x, core_y,\\n zenith.to(u.rad).value) * x_max_scale\\n\\n # Calculate expected Xmax given this energy\\n x_max_exp = 300 + 93 * np.log10(energy)\\n\\n # Convert to binning of Xmax, addition of 100 can probably be\\n # removed\\n x_max_bin = x_max.value - x_max_exp\\n\\n # Check for range\\n if x_max_bin > 100:\\n x_max_bin = 100\\n if x_max_bin < -100:\\n x_max_bin = -100\\n else:\\n x_max_bin = x_max_scale * 37.8\\n if x_max_bin < 13:\\n x_max_bin = 13\\n\\n sum_like = 0\\n for tel_count in self.image: # Loop over all telescopes\\n # Calculate impact distance for all telescopes\\n impact = np.sqrt(pow(self.tel_pos_x[tel_count] - core_x, 2)\\n + pow(self.tel_pos_y[tel_count] - core_y, 2))\\n # And the expected rotation angle\\n phi = np.arctan2((self.tel_pos_y[tel_count] - core_y),\\n (self.tel_pos_x[tel_count] - core_x)) # - (math.pi/2.)\\n\\n # Rotate and translate all pixels such that they match the\\n # template orientation\\n pix_x_rot, pix_y_rot = self.rotate_translate(\\n self.pixel_x[tel_count] * -1,\\n self.pixel_y[tel_count],\\n source_x, source_y, phi\\n )\\n\\n # Then get the predicted image, convert pixel positions to deg\\n prediction = self.image_prediction(\\n self.type[tel_count],\\n zenith, azimuth, energy, impact, x_max_bin,\\n pix_x_rot * (180 / math.pi),\\n pix_y_rot * (180 / math.pi)\\n )\\n prediction[np.isnan(prediction)] = 0\\n prediction[prediction < 1e-6] = 1e-6\\n\\n # Scale templates to match simulations\\n prediction *= self.scale[self.type[tel_count]]\\n # Get likelihood that the prediction matched the camera image\\n like = poisson_likelihood_gaussian(self.image[tel_count],\\n prediction,\\n self.spe,\\n self.ped[tel_count])\\n if np.any(prediction == np.inf):\\n print(\\\"inf found at \\\", self.type[tel_count], zenith,\\n azimuth, energy, impact, x_max_bin)\\n like[np.isnan(like)] = 1e9\\n sum_like += np.sum(like)\\n if np.sum(prediction) is 0:\\n sum_like += 1e9\\n\\n return sum_like\",\n \"def get_score_and_geo(images, labels, data_iter_type='ImageDetIter'):\\n for i, image in enumerate(images):\\n height, width = image.shape[1], image.shape[2]\\n poly_mask = np.zeros((height, width), dtype=np.uint8)\\n score_map = np.zeros((images.shape[0], height, width), dtype=np.uint8)\\n geo_map = np.zeros((images.shape[0], height, width, 5), dtype=np.float32)\\n if data_iter_type == 'MXDataIter':\\n label = labels[i].asnumpy() # 1-D Array\\n label = np.delete(label, np.where(label == -1)) # Delete all -1 padding\\n c, h, w, label_width, header_length, bbox_label_width, orig_h, orig_w = label[:8]\\n polys = np.reshape(label[8:], (int(len(label[8:]) / bbox_label_width), -1)) # (Num_of_polys, bbox_label_width)\\n vocab_idx = polys[:, 1]\\n polys = polys[:, 1:]\\n\\n elif data_iter_type == 'ImageDetIter':\\n label = labels[i].asnumpy() # 1-D Array\\n polys = np.delete(label, np.where(label[:, 0] == -1), axis=0)\\n vocab_idx = polys[:, 1]\\n polys = polys[:, 1:]\\n\\n # For each polygon (bounding box) in the label\\n for poly in polys:\\n poly = np.reshape(poly, (4, 2))\\n poly[:, 0] = np.round(poly[:, 0] * height, 0)\\n poly[:, 1] = np.round(poly[:, 1] * width, 0)\\n\\n poly = np.array(poly).astype(np.int32)\\n # Draw polygon on the score mask (binary map)\\n cv2.fillPoly(score_map[i], [poly], (1))\\n # Draw polygon on the poly_mask (binary map) that will be used to create geo_map\\n cv2.fillPoly(poly_mask, [poly], (1))\\n\\n fitted_parallelograms = []\\n # For the number of sides (4) in the polygon\\n for j in range(4):\\n # Rotate the orientation at each iter\\n p0 = poly[j]\\n p1 = poly[(j + 1) % 4]\\n p2 = poly[(j + 2) % 4]\\n p3 = poly[(j + 3) % 4]\\n\\n edge = fit_line([p0[0], p1[0]], [p0[1], p1[1]])\\n if point_dist_to_line(p0, p1, p2) > point_dist_to_line(p0, p1, p3):\\n if edge[1] == 0:\\n edge_opposite = [1, 0, -p2[0]]\\n else:\\n edge_opposite = [edge[0], -1, p2[1] - edge[0] * p2[0]]\\n else:\\n if edge[1] == 0:\\n edge_opposite = [1, 0, -p3[0]]\\n else:\\n edge_opposite = [edge[0], -1, p3[1] - edge[0] * p3[0]]\\n\\n # move forward edge\\n new_p0 = p0\\n new_p1 = p1\\n new_p2 = p2\\n new_p3 = p3\\n forward_edge = fit_line([p1[0], p2[0]], [p1[1], p2[1]])\\n new_p2 = line_cross_point(forward_edge, edge_opposite)\\n if point_dist_to_line(p1, new_p2, p0) > point_dist_to_line(p1, new_p2, p3):\\n # across p0\\n if forward_edge[1] == 0:\\n forward_opposite = [1, 0, -p0[0]]\\n else:\\n forward_opposite = [forward_edge[0], -1, p0[1] - forward_edge[0] * p0[0]]\\n else:\\n # across p3\\n if forward_edge[1] == 0:\\n forward_opposite = [1, 0, -p3[0]]\\n else:\\n forward_opposite = [forward_edge[0], -1, p3[1] - forward_edge[0] * p3[0]]\\n new_p0 = line_cross_point(forward_opposite, edge)\\n new_p3 = line_cross_point(forward_opposite, edge_opposite)\\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\\n\\n # or move backward edge\\n new_p0 = p0\\n new_p1 = p1\\n new_p2 = p2\\n new_p3 = p3\\n backward_edge = fit_line([p0[0], p3[0]], [p0[1], p3[1]])\\n new_p3 = line_cross_point(backward_edge, edge_opposite)\\n if point_dist_to_line(p0, p3, p1) > point_dist_to_line(p0, p3, p2):\\n # across p1\\n if backward_edge[1] == 0:\\n backward_opposite = [1, 0, -p1[0]]\\n else:\\n backward_opposite = [backward_edge[0], -1, p1[1] - backward_edge[0] * p1[0]]\\n else:\\n # across p2\\n if backward_edge[1] == 0:\\n backward_opposite = [1, 0, -p2[0]]\\n else:\\n backward_opposite = [backward_edge[0], -1, p2[1] - backward_edge[0] * p2[0]]\\n new_p1 = line_cross_point(backward_opposite, edge)\\n new_p2 = line_cross_point(backward_opposite, edge_opposite)\\n fitted_parallelograms.append([new_p0, new_p1, new_p2, new_p3, new_p0])\\n\\n areas = [Polygon(t).area for t in fitted_parallelograms]\\n parallelogram = np.array(fitted_parallelograms[np.argmin(areas)][:-1], dtype=np.float32)\\n\\n # sort thie polygon\\n parallelogram_coord_sum = np.sum(parallelogram, axis=1)\\n min_coord_idx = np.argmin(parallelogram_coord_sum)\\n parallelogram = parallelogram[\\n [min_coord_idx, (min_coord_idx + 1) % 4, (min_coord_idx + 2) % 4, (min_coord_idx + 3) % 4]]\\n\\n rectangle = rectangle_from_parallelogram(parallelogram)\\n rectangle, rotate_angle = sort_rectangle(rectangle)\\n r0, r1, r2, r3 = rectangle\\n\\n # For all points of the polygon (bounding box), calculate geometric geo map\\n Y, X = np.where(poly_mask == 1)\\n for y, x in zip(Y, X):\\n point = np.array([x, y], dtype=np.float32)\\n # top\\n geo_map[i, y, x, 0] = point_dist_to_line(r0, r1, point)\\n # right\\n geo_map[i, y, x, 1] = point_dist_to_line(r1, r2, point)\\n # down\\n geo_map[i, y, x, 2] = point_dist_to_line(r2, r3, point)\\n # left\\n geo_map[i, y, x, 3] = point_dist_to_line(r3, r0, point)\\n # angle\\n geo_map[i, y, x, 4] = rotate_angle\\n\\n print (geo_map.shape)\\n exit()\\n\\n return score_map, geo_map\",\n \"def _compute_bounds(self, axis, view):\\n return None\",\n \"def get_centers(file_path = \\\"./data/input.jpeg\\\", n_rows=10, n_cols=10, verbose=False, image_thresh=20, hough_thresh=20, minDist=20, maxRadius=20):\\n print(\\\"looking for circles in the image\\\")\\n cimg = cv2.imread(file_path, 1)\\n gimg = cv2.cvtColor(cimg, cv2.COLOR_BGR2GRAY)\\n gimg = cv2.medianBlur(gimg, 5)\\n # threshold the image for better circle finding\\n _, gimg = cv2.threshold(gimg, image_thresh, 255, cv2.THRESH_BINARY)\\n\\n\\n # find circles on the image\\n circles = cv2.HoughCircles(gimg, cv2.HOUGH_GRADIENT, dp=1, minDist=minDist, param1=1, param2=hough_thresh, minRadius=5,\\n maxRadius=maxRadius)\\n\\n # re-sequence the circles found\\n circles = circles[0, :, :].reshape((-1, 3))\\n x_min = circles.min(axis=0)[0]\\n x_max = circles.max(axis=0)[0]\\n avg_spacing = (x_max - x_min) / (n_cols - 1)\\n x_segment = [x_min - avg_spacing / 2 + avg_spacing * i for i in range(11)]\\n def get_col_id(point):\\n # return which col this point sits\\n x = point[0]\\n for i in range(n_cols):\\n if x_segment[i] < x < x_segment[i + 1]:\\n return i\\n cols = [[] for i in range(n_cols)]\\n for circle in circles:\\n id = get_col_id(circle)\\n cols[get_col_id(circle)].append(circle)\\n for i, col in enumerate(cols):\\n cols[i] = list(sorted(col, key=lambda p:p[1]))\\n grid = np.zeros((n_rows, n_cols, 3))\\n for c in range(n_cols):\\n for r in range(n_rows):\\n grid[r, c, :] = cols[c][r]\\n\\n # plot theses circles to make sure the sequence is correct\\n gaussian_img = cv2.GaussianBlur(cv2.cvtColor(cimg, cv2.COLOR_BGR2GRAY), (5, 5), 0)\\n for c in range(10):\\n for r in range(10):\\n pos = grid[r, c, :2].astype(np.int)\\n radius = grid[r, c, 2].astype(np.int)\\n # draw the outer circle\\n cv2.circle(cimg, (pos[0], pos[1]), radius, (0, 255, 0), 2)\\n # draw the center of the circle\\n cv2.circle(cimg, (pos[0], pos[1]), 2, (0, 0, 255), 3)\\n # find the avg intensity at each center\\n grid[r, c, 2] = gaussian_img[pos[1], pos[0]]\\n if verbose:\\n cv2.imshow('circles found in the image', cimg)\\n cv2.waitKey(10)\\n\\n if verbose:\\n cv2.imshow('circles found in the image', cimg)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n\\n return grid\",\n \"def detector(centre_x, centre_y, height_z, radius, distance):\\r\\n z = np.linspace(0, height_z, 50)\\r\\n z = [i+distance for i in z]\\r\\n \\r\\n theta = np.linspace(0, 2*np.pi, 50)\\r\\n theta_grid, z_grid=np.meshgrid(theta, z)\\r\\n \\r\\n x_grid = radius*np.cos(theta_grid) + centre_x\\r\\n y_grid = radius*np.sin(theta_grid) + centre_y\\r\\n return x_grid, y_grid, z_grid\",\n \"def face_area(lon_b, lat_b, r_sphere = 6.375e6):\\n \\n # Convert inputs to radians\\n lon_b_rad = lon_b * np.pi / 180.0\\n lat_b_rad = lat_b * np.pi / 180.0\\n \\n r_sq = r_sphere * r_sphere\\n n_cs = lon_b.shape[1] - 1\\n \\n # Allocate output array\\n cs_area = np.zeros((n_cs,n_cs))\\n \\n # Ordering\\n valid_combo = np.array([[1,2,4],[2,3,1],[3,2,4],[4,1,3]]) - 1\\n \\n for i_lon in range(n_cs):\\n for i_lat in range(n_cs):\\n lon_corner = np.zeros(4)\\n lat_corner = np.zeros(4)\\n xyz_corner = np.zeros((4,3))\\n for i_vert in range(4):\\n x_lon = i_lon + (i_vert > 1)\\n x_lat = i_lat + (i_vert == 0 or i_vert == 3)\\n lon_corner[i_vert] = lon_b_rad[x_lon,x_lat]\\n lat_corner[i_vert] = lat_b_rad[x_lon,x_lat]\\n for i_vert in range(4):\\n xyz_corner[i_vert,:] = ll2xyz(lon_corner[i_vert],lat_corner[i_vert])\\n tot_ang = 0.0\\n for i_corner in range(4):\\n curr_combo = valid_combo[i_corner,:]\\n xyz_mini = np.zeros((3,3))\\n for i_mini in range(3):\\n xyz_mini[i_mini,:] = xyz_corner[curr_combo[i_mini],:]\\n curr_ang = sphere_angle(xyz_mini[0,:],xyz_mini[1,:],xyz_mini[2,:])\\n tot_ang += curr_ang\\n cs_area[i_lon,i_lat] = r_sq * (tot_ang - (2.0*np.pi))\\n \\n return cs_area\",\n \"def project_gravity_core(xyz):\\n ver = []\\n hor = []\\n \\n # mean for each axis\\n G = [np.mean(xyz[:, 0]), np.mean(xyz[:, 1]), np.mean(xyz[:, 2])]\\n G_norm = G/np.sqrt(sum(np.power(G, 2)) + 0.0000001)\\n \\n # The projection is here\\n for i in range(len(xyz[:, 0])):\\n ver.append(float(np.dot([xyz[i, :]], G)))\\n hor.append(float(np.sqrt(np.dot(xyz[i, :]-ver[i]*G_norm, xyz[i, :]-ver[i]*G_norm))))\\n \\n ver = np.reshape(np.asarray(ver), len(ver))\\n return Vectors.dense(ver), Vectors.dense(hor)\",\n \"def get_zscore_roi_centers(self, timeWindow=(0, 0.5), zscoreThr=2):\\n zscoreROION,zscoreROIOFF,zscoreROIALL,allAltPos,allAziPos = self.get_zscore_rois(timeWindow, zscoreThr)\\n if zscoreROION is not None:\\n centerON = zscoreROION.get_weighted_center_in_coordinate(allAltPos, allAziPos)\\n else:\\n centerON = None\\n\\n if zscoreROIOFF is not None:\\n centerOFF = zscoreROIOFF.get_weighted_center_in_coordinate(allAltPos, allAziPos)\\n else:\\n centerOFF = None\\n\\n if zscoreROIALL is not None:\\n centerALL = zscoreROIALL.get_weighted_center_in_coordinate(allAltPos, allAziPos)\\n else:\\n centerALL = None\\n return centerON, centerOFF, centerALL\",\n \"def compute_bounding_box(homography, w, h):\\n corners = np.array([[0,0],\\n [0,h],\\n [w,0],\\n [w,h]])\\n t_corners = apply_homography(corners, homography)\\n return np.array([t_corners.min(axis=0),t_corners.max(axis=0)],\\n dtype= np.int)\\n #[top-left, btm-right]\",\n \"def best_coords(self):\\n lat, lon = None, None\\n for term in self.terms:\\n # print(term)\\n # print(term['weight'])\\n geo = term.get(\\\"geo\\\")\\n if geo:\\n osm = geo['osm']\\n gm = geo['gm']\\n geo_data = None\\n if osm:\\n geo_data = osm\\n elif gm:\\n geo_data = gm\\n if geo_data:\\n g = geo_data[0]\\n lat, lon = g['latitude'], g['longitude']\\n break\\n return lat, lon, self.region\",\n \"def scan(self, cut_off, r0 = 4, dr = 2, rmax = 80, bg_global = 3419, sigma = 3.5 * 13.8):\\r\\n \\r\\n start_time = time.time()\\r\\n for trial in range(self.dimension):\\r\\n \\r\\n max_count, max_rank = self.pick_largest(cut_off = cut_off)\\r\\n fitted = 0 # galaxy not fitted to a circle\\r\\n point = [] # \\r\\n circle_number = 0\\r\\n \\r\\n if max_count == -1:\\r\\n print(\\\"Scan completed, number of galaxies found is \\\", len(self.galaxies), \\\"run time is\\\", time.time() - start_time)\\r\\n break\\r\\n \\r\\n if max_count >= 0: # That means a value that is larger than cut_off exists\\r\\n ypos,xpos = self.rank_yx(max_rank)\\r\\n # print(\\\"max_count, y, x\\\", max_count, ypos, xpos) \\r\\n \\r\\n \\r\\n for r in range(r0, rmax, dr): # r = radius, we know the largest radius can't be >80 by inspecting the pic.\\r\\n print(\\\"locating the galaxy position at\\\", ypos, xpos, \\\"at a radius r =\\\", r) \\r\\n if fitted == 1 or r == 80:\\r\\n # print(\\\"max_count, yx\\\",max_count, ypos, xpos, \\\"cut =\\\", no_cut, len(new_point)/2)\\r\\n \\r\\n self.mask_region(ypos, xpos, r - dr)\\r\\n # print(bg_local, no_bg)\\r\\n if r - dr > r0: # it must be a galaxy\\r\\n \\r\\n # getting the local bg\\r\\n if no_bg > 3: # check if enough data to deduce bg\\r\\n bg = bg_local / no_bg \\r\\n else:\\r\\n bg = bg_global\\r\\n \\r\\n if circle_number >= np.pi* 2* (r - dr)**2:\\r\\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\\r\\n\\r\\n else:\\r\\n if no_cut < circle_number/2 and circle_number*2 >= np.pi * (r0**2):\\r\\n self.galaxies.append(galaxy(ypos, xpos, r - dr, np.array(point).sum(), bg, circle_number))\\r\\n\\r\\n print(\\\"\\\\ngalaxy scan completed,radius =\\\", r - dr, \\\"position =\\\", ypos, xpos, \\\"max count =\\\", max_count, \\\"time = \\\", time.time() - start_time)\\r\\n\\r\\n break\\r\\n \\r\\n ##### Resetting parameters ####\\r\\n no_bg = 0 # number 0f background pixels\\r\\n bg_local = 0 # sum of local background noises\\r\\n no_cut = 0 # number of counts below cut off\\r\\n new_point = [] # pending pixels to be added\\r\\n ###############################\\r\\n \\r\\n if fitted == 0:\\r\\n \\r\\n if r == r0:\\r\\n \\r\\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\\r\\n \\r\\n # Check if it is within the circle radius = 2\\r\\n if int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\\r\\n \\r\\n i,j =[int(i), int(j)]\\r\\n if self.raw_image_data[j,i] == self.raw_image_data[j,i] *self.masked[j,i]: # Append the ppoint if not masked (masked = 1)\\r\\n\\r\\n if self.raw_image_data[j,i] <= cut_off:\\r\\n no_cut += 1\\r\\n\\r\\n if self.raw_image_data[j,i] > cut_off:\\r\\n point.append(self.raw_image_data[j, i])\\r\\n circle_number += 1\\r\\n\\r\\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\\r\\n bg_local += self.raw_image_data[j,i]\\r\\n no_bg += 1\\r\\n \\r\\n if no_cut >= len(point)/2 or 2*circle_number < np.pi * r0**2:\\r\\n fitted = 1\\r\\n else:\\r\\n pass\\r\\n \\r\\n#######################################################################################################\\r\\n if r > r0:\\r\\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): \\r\\n \\r\\n # Check if data are in between the previous and the new circle\\r\\n if (r - dr)**2 < int((i - xpos) ** 2 + (j - ypos) ** 2) <= r ** 2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1:\\r\\n i,j =[int(i), int(j)] # just incase \\r\\n \\r\\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]:\\r\\n\\r\\n if self.raw_image_data[j,i] <= cut_off:\\r\\n no_cut += 1\\r\\n if self.raw_image_data[j,i] > cut_off:\\r\\n new_point.append(self.raw_image_data[j, i]) # points are pending to be added in\\r\\n circle_number += 1\\r\\n\\r\\n if abs(self.raw_image_data[j,i] - bg_global) <= sigma:\\r\\n bg_local += self.raw_image_data[j,i]\\r\\n no_bg += 1\\r\\n \\r\\n # Check if half of the new data points are inside cut off region\\r\\n if no_cut <= int(len(new_point)/2) or circle_number*2 < np.pi * r**2:\\r\\n for rannk in range(len(new_point)):\\r\\n point.append(new_point[rannk])\\r\\n\\r\\n else:\\r\\n fitted = 1\",\n \"def find_indexName(chosenTile, pointSHP, maskCLD, maskWTR):\\n meanindexName = chosenTile[:-4]+'_MEAN.tif'\\n if glob.glob(meanindexName) == []: # -- not created yet \\n #cloud mask\\n command1 = 'gdal_calc.py -A' + chosenTile + ' -B ' + maskCLD + ' --outfile=out1.tif --calc=\\\"A*(B == 0)+99*(B > 0)\\\"'\\n os.system(command1) \\n #water mask\\n command2 = 'gdal_calc.py -A out1.tif -B ' + maskWTR + ' --outfile=out2.tif --calc=\\\"A*(B == 99)+99*(B < 1)\\\"' \\n os.system(command2)\\n #no data\\n command3 = 'gdal_translate -a_nodata 99 out2.tif ' + meanindexName\\n os.system(command3)\\n #remove files\\n os.remove('out1.tif')\\n os.remove('out2.tif')\\n stats = zonal_stats(pointSHP, meanindexName)\\n indexName_value = stats[0]['mean']\\n print '********* VALEUR',indexName_value\\n return indexName_value\",\n \"def check_location_confidence(self):\\n\\t\\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\\n\\t\\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\\n\\t\\tepsilon_meters = .08\\n\\t\\tpixel_distances = []\\n\\t\\tactual_distances = []\\n\\t\\tnum_observed = 0\\n\\t\\tfor ti in self.targs:\\n\\t\\t\\tif ti.props_are_set:\\n\\t\\t\\t\\tfor tj in self.targs:\\n\\t\\t\\t\\t\\tif tj.props_are_set: \\n\\t\\t\\t\\t\\t\\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\\n\\t\\t\\t\\t\\t\\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\\n\\t\\t\\t\\t\\t\\tif pixel_dist == 0:\\n\\t\\t\\t\\t\\t\\t\\tpixel_dist = 10000 #ignore two of the same points\\n\\t\\t\\t\\t\\t\\t\\tactual_dist = 10000\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(pixel_dist)\\t\\n\\t\\t\\t\\t\\t\\tactual_distances.append(actual_dist)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor _ in self.targs:\\n\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\tmin_ind_pixel = np.argmin(pixel_distances)\\n\\t\\tmin_ind_actual = np.argmin(actual_distances)\\n\\t\\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\\n\\t\\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\\n\\t\\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\\n\\t\\t\\t#measurements are not trustworthy, return nothing\\n\\t\\t\\treturn None\\n\\n\\t\\treturn best_guys\",\n \"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).transpose()\\n bottem_right_x, bottem_right_y = apply_homography(np.array([[w, h]]), homography).transpose()\\n\\n min_x = min([top_left_x, top_right_x, bottem_left_x, bottem_right_x])[0]\\n max_x = max([top_left_x, top_right_x, bottem_left_x, bottem_right_x])[0]\\n min_y = min([top_left_y, top_right_y, bottem_left_y, bottem_right_y])[0]\\n max_y = max([top_left_y, top_right_y, bottem_left_y, bottem_right_y])[0]\\n return np.array([[min_x, min_y], [max_x, max_y]]).astype(int)\",\n \"def get_bounding_box(self):\\n lon, lat = self.coordinates\\n\\n ll = (np.min(lon),np.min(lat))\\n ul = (np.min(lon),np.max(lat))\\n ur = (np.max(lon),np.max(lat))\\n lr = (np.max(lon),np.min(lat))\\n\\n return (ll, ul, ur, lr)\",\n \"def challenge2(self):\\n # Let's try an octree-type approach\\n # For each grid cube we should be able to find whether a nanobot:\\n # 1) is not in range (is outside grid cube and not in range of nearest face)\\n # 2) is in range of whole cube (all 8 corners are in range)\\n # 3) is in range of part of the cube (i.e. not 1 or 2)\\n # Root node: figure out extent of whole space\\n mins = []\\n maxs = []\\n for axis in range(3):\\n mins.append(min(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n maxs.append(max(self.nanobots, key=lambda n: n.coord[axis]).coord[axis])\\n\\n for count in range(len(self.nanobots), 0, -1):\\n results = self.search_coord_with_max_nanobots(mins, maxs, [], self.nanobots, count)\\n if results and results[0].count >= count:\\n break\\n\\n print(f\\\"Found {len(results)} octree search results with {results[0].count} nanobots in range.\\\")\\n\\n # Find result coord closest to origin\\n closest_dist = np.iinfo(np.int32).max\\n best_coord = None\\n for result in results:\\n for corner in itertools.product(*zip(result.mins, result.maxs)):\\n d = manhattan_dist(corner, (0, 0, 0))\\n if d < closest_dist:\\n closest_dist = d\\n best_coord = corner\\n\\n print(f\\\"Best coord: {best_coord} (dist={manhattan_dist(best_coord, (0, 0, 0))})\\\")\",\n \"def get_bounds(self):\\n log.debug(str(inspect.stack()[1][3]) + \\\"--> OC.get_bounds()\\\")\\n\\n # TODO: Move the operation out of here.\\n\\n xmin = Inf\\n ymin = Inf\\n xmax = -Inf\\n ymax = -Inf\\n\\n # for obj in self.object_list:\\n for obj in self.get_list():\\n try:\\n gxmin, gymin, gxmax, gymax = obj.bounds()\\n xmin = min([xmin, gxmin])\\n ymin = min([ymin, gymin])\\n xmax = max([xmax, gxmax])\\n ymax = max([ymax, gymax])\\n except Exception as e:\\n log.warning(\\\"DEV WARNING: Tried to get bounds of empty geometry. %s\\\" % str(e))\\n\\n return [xmin, ymin, xmax, ymax]\",\n \"def average_normal_projections(fr,mvec,pivot,maxflux,do_inflate=False):\\n\\tglobal surf,surfs,mesh\\n\\t#---! getting: calcs/codes/mesh.py:24: RuntimeWarning: invalid value encountered in divide ... in vecnorm\\n\\t#---inflate the instantaneous surface\\n\\tthis_surf_inflated = surfs[fr]#inflate_lateral(surfs[fr],inflate_factor)\\n\\t#---find the points on the instantaneous surface which are nearest the points on the regular grid on the average\\n\\t#---convert instantaneous points to XYZ with the reference box vectors mvec\\n\\tinstant_all = boxstuff(height_recenter(literalize(this_surf_inflated,mvec),pivot=pivot,maxflux=maxflux),mvec)\\n\\t#---after literalizing the inflated points, we take only the points which are relevant to the base structure\\n\\t#---! is the order correct?\\n\\tif do_inflate:\\n\\t\\tsource = surf_average_base\\n\\t\\tinds = np.concatenate(np.transpose(np.meshgrid(*[np.arange(-inflate_factor,i+inflate_factor+1) \\n\\t\\t\\tfor i in source.shape])))\\n\\t\\tbase = np.where(np.all((np.all(inds>0,axis=1),np.all(np.array(source.shape)>=inds,axis=1)),axis=0))[0]\\n\\t\\tinstant = instant_all[base]\\n\\telse: instant = instant_all\\n\\t#---note that we make a tree from the instantaneous points then probe over the average surface\\n\\t#---! more efficient to do this in reverse, however it might not cover all of the average/reference points?\\n\\t#---prepare a KDTree. we use a fudge factor of 1000 epsilon to avoid angry errors about being outside the box\\n\\ttree = scipy.spatial.ckdtree.cKDTree(instant,boxsize=np.concatenate((mvec,mvec))+1000.*eps)\\n\\t#---find the nearest reference points for each instantaneous point\\n\\tclose,nns = tree.query(surf,k=1)\\n\\t#---given a mapping between instantaneous point and target position (on XY), project the instantaneous point\\n\\t#---...onto the tangent plane given by the reference point. note that this is obviously a minor approximation in \\n\\t#---...which we assume that the point is hovering \\\"above\\\" the reference point close enough that the projection onto\\n\\t#---...that tangent plane is correct. a more literal form of this might actually try to find the exact distance to \\n\\t#---...the triangle adjacent to the nearest reference vertex, but this would require adding extra neighbor\\n\\t#---...information and I think it takes the surface a bit too literally.\\n\\t#---! note that we could use the real points instead of regular grid points for the instantaneous point?\\n\\tdeviations = np.array([\\n\\t\\tget_normal_fluctuation(\\n\\t\\t\\tnormal=mesh['vertnorms'][index],\\n\\t\\t\\ttarget=surf[index],\\n\\t\\t\\thover=instant[nns][index],\\n\\t\\t\\tvec=mvec) \\n\\t\\tfor ii,index in enumerate(nns)])\\n\\t#---corners fail for whatever reason. could not get the do_inflate method working\\n\\tdeviations[np.isnan(deviations)] = 0.0\\n\\treturn deviations\",\n \"def empirical_cor(l):\\n\\n global fig_dphi\\n\\n # first clean los\\n maps_temp = np.matrix.copy(maps[:,:,l]) - np.matrix.copy(models[:,:,l])\\n\\n # no estimation on the ref image set to zero \\n if np.nansum(maps[:,:,l]) != 0:\\n\\n maxlos,minlos=np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],float(arguments[\\\"--perc_los\\\"])),np.nanpercentile(maps_temp[ibeg_emp:iend_emp,jbeg_emp:jend_emp],100-float(arguments[\\\"--perc_los\\\"]))\\n logger.debug('Set Max-Min LOS for empirical estimation: {0}-{1}'.format(maxlos,minlos))\\n kk = np.nonzero(np.logical_or(maps_temp==0.,np.logical_or((maps_temp>maxlos),(maps_temp<minlos))))\\n maps_temp[kk] = float('NaN')\\n\\n itemp = ibeg_emp\\n for lign in range(ibeg_emp,iend_emp,10):\\n if np.isnan(np.nanmean(maps[lign:lign+10,:,l])):\\n itemp = lign\\n else:\\n break\\n logger.debug('Begining of the image: {}'.format(itemp))\\n\\n if arguments[\\\"--topofile\\\"] is not None:\\n ax_dphi = fig_dphi.add_subplot(4,int(N/4)+1,l+1)\\n else:\\n ax_dphi = None\\n\\n logger.debug('Threshold RMS: {}'.format(float(arguments[\\\"--threshold_rms\\\"])))\\n\\n # selection pixels\\n index = np.nonzero(np.logical_and(elev<maxtopo,\\n np.logical_and(elev>mintopo,\\n np.logical_and(mask_flat>float(arguments[\\\"--threshold_mask\\\"]),\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(~np.isnan(rmsmap),\\n np.logical_and(~np.isnan(elev),\\n np.logical_and(rmsmap<float(arguments[\\\"--threshold_rms\\\"]),\\n np.logical_and(rmsmap>1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>ibeg_emp,\\n np.logical_and(pix_az<iend_emp,\\n np.logical_and(pix_rg>jbeg_emp,\\n np.logical_and(pix_rg<jend_emp, \\n slope>0.,\\n ))))))))\\n ))))))\\n\\n # extract coordinates for estimation\\n temp = np.array(index).T\\n x = temp[:,0]; y = temp[:,1]\\n # clean maps\\n los_clean = maps_temp[index].flatten()\\n topo_clean = elev[index].flatten()\\n rms_clean = rmsmap[index].flatten()\\n \\n logger.debug('Number of points for empirical estimation: {}'.format(len(los_clean)))\\n if len(los_clean) < 1:\\n logger.critical('No points left for empirical estimation. Exit!')\\n logger.critical('threshold RMS: {0}, threshold Mask: {1}, Min-Max LOS: {2}-{3}, Min-Max topo: {4}-{5}, lines: {6}-{7}, \\\\\\n cols: {8}- {9}'.format(float(arguments[\\\"--threshold_rms\\\"]),float(arguments[\\\"--threshold_mask\\\"]),minlos,maxlos,mintopo,maxtopo,ibeg_emp,iend_emp,jbeg_emp,jend_emp))\\n sys.exit()\\n\\n # print itemp, iend_emp\\n if flat>5 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\\n logger.warning('Image too short in comparison to master, set flat to 5')\\n temp_flat=5\\n else:\\n temp_flat=flat\\n\\n if ivar>0 and iend_emp-itemp < .6*(iend_emp-ibeg_emp):\\n logger.warning('Image too short in comparison to master, set ivar to 0')\\n ivar_temp=0\\n nfit_temp=0\\n else:\\n ivar_temp=ivar\\n nfit_temp=nfit\\n\\n # call ramp estim\\n los = as_strided(maps[:,:,l]).flatten()\\n samp = int(arguments[\\\"--emp_sampling\\\"])\\n\\n map_ramp, map_flata, map_topo, rmsi = estim_ramp(los,los_clean[::samp],topo_clean[::samp],x[::samp],\\\\\\n y[::samp],temp_flat,rms_clean[::samp],nfit_temp, ivar_temp, l, ax_dphi)\\n\\n if (lin_start is not None) and (lin_end is not None):\\n # try:\\n indexref = np.nonzero(np.logical_and(elev<maxtopo,\\n np.logical_and(elev>mintopo,\\n np.logical_and(mask_flat>float(arguments[\\\"--threshold_mask\\\"]),\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(~np.isnan(rmsmap),\\n np.logical_and(~np.isnan(elev),\\n np.logical_and(rmsmap<float(arguments[\\\"--threshold_rms\\\"]),\\n np.logical_and(rmsmap>1.e-6,\\n np.logical_and(~np.isnan(maps_temp),\\n np.logical_and(pix_az>lin_start,\\n np.logical_and(pix_az<lin_end,\\n np.logical_and(pix_rg>col_start,\\n np.logical_and(pix_rg<col_end, \\n slope>0.,\\n ))))))))))))\\n ))\\n \\n if len(indexref[0]) == 0:\\n logger.warning('Ref zone is empty! Re-define --ref_zone argument. Exit!')\\n sys.exit()\\n\\n ## Set data minus temporal model to zero in the ref area\\n zone = as_strided(map_flata[:,:] - models[:,:,l])\\n los_ref2 = zone[indexref].flatten()\\n rms_ref = rmsmap[indexref].flatten()\\n amp_ref = 1./rms_ref\\n amp_ref = amp_ref/np.nanmax(amp_ref)\\n # weigth avera of the phase\\n cst = np.nansum(los_ref2*amp_ref) / np.nansum(amp_ref)\\n logger.info('Re-estimation of a constant within lines {0}-{1} and cols {2}-{3}'.format(lin_start,lin_end,col_start,col_end))\\n logger.info('Average phase within ref area: {0}:'.format(cst))\\n if np.isnan(cst):\\n cst = 0.\\n map_ramp, map_flata = map_ramp + cst, map_flata - cst\\n del zone\\n \\n else:\\n map_flata = np.copy(maps[:,:,l])\\n map_ramp, map_topo = np.zeros(np.shape(map_flata)), np.zeros(np.shape(map_flata))\\n rmsi = 1\\n\\n # set ramp to NaN to have ramp of the size of the images\\n kk = np.nonzero(np.isnan(map_flata))\\n ramp = as_strided(map_ramp)\\n ramp[kk] = float('NaN')\\n topo = as_strided(map_topo)\\n topo[kk] = float('NaN')\\n del ramp, topo\\n \\n return map_ramp, map_flata, map_topo, rmsi\",\n \"def bounds(self):\\n return self._bboxes[0][0] #TODO: merge all coverages\",\n \"def search_coord_with_max_nanobots(self, mins, maxs, fully_in_range, maybe_partially_in_range, best_count=0):\\n # Figure out how many of maybe_partially_in_range are actually in range of this whole cube\\n # or if they're completely out of range\\n cube = OctreeNode(mins, maxs)\\n new_fully_in_range = fully_in_range.copy()\\n new_partially_in_range = []\\n for nanobot in maybe_partially_in_range:\\n if cube.nanobot_in_range_of_whole_node(nanobot):\\n new_fully_in_range.append(nanobot)\\n elif cube.in_node(nanobot.coord) or cube.in_range_if_outside(nanobot):\\n new_partially_in_range.append(nanobot)\\n\\n # If we're not potentially at least as good as best_count, no results worth returning\\n if len(new_fully_in_range) + len(new_partially_in_range) < best_count:\\n return []\\n\\n # If none are partially in range, we know the answer for this node!\\n if not new_partially_in_range:\\n return [SearchResult(mins, maxs, len(new_fully_in_range))]\\n\\n # If this node is only 0 or 1 units long in each direction, we can't subdivide\\n big_enough = False\\n for axis in range(3):\\n if maxs[axis] - mins[axis] > 1:\\n big_enough = True\\n\\n all_results = []\\n if not big_enough:\\n # Manually test all 8 corners (ignoring duplicate corners, if any)\\n points_tested = set()\\n for corner in itertools.product(*zip(mins, maxs)):\\n if corner not in points_tested:\\n points_tested.add(corner)\\n new_best_count = len(new_fully_in_range) + len([nanobot for nanobot in new_partially_in_range\\n if manhattan_dist(nanobot.coord, corner) <= nanobot.r])\\n if new_best_count >= best_count:\\n best_count = new_best_count\\n all_results += [SearchResult(corner, corner, new_best_count)]\\n \\n else:\\n # Otherwise, divide into 8 subcubes and recursively search\\n midpoint = []\\n for axis in range(3):\\n midpoint.append((mins[axis] + maxs[axis]) // 2)\\n\\n axis_coords = list(zip(mins, midpoint, maxs))\\n for corner_index in itertools.product(*zip([0, 0, 0], [1, 1, 1])):\\n subcube_mins = []\\n subcube_maxs = []\\n for axis in range(3):\\n subcube_mins.append(axis_coords[axis][corner_index[axis]])\\n subcube_maxs.append(axis_coords[axis][corner_index[axis] + 1])\\n\\n results = self.search_coord_with_max_nanobots(subcube_mins,\\n subcube_maxs,\\n new_fully_in_range,\\n new_partially_in_range,\\n best_count)\\n \\n # Result counts should all be the same\\n if results and results[0].count >= best_count:\\n all_results += results\\n\\n # Keep the result(s) with the highest count\\n return [result for result in all_results if result.count == best_count]\",\n \"def do_intensity_projection(points, proj_W , proj_H, proj_fov_up, proj_fov_down, fn, idx):\\n\\n # print(points.shape)\\n\\n points = points[points.any(axis=1)]\\n\\n proj_range = np.zeros((proj_H, proj_W),\\n dtype=np.float64)\\n\\n # unprojected range (list of depths for each point)\\n unproj_range = np.zeros((0, 1), dtype=np.float32)\\n\\n # projected point cloud xyz - [H,W,3] xyz coord (-1 is no data)\\n proj_xyz = np.full((proj_H, proj_W, 4), -1,\\n dtype=np.float32)\\n\\n # projected remission - [H,W] intensity (-1 is no data)\\n proj_remission = np.full((proj_H, proj_W), -1,\\n dtype=np.float32)\\n\\n # projected index (for each pixel, what I am in the pointcloud)\\n # [H,W] index (-1 is no data)\\n proj_idx = np.full((proj_H, proj_W), -1,\\n dtype=np.int32)\\n\\n # for each point, where it is in the range image\\n proj_x = np.zeros((0, 1), dtype=np.int32) # [m, 1]: x\\n proj_y = np.zeros((0, 1), dtype=np.int32) # [m, 1]: y\\n\\n # mask containing for each pixel, if it contains a point or not\\n proj_mask = np.zeros((proj_H, proj_W),\\n dtype=np.int32) # [H,W] mask\\n\\n\\n\\n\\n # laser parameters\\n fov_up = proj_fov_up / 180.0 * np.pi # field of view up in rad\\n fov_down = proj_fov_down / 180.0 * np.pi # field of view down in rad\\n fov = abs(fov_down) + abs(fov_up) # get field of view total in rad\\n\\n\\n \\n depth = np.linalg.norm(points[:,:3], 2, axis=1)\\n\\n # print(points[:10,:])\\n \\n\\n # get scan components\\n scan_x = points[:, 0]\\n scan_y = points[:, 1]\\n scan_z = points[:, 2]\\n\\n # get angles of all points\\n yaw = -np.arctan2(scan_y, scan_x) \\n pitch = np.arcsin(scan_z / depth)\\n\\n # get projections in image coords\\n proj_x = 0.5 * (yaw / np.pi + 1.0) # in [0.0, 1.0]\\n proj_y = 1.0 - (pitch + abs(fov_down)) / fov # in [0.0, 1.0]\\n\\n proj_x = np.nan_to_num(proj_x)\\n\\n proj_y = np.nan_to_num(proj_y)\\n # scale to image size using angular resolution\\n proj_x *= proj_W # in [0.0, W]\\n proj_y *= proj_H # in [0.0, H]\\n\\n \\n \\n\\n # round and clamp for use as index\\n proj_x = np.floor(proj_x)\\n proj_x = np.minimum(proj_W - 1, proj_x)\\n proj_x = np.maximum(0, proj_x).astype(np.int32) # in [0,W-1]\\n proj_x = np.copy(proj_x) # store a copy in orig order\\n\\n proj_y = np.floor(proj_y)\\n proj_y = np.minimum(proj_H - 1, proj_y)\\n proj_y = np.maximum(0, proj_y).astype(np.int32) # in [0,H-1]\\n\\n proj_y = np.copy(proj_y) # stope a copy in original order\\n\\n\\n # # copy of depth in original order\\n # unproj_range = np.copy(depth)\\n\\n # indices = np.arange(depth.shape[0])\\n # order = np.argsort(depth)[::-1]\\n # depth = depth[order]\\n # indices = indices[order]\\n # points = points[order]\\n\\n # proj_y = proj_y[order]\\n # proj_x = proj_x[order]\\n \\n\\n if DATASET_TYPE == \\\"kitti\\\":\\n intensities = points[:,3]\\n print(\\\"kitti\\\")\\n # intensities = np.minimum(intensities, 1000)\\n # i_min = intensities.min()\\n # i_max = intensities.max()\\n # intensities = (intensities - i_min)/(i_max - i_min)\\n\\n\\n\\n if DATASET_TYPE == \\\"mulran\\\" or DATASET_TYPE == \\\"mulran2\\\":\\n intensities = points[:,3]\\n intensities = np.minimum(intensities, 1000)\\n i_min = intensities.min()\\n i_max = intensities.max()\\n \\n intensities = (intensities - i_min)/(i_max - i_min)\\n\\n if DATASET_TYPE == \\\"dso\\\":\\n \\n \\n \\n intensities = points[:,4]\\n \\n\\n minval = np.percentile(intensities, 2)\\n maxval = np.percentile(intensities, 98)\\n intensities = np.clip(intensities, minval, maxval)\\n # intensities = np.maximum(intensities, 5000)\\n # intensities = np.sqrt(intensities)\\n\\n \\n\\n\\n \\n i_min = intensities.min()\\n i_max = intensities.max()\\n\\n intensities = (intensities - i_min)/(i_max - i_min)\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n \\n \\n \\n \\n pixel_tracker = {}\\n pc_tracker = {}\\n # print(proj_x.shape)\\n # print(scan_x.shape)\\n\\n \\n proj_3d_corres = np.zeros((proj_H, proj_W, 3),\\n dtype=np.float64)\\n\\n # print(proj_x[:20])\\n # print(proj_y[:70])\\n \\n \\n for i in range(proj_x.shape[0]):\\n x_val = proj_x[i]\\n y_val = proj_y[i]\\n\\n \\n\\n if proj_range[y_val, x_val] != 0:\\n continue\\n\\n \\n \\n intensity = intensities[i]\\n \\n \\n \\n \\n proj_range[y_val, x_val] = intensity\\n \\n proj_3d_corres[y_val,x_val, :] = np.array([scan_x[i], scan_y[i], scan_z[i]])\\n \\n\\n\\n \\n proj_range *= 255\\n\\n\\n \\n \\n \\n \\n proj_range = np.array(proj_range, dtype=np.uint8)\\n\\n \\n newPicPath = None\\n\\n\\n \\n\\n\\n img = Image.fromarray(proj_range, 'L')\\n pc_name = fn.split('.')[0]\\n newPicPath = os.path.join(CURRENT_DIR, \\\"intensity_images\\\", \\\"mulran_\\\" + (str(idx)) + \\\".png\\\")\\n img.save(newPicPath)\\n\\n\\n return newPicPath, proj_3d_corres, proj_range\",\n \"def detect(self, score_map, geo_map, score_map_thresh=common.SCORE_MAP_THRESH,\\n box_thresh=common.BOX_THRESH, nms_thres=common.NMS_TRESH):\\n if len(score_map.shape) == 4:\\n score_map = score_map[0, :, :, 0]\\n geo_map = geo_map[0, :, :, ]\\n # filter the score map\\n xy_text = np.argwhere(score_map > score_map_thresh)\\n # sort the text boxes via the y axis\\n xy_text = xy_text[np.argsort(xy_text[:, 0])]\\n # restore\\n text_box_restored = restore_rectangle(xy_text[:, ::-1] * 4, geo_map[xy_text[:, 0], xy_text[:, 1], :]) # N*4*2\\n boxes = np.zeros((text_box_restored.shape[0], 9), dtype=np.float32)\\n boxes[:, :8] = text_box_restored.reshape((-1, 8))\\n boxes[:, 8] = score_map[xy_text[:, 0], xy_text[:, 1]]\\n # nms part\\n boxes = lanms.merge_quadrangle_n9(boxes.astype('float32'), nms_thres)\\n\\n if boxes.shape[0] == 0:\\n return boxes\\n\\n # here we filter some low score boxes by the average score map, this is different from the orginal paper\\n for i, box in enumerate(boxes):\\n mask = np.zeros_like(score_map, dtype=np.uint8)\\n cv2.fillPoly(mask, box[:8].reshape((-1, 4, 2)).astype(np.int32) // 4, 1)\\n boxes[i, 8] = cv2.mean(score_map, mask)[0]\\n boxes = boxes[boxes[:, 8] > box_thresh]\\n\\n return boxes\",\n \"def get_grid_mappings(weighed_sum,\\n use_defaults=True,min_index_row_peaks =40):\\n # Detect peaks\\n col_peaks = indices_highest_peaks(weighed_sum, 0)\\n row_peaks = indices_highest_peaks(weighed_sum, 1)\\n \\n # Map col_peaks to Hz values\\n if len(col_peaks) == len(HZ):\\n mapping_Hz = dict(zip(HZ,col_peaks)) \\n \\n # Map adjusted col_peaks to Hz values\\n else:\\n try: \\n col_peaks =adjust_arr_peaks(weighed_sum,col_peaks,len(HZ),0)\\n mapping_Hz = dict(zip(HZ,col_peaks)) \\n \\n # Map adjusted HZ values to default coordinates if need be\\n if use_defaults:\\n for i,key in enumerate(HZ):\\n if mapping_Hz[key] > UPPER_LIMIT_HZ_COORD[i] or mapping_Hz[key] < LOWER_LIMIT_HZ_COORD[i]:\\n mapping_Hz[key] = DEFAULT_HZ_COORD[i]\\n except:\\n if use_defaults:\\n mapping_Hz = dict(zip(HZ,DEFAULT_HZ_COORD )) \\n else: \\n return np.nan,np.nan,np.nan,np.nan\\n \\n \\n row_peaks = row_peaks[row_peaks > min_index_row_peaks]\\n \\n try:\\n row_100 = row_peaks[0] #Should be around 30 for 100 km\\n row_200 = row_peaks[1] #Should be around 30 for 100 km\\n except:\\n if use_defaults:\\n row_100 = KM_DEFAULT_100\\n row_200 = KM_DEFAULT_200 \\n else: \\n return np.nan,np.nan,np.nan,np.nan\\n \\n if use_defaults:\\n if abs(row_100 - KM_DEFAULT_100) > abs(KM_DEFAULT_200 - KM_DEFAULT_100):\\n row_100 = KM_DEFAULT_100\\n if abs(row_200 - KM_DEFAULT_200) > abs(KM_DEFAULT_200 - KM_DEFAULT_100):\\n row_200 = KM_DEFAULT_200 \\n \\n mapping_km = {100:row_100,200:row_200}\\n\\n return col_peaks,row_peaks,mapping_Hz, mapping_km\",\n \"def bounds(self, pos):\",\n \"def _area(bounds):\\n return (bounds[0, 1] - bounds[0, 0]) * (bounds[1, 1] - bounds[1, 0])\",\n \"def get_geo_extents(nc, possible_units, std_name, axis_name, short_name):\\n\\n geo_extent_vars = {}\\n geo_extent_units = []\\n\\n # variables must have units\\n for var in nc.get_variables_by_attributes(units=lambda x: x is not None):\\n \\n geo_extent_vars[var.name] = 0\\n # units in this set\\n if var.units in possible_units:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n\\n # standard name\\n if hasattr(var, 'standard_name') and var.standard_name == std_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n # axis of \\\"X\\\"\\n if hasattr(var, 'axis') and var.axis == axis_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n \\n\\n if var.name == std_name or var.name == short_name:\\n geo_extent_vars[var.name] += 1\\n geo_extent_units.append(var.units)\\n\\n if len(geo_extent_vars) == 0:\\n return\\n\\n # filter out any zero scores\\n geo_extent_vars = dict(filter(lambda x: x[1]>0, geo_extent_vars.items()))\\n\\n # sort by criteria passed\\n final_geo_vars = sorted(geo_extent_vars, key=lambda x: geo_extent_vars[x], reverse=True)\\n\\n obs_mins = [np.nanmin(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n obs_maxs = [np.nanmax(nc.variables[var]) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n\\n # Let's just pick one\\n geo_vals = nc.variables[final_geo_vars[0][:]]\\n if geo_vals.size == 1:\\n obs_res = [0.0]\\n else:\\n obs_res = [np.nanmean(np.diff(nc.variables[var])) for var in final_geo_vars if not np.isnan(nc.variables[var]).all()]\\n\\n geo_min = round(float(min(obs_mins)), 5)\\n geo_max = round(float(max(obs_maxs)), 5)\\n geo_extent_units = [nc.variables[k].units for k, v in geo_extent_vars.items()][0]\\n geo_res = \\\"{} {}\\\".format(round(float(abs(np.mean(obs_res))), 5), geo_extent_units)\\n\\n print('<attribute name=\\\"geospatial_{}_min\\\" value=\\\"{}\\\" />'.format(short_name, geo_min))\\n print('<attribute name=\\\"geospatial_{}_max\\\" value=\\\"{}\\\" />'.format(short_name, geo_max))\\n print('<attribute name=\\\"geospatial_{}_resolution\\\" value=\\\"{}\\\" />'.format(short_name, geo_res))\\n print('<attribute name=\\\"geospatial_{}_units\\\" value=\\\"{}\\\" />'.format(short_name, geo_extent_units))\",\n \"def background_detection(dataset, radius, normal_threshold):\\n length = len(dataset)\\n normal_list = []\\n tree = scipy.spatial.cKDTree(dataset)\\n for x, y, z in zip(original_x_int_array, original_y_int_array, original_z_int_array):\\n indices = tree.query_ball_point([x, y, z], radius)\\n if len(indices) <= 3:\\n normal_list.append(0)\\n continue\\n idx = tuple(indices)\\n data = np.vstack([dataset[idx, 0], dataset[idx, 1], dataset[idx, 2]])\\n cov = np.cov(data)\\n evals, evects = la.eigh(cov)\\n evals = np.abs(evals)\\n index = evals.argsort()[::-1]\\n evects = evects[:, index]\\n normal = evects[2][2]\\n normal_list.append(normal)\\n\\n # codes below were region growing algorithm implemented based pseudocode in\\n # http://pointclouds.org/documentation/tutorials/region_growing_segmentation.php#region-growing-segmentation\\n # awailable voxel list index\\n seeds = np.logical_or(np.array(normal_list) > normal_threshold, np.array(normal_list) < -normal_threshold)\\n\\n seeds = list(np.where(seeds)[0])\\n\\n voxel_set = np.vstack([original_x_int_array[seeds], original_y_int_array[seeds],\\n original_z_int_array[seeds]]).transpose()\\n regions = region_growing(voxel_set, GROUND_NEIGHBOR / VOXEL_SIZE)\\n\\n seeds = np.array(seeds)\\n ground = []\\n max_len = 0\\n if len(regions) == 1:\\n ground += seeds[regions[0]]\\n else:\\n for region in regions:\\n if len(region) > max_len:\\n max_len = len(region)\\n ground = []\\n ground = seeds[region]\\n # if float(len(region)) / length < 0.2:\\n # continue\\n # else:\\n # ground += list(seeds[region])\\n # if len(ground) == 0:\\n # ground.append(temp_ground)\\n return normal_list, ground\",\n \"def get_object_centers(data, north_offset, east_offset, drone_altitude, safety_distance):\\n points = []\\n for i in range(data.shape[0]):\\n north, east, alt, d_north, d_east, d_alt = data[i, :]\\n if alt + d_alt + safety_distance > drone_altitude:\\n points.append([north - north_offset, east - east_offset])\\n return points;\",\n \"def fit_galaxy(self, ypos, xpos, r_in, r_out = 0):\\r\\n count_out = []\\r\\n count_in = []\\r\\n for j, i in product(np.arange(ypos - (r_out + r_in), ypos + r_out + r_in + 1),np.arange(xpos - (r_out + r_in), xpos + 1 + r_out + r_in)): # Create square\\r\\n if (j - ypos) ** 2 + (i - xpos) ** 2 <= r_in ** 2 and 0<= j <= self.shapes[0] - 1 and 0<= i <= self.shapes[1] - 1: # make sure points are in a circle\\r\\n j = int(j)\\r\\n i = int(i)\\r\\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]:\\r\\n count_in.append(self.raw_image_data[j,i])\\r\\n self.masked[j,i] = 0 # self.mask_region runs the for loop again\\r\\n if r_in ** 2 < (j - ypos) ** 2 + (i - xpos) ** 2 <= (r_in + r_out)**2 and 0<= j <= (self.shapes[0] - 1) and 0<= i <= self.shapes[1] - 1: # in the outer ring\\r\\n j = int(j)\\r\\n i = int(i)\\r\\n if self.raw_image_data[j,i] * self.masked[j,i] == self.raw_image_data[j,i]: \\r\\n count_out.append(self.raw_image_data[j][i]) \\r\\n self.masked[j,i]\\r\\n return count_in, count_out\",\n \"def getVisualFieldOrigin(self):\\r\\n\\r\\n if not hasattr(self, 'finalPatchesMarked'):\\r\\n raise LookupError('Please mark the final patches first!!')\\r\\n\\r\\n if not hasattr(self, 'altPosMapf'):\\r\\n _ = self._getSignMap()\\r\\n\\r\\n try:\\r\\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\\r\\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\\r\\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\\r\\n\\r\\n overlap = 0 # number of overlaping pixels\\r\\n iterNum = 1 # number of iteration\\r\\n while overlap < 1:\\r\\n # print 'Iteration number for finding overlapping pixel:', iterNum\\r\\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\\r\\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\\r\\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\\r\\n totalField = V1 + LM + RL\\r\\n # plt.imshow(totalField)\\r\\n overlap = len(np.argwhere(totalField == 3))\\r\\n iterNum += 1\\r\\n # print 'Number of overlapping pixels:', overlap\\r\\n # plt.show()\\r\\n\\r\\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\\r\\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\\r\\n\\r\\n except KeyError:\\r\\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\\\nSetting origins to 0 ...')\\r\\n altPosOrigin = 0.\\r\\n aziPosOrigin = 0.\\r\\n\\r\\n return altPosOrigin, aziPosOrigin\",\n \"def box_results_for_corloc(scores, boxes): # NOTE: support single-batch\\n num_classes = cfg.MODEL.NUM_CLASSES + 1\\n cls_boxes = [[] for _ in range(num_classes)]\\n # Apply threshold on detection probabilities and apply NMS\\n # Skip j = 0, because it's the background class\\n for j in range(1, num_classes):\\n max_ind = np.argmax(scores[:, j])\\n cls_boxes[j] = np.hstack((boxes[max_ind, :].reshape(1, -1),\\n np.array([[scores[max_ind, j]]])))\\n\\n im_results = np.vstack([cls_boxes[j] for j in range(1, num_classes)])\\n boxes = im_results[:, :-1]\\n scores = im_results[:, -1]\\n return scores, boxes, cls_boxes\",\n \"def get_bounding_box(self, maxdist):\\n lon = self.location.longitude\\n lat = self.location.latitude\\n maxradius = self._get_max_rupture_projection_radius()\\n a1 = (maxdist + maxradius) * KM_TO_DEGREES\\n a2 = angular_distance(maxdist + maxradius, lat)\\n return lon - a2, lat - a1, lon + a2, lat + a1\",\n \"def get_score(location, grid, shape):\",\n \"def extract_k_space_center(samples, samples_locations,\\n thr=None, img_shape=None):\\n if thr is None:\\n if img_shape is None:\\n raise ValueError('target image cartesian image shape must be fill')\\n raise NotImplementedError\\n else:\\n samples_thresholded = np.copy(samples)\\n samples_thresholded *= (samples_locations[:, 0] <= thr)\\n samples_thresholded *= (samples_locations[:, 1] <= thr)\\n return samples_thresholded\",\n \"def get_bounds(self):\\n x_max = self.data['x'].max()\\n y_max = self.data['y'].max()\\n z_max = self.data['z'].max()\\n print(\\\"x={}; y={}; z={}\\\".format(x_max, y_max, z_max))\\n return (x_max, y_max, z_max)\",\n \"def getSearchSpaceCoords(self):\",\n \"def nms_all_class(bound_corr_objs, nms_thresh):\\n bboxs, scores, masks, labels = [], [], [], []\\n for obj in bound_corr_objs:\\n bboxs.append(obj['box'])\\n scores.append(obj['score'])\\n # masks.append(obj['mask'])\\n # labels.append(obj['label'])\\n bboxs = np.asarray(bboxs)\\n scores = np.asarray(scores)\\n # masks = np.asarray(masks)\\n # labels = np.asarray(labels)\\n x1 = bboxs[:, 0]\\n y1 = bboxs[:, 1]\\n x2 = bboxs[:, 2]\\n y2 = bboxs[:, 3]\\n areas = (x2 - x1 + 1) * (y2 - y1 + 1)\\n # cfvalid_ids = np.where(scores >= cf_thresh)[0]\\n # scores = scores[cfvalid_ids]\\n\\n order = scores.argsort()[::-1]\\n # mask_sizes = np.sum(masks, axis=(1, 2))\\n # order = mask_sizes.argsort()[::-1]\\n keep = []\\n suppress = []\\n while order.size > 0:\\n i = order[0]\\n keep.append(i)\\n xx1 = np.maximum(x1[i], x1[order[1:]])\\n yy1 = np.maximum(y1[i], y1[order[1:]])\\n xx2 = np.minimum(x2[i], x2[order[1:]])\\n yy2 = np.minimum(y2[i], y2[order[1:]])\\n w = np.maximum(0.0, xx2 - xx1 + 1)\\n h = np.maximum(0.0, yy2 - yy1 + 1)\\n inter = w * h\\n iou = inter / (areas[i] + areas[order[1:]] - inter)\\n\\n # mask_other = masks[order[1:], :, :]\\n # mask_cur = masks[i, :, :]\\n # mask_inter = np.sum(mask_cur & mask_other, axis=(1, 2))\\n # mask_union = np.sum(mask_cur | mask_other, axis=(1, 2))\\n # mask_iou = mask_inter / mask_union\\n\\n # inds = np.where((iou <= nms_thresh) & (mask_iou <= nms_thresh))[0]\\n inds = np.where(iou <= nms_thresh)[0]\\n order = order[inds + 1]\\n\\n # masks = masks[keep]\\n # ids = ids[keep]\\n return keep\",\n \"def rectCenter(rect):\\n return np.array([rect[:2].mean(), rect[2:].mean()])\",\n \"def eval_detection(gt_mask, r):\\n ids = np.unique(r['class_ids'])\\n merged_masks = {}\\n qualities = dict([(1,0), (2,0), (3,0)])\\n\\n for i in ids:\\n merged_masks[i] = (np.zeros_like(r['masks'][:,:,0]) > 0)\\n n_masks = r['masks'].shape[-1]\\n for c in range(n_masks):\\n if i != r['class_ids'][c] or r['scores'][c] < .7:\\n continue\\n\\n mask = r['masks'][:,:,c]\\n merged_masks[i] |= mask\\n\\n gt_mask_i = (gt_mask[:,:,i-1] > 0)\\n intersection = gt_mask_i & merged_masks[i]\\n union = gt_mask_i | merged_masks[i]\\n qualities[i] = np.sum(intersection) / np.sum(union)\\n \\n return qualities, merged_masks\",\n \"def get_bounds_halo(self):\\n bottom_right = np.asarray([self.coords_halo[k][0] for k in range(self.dim)])\\n upper_left = np.asarray([self.coords_halo[k][-1] for k in range(self.dim)])\\n return bottom_right, upper_left\",\n \"def normal_nms(self, all_boxes, all_scores, thresh=0.5, max_boxes=100):\\n x1 = all_boxes[:, 0]\\n y1 = all_boxes[:, 1]\\n x2 = all_boxes[:, 2]\\n y2 = all_boxes[:, 3]\\n areas = (x2 - x1 + 1) * (y2 - y1 + 1)\\n order = all_scores.argsort()[::-1]\\n keep = []\\n while order.size > 0:\\n i = order[0]\\n keep.append(i)\\n if len(keep) >= max_boxes:\\n break\\n xx1 = np.maximum(x1[i], x1[order[1:]])\\n yy1 = np.maximum(y1[i], y1[order[1:]])\\n xx2 = np.minimum(x2[i], x2[order[1:]])\\n yy2 = np.minimum(y2[i], y2[order[1:]])\\n w = np.maximum(0.0, xx2 - xx1 + 1)\\n h = np.maximum(0.0, yy2 - yy1 + 1)\\n inter = w * h\\n ovr = inter / (areas[i] + areas[order[1:]] - inter)\\n inds = np.where(ovr <= thresh)[0]\\n order = order[inds + 1]\\n return keep\",\n \"def compute_crowd_metrics(bbox, virtual_radius=0.45):\\n\\n # 0. all_det\\n all_det = np.shape(bbox)[0]\\n\\n # 1. all_dist: all pedestrain from qolo\\n # all_dist = np.linalg.norm(bbox[:, [0, 1]], axis=1)\\n bbox_xy = bbox[:, [0, 1]]\\n all_dist = np.linalg.norm(bbox_xy, axis=1)\\n\\n # consider qolo capsule\\n # print(\\\"Considered virtual radius is {} m.\\\".format(virtual_radius))\\n capsule_qolo = Capsule(0.18, -0.5, virtual_radius)\\n all_dist_capsuled = np.ones([all_det]) * np.inf\\n for idx in range(all_det):\\n x_dist = bbox_xy[idx, 0]\\n y_dist = bbox_xy[idx, 1]\\n all_dist_capsuled[idx] = capsule_qolo.distanceLocal(x_dist, y_dist)\\n\\n # 2. within_det\\n within_det2_5 = np.sum(np.less(all_dist, 2.5))\\n within_det3 = np.sum(np.less(all_dist, 3.0))\\n within_det5 = np.sum(np.less(all_dist, 5.0))\\n within_det10 = np.sum(np.less(all_dist, 10.0))\\n\\n # 3. min_dist/proximity: all_dist_capsuled or all_dist\\n # only consider the dist larger than )\\n min_dist = min(all_dist_capsuled)\\n\\n # 4. crowd_density\\n crowd_density2_5 = within_det2_5 / (np.pi * 2.5 ** 2)\\n crowd_density3 = within_det3 / (np.pi * 3.0 ** 2)\\n crowd_density5 = within_det5 / (np.pi * 5.0 ** 2)\\n crowd_density10 = within_det10 / (np.pi * 10.0 ** 2)\\n\\n return (\\n all_det,\\n within_det2_5,\\n within_det3,\\n within_det5,\\n within_det10,\\n crowd_density2_5,\\n crowd_density3,\\n crowd_density5,\\n crowd_density10,\\n min_dist,\\n )\",\n \"def calculate_laser_center(self):\\n image = np.copy(self.camera_fiber.temp_image)\\n brightest = np.unravel_index(image.argmax(), image.shape)\\n self.laser_center = self.calculate_gaussian_centroid(image, brightest[0], brightest[1], crop_size=25)\",\n \"def center(coords):\\n for c in coords:\\n if 'avg' not in locals():\\n avg = c\\n else:\\n avg += c\\n return avg / len(coords)\",\n \"def grid_area(cs_grid=None,cs_res=None):\\n # Calculate area on a cubed sphere\\n if cs_res is None:\\n cs_res = cs_grid['lon_b'].shape[-1] - 1\\n elif cs_grid is None:\\n cs_grid = cubedsphere.csgrid_GMAO(cs_res)\\n elif cs_grid is not None and cs_res is not None:\\n assert cs_res == cs_grid['lon_b'].shape[-1], 'Routine grid_area received inconsistent inputs' \\n cs_area = np.zeros((6,cs_res,cs_res))\\n cs_area[0,:,:] = face_area(cs_grid['lon_b'][0,:,:],cs_grid['lat_b'][0,:,:])\\n for i_face in range(1,6):\\n cs_area[i_face,:,:] = cs_area[0,:,:].copy()\\n return cs_area\",\n \"def fix_sphere_h (center_x, center_y, center_z, radius, centers, radii, len_points, list_of_a):\\n g_x = []\\n g_y = []\\n g_z = []\\n points = [hydrogen_coord_gen(center_x, center_y, center_z, radius) for i in range(0, len_points)] \\n x = [points[i][0] for i in range(0, len(points))] \\n y = [points[i][1] for i in range(0, len(points))]\\n z = [points[i][2] for i in range(0, len(points))]\\n for i in range(0, len(points)):\\n check = 0\\n check_b = 0\\n j = 0\\n while (j <= (len(centers) - 1) and (check == 0)): \\n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], centers[j][0], centers[j][1], centers[j][2]) < radii[j]):\\n check += 1\\n j += 1\\n h = 0\\n while ((check_b == 0) and (h <= len(list_of_a) -1)):\\n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], list_of_a[h].x, list_of_a[h].y, list_of_a[h].z) <= 1.50): \\n check_b += 1\\n h += 1\\n if ((check == 0) and (check_b == 0)):\\n g_x.append(x[i])\\n g_y.append(y[i])\\n g_z.append(z[i])\\n return g_x, g_y, g_z\",\n \"def get_raw_bounds(self) -> [Vector, Vector]:\\n\\t\\tverts = np.array([v.co for mesh in self._meshes for v in mesh.data.vertices])\\n\\t\\tbbox_min = Vector([*np.min(verts, axis=0)])\\n\\t\\tbbox_max = Vector([*np.max(verts, axis=0)])\\n\\t\\treturn bbox_min, bbox_max\",\n \"def find_centroid(event_file):\\n \\n print('Finding the centroid of the event file...\\\\n')\\n \\n make_img(event_file,clobber=True)\\n \\n fits = pyfits.open('temp.fits')\\n \\n #Previously used the RA and DEC headers to find the centre, now trying a more nuanced\\n #max pixel value method\\n \\n #source_ra = fits[1].header['RA_TARG']\\n #source_dec = fits[1].header['DEC_TARG']\\n \\n #return source_ra,source_dec\\n \\n data = fits[0].data\\n \\n #As the data from make_img is 1024x1024 based on the centre of the image, use modulo\\n #arithmetic to find the physical x and y coordinates\\n \\n argmax = np.argmax(data)\\n \\n x = argmax%1024 + 3584\\n y = int(argmax/1024) + 3584\\n \\n return x,y\",\n \"def bounds(self):\\n return self._bboxes[0][0] #TODO: merge all coverages\",\n \"def _get_clip_loc_in_array(self):\\r\\n\\r\\n # coordinates of upperleft and lowerright points of binding box\\r\\n box_ulx, box_uly, box_lrx, box_lry = self.clip_box[0][0], self.clip_box[0][1], \\\\\\r\\n self.clip_box[1][0], self.clip_box[1][1]\\r\\n\\r\\n # Get the offsets that correspond to the bounding box corner coordinates.\\r\\n offsets_ul = gdal.ApplyGeoTransform(self.inv_gt, box_ulx, box_uly)\\r\\n offsets_lr = gdal.ApplyGeoTransform(self.inv_gt, box_lrx, box_lry)\\r\\n\\r\\n # The offsets are returned as floating point, but we need integers.\\r\\n self.off_ulx, self.off_uly = map(int, offsets_ul)\\r\\n self.off_lrx, self.off_lry = map(int, offsets_lr)\\r\\n\\r\\n # Compute the numbers of rows and columns to extract, based on the offsets.\\r\\n self.row = self.off_lry - self.off_uly\\r\\n self.column = self.off_lrx - self.off_ulx\",\n \"def _getRawBound(self):\\n if self._colormap is None:\\n return None\\n elif self._index == 0:\\n return self._colormap.getVMin()\\n else: # self._index == 1\\n return self._colormap.getVMax()\",\n \"def get_response_weights_vector(zenith,azimuth,binsize=5,cut=57.4):\\n\\n # assuming useful input:\\n # azimuthal angle is periodic in the range [0,360[\\n # zenith ranges from [0,180[ \\n # checking azimuth range (can be exactly 360?)\\n azimuth[azimuth == 360] -= 0.01\\n \\n # check which pixel (index) was hit on regular grid\\n hit_pixel_zi = np.floor(zenith/binsize).astype(int)\\n hit_pixel_ai = np.floor(azimuth/binsize).astype(int)\\n\\n # and which pixel centre\\n hit_pixel_z = (hit_pixel_zi+0.5)*binsize\\n hit_pixel_a = (hit_pixel_ai+0.5)*binsize\\n\\n # check which zeniths are beyond threshold\\n bad_idx = np.where(hit_pixel_z > cut) \\n \\n # calculate nearest neighbour pixels indices\\n za_idx = np.array([[np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize+0.5)],\\n [np.floor(azimuth/binsize+0.5),np.floor(zenith/binsize-0.5)],\\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize+0.5)],\\n [np.floor(azimuth/binsize-0.5),np.floor(zenith/binsize-0.5)]]).astype(int)\\n\\n # take care of bounds at zenith (azimuth is allowed to be -1!)\\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] < 0)] += 1\\n (za_idx[:,1,:])[np.where(za_idx[:,1,:] >= 180/binsize)] = int(180/binsize-1)\\n # but azimuth may not be larger than range [0,360/binsize[\\n (za_idx[:,0,:])[np.where(za_idx[:,0,:] >= 360/binsize)] = 0\\n \\n # and pixel centres of neighbours\\n azimuth_neighbours = (za_idx[:,0]+0.5)*binsize\\n zenith_neighbours = (za_idx[:,1]+0.5)*binsize\\n\\n # calculate angular distances to neighbours\\n dists = angular_distance(azimuth_neighbours,zenith_neighbours,azimuth,zenith)\\n\\n # inverse weighting to get impact of neighbouring pixels\\n n_in = len(zenith)\\n weights = (1/dists)/np.sum(1/dists,axis=0).repeat(4).reshape(n_in,4).T\\n # if pixel is hit directly, set weight to 1.0\\n weights[np.isnan(weights)] = 1\\n # set beyond threshold weights to zero\\n weights[:,bad_idx] = 0\\n\\n return za_idx,weights\",\n \"def compute_iso0(radar, ml_top, iso0_field='height_over_iso0'):\\n iso0_data = np.ma.masked_all((radar.nrays, radar.ngates))\\n for ind_ray in range(radar.nrays):\\n iso0_data[ind_ray, :] = (\\n radar.gate_altitude['data'][ind_ray, :]-ml_top[ind_ray])\\n\\n iso0_dict = get_metadata(iso0_field)\\n iso0_dict['data'] = iso0_data\\n\\n return iso0_dict\",\n \"def ap_index_bounds(self, qa_lows, qa_highs, ap_coordinates):\\n\\n # Treat the first alignment area separately. Its lower bound is the first alignment point.\\n qa_ap_index_lows = [0]\\n\\n # Starting with the second alignment point, search for the first one on the upper area\\n # border or beyond it. Take it as the upper index bound.\\n for ap_index, ap_value in enumerate(ap_coordinates[1:]):\\n if ap_value >= qa_highs[0]:\\n qa_ap_index_highs = [ap_index + 2]\\n break\\n\\n # For interior quality areas\\n for qa_index_m1, qa_low in enumerate(qa_lows[1:-1]):\\n\\n # The index of the quality area (qa_index) has to be increased by one because the list\\n # used for the enumerator starts with the second entry.\\n qa_index = qa_index_m1 + 1\\n qa_high = qa_highs[qa_index]\\n\\n # For the lower index bound, look for the first alignment point on the lower border\\n # or beyond in reversed order.\\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\\n if ap_value <= qa_low:\\n qa_ap_index_lows.append(ap_index)\\n break\\n\\n # For the upper index bound, look for the first alignment point on the upper border\\n # or beyond.\\n for ap_index, ap_value in enumerate(ap_coordinates):\\n if ap_value >= qa_high:\\n qa_ap_index_highs.append(ap_index + 1)\\n break\\n\\n # The last alignment point index was removed from the search. If this is the upper bound\\n # for the last inner quality area, it has not been assigned to the index_highs list. In\\n # this case this list is one entry short. In this case add the index of the last alignment\\n # point as the upper index bound.\\n if len(qa_ap_index_highs) < len(qa_ap_index_lows):\\n qa_ap_index_highs.append(len(ap_coordinates))\\n\\n # In analogy to the first quality area, treat the case of the last quality area separately\\n # as well.\\n for ap_index, ap_value in reversed(list(enumerate(ap_coordinates))):\\n if ap_value <= qa_lows[-1]:\\n qa_ap_index_lows.append(ap_index)\\n break\\n # The upper index bound is always the last alignment point index.\\n qa_ap_index_highs.append(len(ap_coordinates))\\n\\n return qa_ap_index_lows, qa_ap_index_highs\",\n \"def grid_cloud_top(data, xradar, yradar, xgrid, ygrid, theta_3db=1.5, rmax=150e3, gatespacing=250):\\n if xradar.shape != data.shape:\\n raise IndexError(\\\"Bad dimensions\\\")\\n\\n if len(xgrid.shape) < len(xradar.shape):\\n xgrid, ygrid = np.meshgrid(xgrid, ygrid)\\n\\n eth_out = np.zeros(xgrid.shape) + np.NaN\\n\\n for i in range(len(xgrid)):\\n for j in range(len(ygrid)):\\n cnt = 0\\n zmax = 0\\n xi = xgrid[j, i]\\n yi = ygrid[j, i]\\n\\n if xi ** 2 + yi ** 2 > rmax ** 2:\\n continue\\n\\n width = 0.5 * (np.sqrt(xi ** 2 + yi ** 2) * theta_3db * np.pi / 180)\\n if width < gatespacing:\\n width = gatespacing\\n\\n for k in range(data.shape[1]):\\n for l in range(data.shape[0]):\\n xr = xradar[l, k]\\n yr = yradar[l, k]\\n\\n if (\\n xr >= xi - width\\n and xr < xi + width\\n and yr >= yi - width\\n and yr < yi + width\\n ):\\n if data[l, k] > 0:\\n zmax = zmax + data[l, k]\\n cnt = cnt + 1\\n\\n if cnt != 0:\\n eth_out[j, i] = zmax / cnt\\n\\n return eth_out\",\n \"def get_bounds(self, crs=\\\"default\\\"):\\n\\n if crs == \\\"default\\\":\\n crs = podpac.settings[\\\"DEFAULT_CRS\\\"]\\n\\n bounds = {}\\n for coords in self.find_coordinates():\\n ct = coords.transform(crs)\\n for dim, (lo, hi) in ct.bounds.items():\\n if dim not in bounds:\\n bounds[dim] = (lo, hi)\\n else:\\n bounds[dim] = (min(lo, bounds[dim][0]), max(hi, bounds[dim][1]))\\n\\n return bounds, crs\",\n \"def getBoundingBoxCenter(self, shell=False, *args, **kwargs):\\n if shell:\\n self.grabShell()\\n uvBB = pm.polyEvaluate(boundingBoxComponent2d=True)\\n uvCenter = [((uvBB[0][1] + uvBB[0][0]) / 2), ((uvBB[1][1] + uvBB[1][0]) / 2)]\\n return uvCenter\",\n \"def gen_centers(self):\\n\\n \\\"\\\"\\\"x_track = self.cs.discrete_rollout()\\n t = np.arange(len(x_track))*self.dt\\n # choose the points in time we'd like centers to be at\\n c_des = np.linspace(0, self.cs.run_time, self.n_bfs)\\n self.c = np.zeros(len(c_des))\\n for ii, point in enumerate(c_des):\\n diff = abs(t - point)\\n self.c[ii] = x_track[np.where(diff == min(diff))[0][0]]\\\"\\\"\\\"\\n\\n # desired activations throughout time\\n des_c = jnp.linspace(0, self.cs.run_time, self.n_bfs)\\n\\n self.c = np.ones(len(des_c))\\n for n in range(len(des_c)):\\n # finding x for desired times t\\n self.c[n] = jnp.exp(-self.cs.ax * des_c[n])\\n self.c = jnp.array(self.c)\",\n \"def on_max_hit_points(self):\\n pass\",\n \"def total_crimes_in_bounds(user_coords):\\n\\n crimes_coords = {'crimes': []}\\n\\n # takes in user_coords point a and point b\\n # in order to determine top left and bottom right coordinates.\\n point_a = user_coords['point_a']\\n point_b = user_coords['point_b']\\n\\n # compare latitude to see what's the top coord, tupleize\\n # add 0.005 to latitude, and subtract 0.02 to longitude\\n top_left_coord = {'lat': max(point_a['lat'], point_b['lat']) + 0.005,\\n 'lng': min(point_a['lng'], point_b['lng']) - 0.02}\\n\\n # subtract 0.005 to latitude, and add 0.02 to longitude\\n bottom_right_coord = {'lat': min(point_a['lat'], point_b['lat']) - 0.005,\\n 'lng': max(point_a['lng'], point_b['lng']) + 0.02}\\n\\n # once the bounds are generated, we will want to do a query for all of the\\n # geohashes that are within those bounds. Let's do that now.\\n # some raw sql to get the center coords of geohash\\n geohash_in_bounds_sql = \\\"SELECT *, \\\" + \\\\\\n \\\"ST_AsText(ST_PointFromGeoHash(geohash)) AS lat_lng \\\" + \\\\\\n \\\"FROM nyc_crimes_by_geohash \\\" + \\\\\\n \\\"WHERE ST_Contains(\\\" + \\\\\\n \\\"ST_MakeBox2D(\\\" + \\\\\\n \\\"ST_Point(%f, %f), ST_Point(%f, %f)), ST_PointFromGeoHash(geohash));\\\" \\\\\\n % (top_left_coord['lat'], top_left_coord['lng'],\\n bottom_right_coord['lat'], bottom_right_coord['lng'])\\n # execute the raw sql, there should be many\\n geohash_in_bounds_query = db.engine.execute(geohash_in_bounds_sql).fetchall()\\n\\n for row in geohash_in_bounds_query:\\n # strip the lat, lngs before putting them in\\n # some string splitting to extract data\\n location = row[4].strip(\\\"POINT(\\\").rstrip(\\\")\\\").split()\\n latitude = location[0]\\n longitude = location[1]\\n\\n format_loc_dict = {'latitude': latitude, 'longitude': longitude,\\n 'total_crimes': row[2]}\\n\\n # append to crimes_coords inner list\\n crimes_coords['crimes'].append(format_loc_dict)\\n\\n return crimes_coords\",\n \"def get_max_score(location_list, grid, shape):\",\n \"def find_components(image,deltaPix,lens_rad_arcsec = 6.0,lens_rad_ratio = None,\\n center_x = None,center_y = None, gal_rad_ratio = 0.1,\\n min_size_arcsec=0.7,thresh=0.5, many_sources = True,\\n show_locations=False, title = None):\\n\\n # convert minimum component size in pixel units\\n min_size = int(min_size_arcsec / deltaPix)\\n \\n #Convert lens radius and central galaxy radius to pixels\\n if lens_rad_ratio == None:\\n lens_rad = int(lens_rad_arcsec / deltaPix)\\n else: lens_rad = int(len(image) * lens_rad_ratio)\\n gal_rad = int(len(image) * gal_rad_ratio)\\n \\n \\n# im2[im2 < im2.min() + 10.*thresh] = 0.\\n \\n # downscale source image to data resolution (for speed + easier for converting to data units)\\n #down = image_util.re_size(image, factor=supersampling_factor_source)\\n \\n # apply laplacian of gaussian (LoG) filter to enhance maxima\\n LoG = - gaussian_laplace(deepcopy(image), sigma = min_size, mode='constant', cval=0.) \\n \\n# LoG = - gaussian_laplace(deepcopy(im2), sigma = 2., mode='constant', cval=0.)\\n \\n filtered = deepcopy(LoG)\\n \\n# print(LoG.min(),LoG.max(),np.abs(LoG.min()) + thresh )\\n \\n# print(type(filtered))\\n \\n #background mean and std of filtered image \\n corners = np.zeros([4,5,5])\\n corners[0] = LoG[0:5,0:5]\\n corners[1] = LoG[-5:,0:5]\\n corners[2] = LoG[0:5,-5:]\\n corners[3] = LoG[-5:,-5:]\\n means = []\\n stds = []\\n for c in corners:\\n mn,med,s = sigma_clipped_stats(c,sigma=3.0)\\n means.append(mn)\\n stds.append(s)\\n \\n stds=np.array(stds)\\n means = np.array(means)\\n means_std = np.std(means)\\n# means_good = means[(means >= means.mean() - 1.0 * means_std) & (means <= means.mean() + 1.0 * means_std)]\\n means_good = means[(np.abs(means) <= np.abs(means).min() + 1.0 * means_std)]\\n mean_bg = np.mean(means_good)\\n std_bg = np.mean(stds[(np.abs(means) <= np.abs(means).min() + 1.0 * means_std)])\\n# print('LoG means: {}, Log means std: {}, Log means good: {}, LoG avg mean: {}'.format(means,means_std,means_good,mean_bg))\\n# print('min: {}, max: {}, cut: {}'.format(LoG.min(),LoG.max(),mean_bg + thresh))\\n# print(LoG.min(),LoG.max(),filtered.min() + thresh)\\n \\n \\n # assume all value below max*threshold can not be maxima, so put all to zero\\n# filtered[filtered < thresh*filtered.max()] = 0.\\n \\n# assume all value below min*threshold can not be maxima, so put all to zero\\n# filtered[filtered < filtered.min() + thresh * np.abs(filtered.min())] = 0.\\n# filtered[filtered < mean_bg + thresh] = 0.\\n filtered[filtered < mean_bg + 6.*std_bg] = 0. #set pixels below the mean + 6x threshold to 0\\n \\n # find coordinates of local maxima\\n #print(int(0.5 * min_size))\\n max_idx_2d_small = peak_local_max(filtered, min_distance=0) #All bright pixels\\n max_idx_2d_large = peak_local_max(filtered, min_distance=1) #peaks with min size of 1 pixel\\n \\n x_list_small, y_list_small = max_idx_2d_small[:, 1], max_idx_2d_small[:, 0]\\n x_list_large, y_list_large = max_idx_2d_large[:, 1], max_idx_2d_large[:, 0]\\n \\n im_center_x, im_center_y = len(image) / 2., len(image) / 2. #center of image\\n \\n if (center_x == None) & (center_y == None):\\n new_center_x, new_center_y = im_center_x,im_center_y\\n else:\\n new_center_x, new_center_y = center_x,center_y #new \\\"center\\\" = location of lens galaxy\\n \\n \\n #distance of each detected peak from center\\n R_small = np.sqrt((x_list_small - new_center_x)**2 + (y_list_small - new_center_y)**2) \\n R_large = np.sqrt((x_list_large - new_center_x)**2 + (y_list_large - new_center_y)**2)\\n \\n #Contaminant light is only bright pixels further from center than lens_rad\\n x_sats, y_sats = x_list_small[R_small > lens_rad], y_list_small[R_small > lens_rad]\\n \\n if many_sources:\\n x_lens, y_lens = deepcopy(x_list_small), deepcopy(y_list_small)\\n else:\\n x_lens, y_lens = deepcopy(x_list_large), deepcopy(y_list_large)\\n \\n# x_lens, y_lens = x_list_small[R_small <= lens_rad], y_list_small[R_small <= lens_rad]\\n \\n if (len(x_lens) == 0) & (len(y_lens) == 0):\\n x_lens = [0,15]\\n y_lens = [0,15]\\n \\n sources = QTable([x_lens, y_lens],names={'x_local_peak','y_local_peak'}) #make table of all detected objects\\n# print(x_list_large)\\n# print(y_list_large)\\n# print(sources)\\n \\n # show maxima on image for debug\\n \\n if show_locations:\\n# fig = plt.figure(figsize=(4, 4))\\n #plt.imshow(image, origin='lower', cmap=cmap_flux, norm=LogNorm(1e-2))\\n \\n f, axes = plt.subplots(1, 5, figsize=(20,5), sharex=False, sharey=False)\\n# plt.figure(figsize = (8,8))\\n# plt.subplot(1,2,1)\\n \\n axes[0].imshow(image, origin='lower', norm=SymLogNorm(5))\\n axes[0].set_title('Image')\\n axes[0].set_axis_off()\\n \\n \\n axes[1].imshow(LoG, origin='lower', norm=SymLogNorm(5))\\n axes[1].set_title('LoG Filtered Image')\\n axes[1].set_axis_off()\\n\\n# plt.subplot(1,2,2)\\n axes[2].imshow(filtered, origin='lower', norm=SymLogNorm(5))\\n axes[2].set_title('Final Filtered Image')\\n axes[2].set_axis_off()\\n \\n axes[3].imshow(image, origin='lower', norm=SymLogNorm(5))\\n for i in range(len(x_lens)):\\n axes[3].scatter([x_lens[i]], [y_lens[i]], c='red', s=60, marker='+')\\n \\n for i in range(len(x_list_large)):\\n axes[3].scatter([x_list_large[i]], [y_list_large[i]], c='black', s=100, marker='x')\\n axes[3].set_title('Detected Objects')\\n axes[3].set_axis_off()\\n \\n axes[4].imshow(image, origin='lower', norm=SymLogNorm(5))\\n \\n for i in range(len(x_sats)):\\n axes[4].scatter([x_sats[i]], [y_sats[i]], c='red', s=60, marker='+')\\n \\n# plt.annotate(i+1, (x_list[i], y_list[i]), color='black')\\n \\n# for i in range(len(x_mask)):\\n# plt.scatter([x_mask[i]], [y_mask[i]], c='red', s=100, marker='*')\\n# plt.annotate(i+1, (x_mask[i], y_mask[i]), color='red')\\n axes[4].scatter(new_center_x, new_center_y,c='red', s=100, marker='*')\\n \\n draw_lens_circle = Circle((new_center_x, new_center_y),lens_rad ,fill=False)\\n draw_gal_circle = Circle((new_center_x, new_center_y),gal_rad, fill = False)\\n# plt.gcf().gca().add_artist(draw_lens_circle)\\n# plt.gcf().gca().add_artist(draw_gal_circle)\\n axes[4].add_patch(draw_lens_circle)\\n# axes[4].add_patch(draw_gal_circle)\\n \\n axes[4].set_title('Pixels to Mask: \\\\n r = {:.3f}'.format(lens_rad_arcsec))\\n axes[4].text(1, 1, \\\"detected components\\\", color='red')\\n axes[4].set_axis_off()\\n \\n if title != None:\\n f.suptitle(title, fontsize = 15)\\n# plt.show()\\n \\n \\n return (x_sats, y_sats), (new_center_x, new_center_y), sources\",\n \"def get_center_ball_dist(output, x_true, y_true, num_classes=256):\\n max_dist = 5\\n success, fail = 0, 0\\n dists = []\\n Rx = 640 / 1280\\n Ry = 360 / 720\\n\\n for i in range(len(x_true)):\\n x, y = -1, -1\\n # Reshape output\\n cur_output = output[i].reshape((360, 640))\\n\\n # cv2 image must be numpy.uint8, convert numpy.int64 to numpy.uint8\\n cur_output = cur_output.astype(np.uint8)\\n\\n # reshape the image size as original input image\\n heatmap = cv2.resize(cur_output, (640, 360))\\n\\n # heatmap is converted into a binary image by threshold method.\\n if num_classes == 256:\\n ret, heatmap = cv2.threshold(heatmap, 127, 255, cv2.THRESH_BINARY)\\n else:\\n heatmap *= 255\\n\\n # find the circle in image with 2<=radius<=7\\n circles = cv2.HoughCircles(heatmap, cv2.HOUGH_GRADIENT, dp=1, minDist=1, param1=50, param2=2, minRadius=2,\\n maxRadius=7)\\n # check if there have any tennis be detected\\n if circles is not None:\\n # if only one tennis be detected\\n if len(circles) == 1:\\n\\n x = int(circles[0][0][0])\\n y = int(circles[0][0][1])\\n\\n if x_true[i] < 0:\\n if x < 0:\\n success += 1\\n else:\\n fail += 1\\n dists.append(-2)\\n else:\\n if x < 0:\\n fail += 1\\n dists.append(-1)\\n else:\\n dist = np.linalg.norm(((x_true[i] * Rx) - x, (y_true[i] * Ry) - y))\\n dists.append(dist)\\n if dist < max_dist:\\n success += 1\\n else:\\n fail += 1\\n\\n return dists, success, fail\",\n \"def get_bounds(self):\\n return ([self.t_min] * self.dim,[self.t_max] * self.dim)\",\n \"def calc_R(center):\\r\\n xc = center[0]\\r\\n yc = center[1]\\r\\n return np.sqrt((x-xc)**2 + (y-yc)**2)\",\n \"def _find_centroid_sphere(ch_pos, group_names):\\n cartesian_positions = np.array([ch_pos[ch_name] for ch_name in group_names])\\n sphere_positions = _cart_to_sph(cartesian_positions)\\n cartesian_pos_centroid = np.average(cartesian_positions, axis=0)\\n sphere_pos_centroid = _cart_to_sph(cartesian_pos_centroid)\\n # average the radius and overwrite it\\n avg_radius = np.average(sphere_positions, axis=0)[0]\\n sphere_pos_centroid[0, 0] = avg_radius\\n # convert back to cartesian\\n pos_centroid = _sph_to_cart(sphere_pos_centroid)[0, :]\\n return pos_centroid\",\n \"def grid_search(self,\\n images,\\n labels,\\n max_rot,\\n max_dx,\\n max_dy,\\n by_score=False,\\n generate_samples=False,\\n stop_on_success=True,\\n include_unsuccessful=False):\\n\\n rotation_range = range(-max_rot, max_rot)\\n dx_range = range(-max_dx, max_dx)\\n dy_range = range(-max_dy, max_dy)\\n cartesian_product = [i for i in itertools.product(rotation_range, dx_range, dy_range)]\\n\\n def get_abs_sum(arg):\\n return abs(arg[0]) + abs(arg[1]) + abs(arg[2])\\n\\n if by_score:\\n cartesian_product.sort(key=get_abs_sum)\\n else:\\n random.shuffle(cartesian_product)\\n\\n adv_status = torch.ones(images.shape[0], dtype=torch.bool).to(self.device)\\n\\n for args in cartesian_product:\\n print(args)\\n advs = F.affine(images, args[0], [args[1], args[2]], 1.0, [0.0, 0.0])\\n if self.parse_adversarials(advs,\\n labels,\\n adv_status,\\n images,\\n include_unsuccessful=include_unsuccessful,\\n generate_samples=generate_samples,\\n stop_on_success=stop_on_success):\\n break\",\n \"def get_final_bounding_box(boxes, nms_idx, width: int, height: int):\\n x1 = np.inf\\n y1 = np.inf\\n x2 = -np.inf\\n y2 = -np.inf\\n\\n bx = [boxes[i] for i in nms_idx]\\n for box in bx:\\n xmin = np.min(box[[0, 2]])\\n xmax = np.max(box[[0, 2]])\\n ymin = np.min(box[[1, 3]])\\n ymax = np.max(box[[1, 3]])\\n\\n x1 = np.min([xmin, x1])\\n y1 = np.min([ymin, y1])\\n x2 = np.max([xmax, x2])\\n y2 = np.max([ymax, y2])\\n return x1, y1, x2, y2\",\n \"def __nc_geo_bounds(self, extent, data_sel):\\n indx = None\\n if extent is not None:\\n if len(extent) != 4:\\n raise ValueError('parameter extent must have 4 elements')\\n\\n lats = self.fid['/instrument/latitude_center'][:].reshape(\\n self.scanline, self.ground_pixel)\\n lons = self.fid['/instrument/longitude_center'][:].reshape(\\n self.scanline, self.ground_pixel)\\n\\n indx = np.where((lons >= extent[0]) & (lons <= extent[1])\\n & (lats >= extent[2]) & (lats <= extent[3]))\\n data_sel = np.s_[indx[0].min():indx[0].max(),\\n indx[1].min():indx[1].max()]\\n\\n gid = self.fid['/instrument']\\n lat_bounds = gid['latitude_corners'][:].data.reshape(\\n self.scanline, self.ground_pixel, 4)\\n lon_bounds = gid['longitude_corners'][:].data.reshape(\\n self.scanline, self.ground_pixel, 4)\\n if data_sel is not None:\\n lat_bounds = lat_bounds[data_sel + (slice(None),)]\\n lon_bounds = lon_bounds[data_sel + (slice(None),)]\\n\\n return (data_sel, lon_bounds, lat_bounds)\",\n \"def multi_gaussian_lens(self, kwargs_lens, n_comp=20):\\n kwargs_lens_copy = copy.deepcopy(kwargs_lens)\\n if 'center_x' in kwargs_lens_copy[0]:\\n center_x = kwargs_lens_copy[0]['center_x']\\n center_y = kwargs_lens_copy[0]['center_y']\\n else:\\n raise ValueError('no keyword center_x defined!')\\n theta_E = self.LensModel.effective_einstein_radius(kwargs_lens)\\n r_array = np.logspace(-4, 2, 200) * theta_E\\n #r_array = np.logspace(-2, 1, 50) * theta_E\\n lens_model_internal_bool = self.kwargs_model.get('lens_model_internal_bool', [True] * len(kwargs_lens))\\n kappa_s = np.zeros_like(r_array)\\n for i in range(len(kwargs_lens_copy)):\\n if lens_model_internal_bool[i]:\\n if 'center_x' in kwargs_lens_copy[0]:\\n kwargs_lens_copy[i]['center_x'] -= center_x\\n kwargs_lens_copy[i]['center_y'] -= center_y\\n kappa_s += self.LensModel.kappa(r_array, np.zeros_like(r_array), kwargs_lens_copy, k=i)\\n amplitudes, sigmas, norm = mge.mge_1d(r_array, kappa_s, N=n_comp)\\n return amplitudes, sigmas, center_x, center_y\",\n \"def calcFaceAreas(x,y,z):\\n (nLonP1, nLatP1) = x.shape\\n (nLon, nLat) = (nLonP1-1, nLatP1-1)\\n\\n area = numpy.zeros((nLon, nLat))\\n\\n for i in range(nLon):\\n for j in range(nLat):\\n left = distance( (x[i,j], y[i,j], z[i,j]), (x[i,j+1], y[i,j+1], z[i,j+1]) )\\n right = distance( (x[i+1,j], y[i+1,j], z[i+1,j]), (x[i+1,j+1], y[i+1,j+1], z[i+1,j+1]) )\\n top = distance( (x[i,j+1], y[i,j+1], z[i,j+1]), (x[i+1,j+1], y[i+1,j+1], z[i+1,j+1]) )\\n bot = distance( (x[i,j], y[i,j], z[i,j]), (x[i+1,j], y[i+1,j], z[i+1,j]) )\\n \\n area[i,j] = 0.5*(left+right) * 0.5*(top+bot)\\n\\n return area\",\n \"def detect(self, mask):\\n # 1) Return Non zero indices\\n det_idx = np.where(mask > 0.0)\\n idx_x, idx_y = det_idx[0], det_idx[1]\\n # 2) Create 1x1 box for each pixel detected.\\n detections = []\\n for i in range(0, len(idx_x)):\\n x, y = idx_x[i], idx_y[i]\\n detections.append((x, y, x+1, y+1, 1)) # x1, y1, x2, y2, area\\n # 3) merge boxes\\n bounding_boxes = self.bounding_boxes(detections)\\n return bounding_boxes\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.54468155","0.5245982","0.52018434","0.51407737","0.5027572","0.501179","0.49909672","0.49505368","0.49250877","0.49115202","0.49069312","0.4905353","0.48982129","0.48870504","0.4865395","0.48550183","0.4845263","0.47969246","0.4787651","0.4767172","0.47633308","0.4750658","0.47479448","0.47339362","0.47285673","0.47237074","0.4722375","0.4722134","0.47218993","0.47121498","0.47121185","0.47085798","0.47074458","0.47050658","0.47016785","0.4698726","0.46950874","0.46904483","0.46901226","0.46882355","0.4685476","0.46846965","0.46824208","0.46818632","0.46797615","0.46786997","0.46780536","0.46703002","0.46697843","0.4668188","0.4665379","0.46538702","0.46536738","0.46499625","0.46466655","0.46453503","0.46453032","0.46393093","0.46322253","0.46233368","0.46228695","0.4616551","0.46158567","0.46132353","0.46122605","0.46049652","0.4601896","0.45941898","0.4587908","0.45865616","0.45837393","0.45813346","0.4580609","0.4578817","0.45779514","0.45755455","0.45715663","0.45649806","0.45637092","0.45626518","0.45610648","0.45576945","0.4557385","0.45452818","0.45425206","0.4539822","0.45301053","0.45289046","0.45278907","0.45271212","0.45217526","0.45112702","0.45087907","0.44999135","0.44995096","0.44952685","0.44932854","0.4492662","0.44914004","0.44906065"],"string":"[\n \"0.54468155\",\n \"0.5245982\",\n \"0.52018434\",\n \"0.51407737\",\n \"0.5027572\",\n \"0.501179\",\n \"0.49909672\",\n \"0.49505368\",\n \"0.49250877\",\n \"0.49115202\",\n \"0.49069312\",\n \"0.4905353\",\n \"0.48982129\",\n \"0.48870504\",\n \"0.4865395\",\n \"0.48550183\",\n \"0.4845263\",\n \"0.47969246\",\n \"0.4787651\",\n \"0.4767172\",\n \"0.47633308\",\n \"0.4750658\",\n \"0.47479448\",\n \"0.47339362\",\n \"0.47285673\",\n \"0.47237074\",\n \"0.4722375\",\n \"0.4722134\",\n \"0.47218993\",\n \"0.47121498\",\n \"0.47121185\",\n \"0.47085798\",\n \"0.47074458\",\n \"0.47050658\",\n \"0.47016785\",\n \"0.4698726\",\n \"0.46950874\",\n \"0.46904483\",\n \"0.46901226\",\n \"0.46882355\",\n \"0.4685476\",\n \"0.46846965\",\n \"0.46824208\",\n \"0.46818632\",\n \"0.46797615\",\n \"0.46786997\",\n \"0.46780536\",\n \"0.46703002\",\n \"0.46697843\",\n \"0.4668188\",\n \"0.4665379\",\n \"0.46538702\",\n \"0.46536738\",\n \"0.46499625\",\n \"0.46466655\",\n \"0.46453503\",\n \"0.46453032\",\n \"0.46393093\",\n \"0.46322253\",\n \"0.46233368\",\n \"0.46228695\",\n \"0.4616551\",\n \"0.46158567\",\n \"0.46132353\",\n \"0.46122605\",\n \"0.46049652\",\n \"0.4601896\",\n \"0.45941898\",\n \"0.4587908\",\n \"0.45865616\",\n \"0.45837393\",\n \"0.45813346\",\n \"0.4580609\",\n \"0.4578817\",\n \"0.45779514\",\n \"0.45755455\",\n \"0.45715663\",\n \"0.45649806\",\n \"0.45637092\",\n \"0.45626518\",\n \"0.45610648\",\n \"0.45576945\",\n \"0.4557385\",\n \"0.45452818\",\n \"0.45425206\",\n \"0.4539822\",\n \"0.45301053\",\n \"0.45289046\",\n \"0.45278907\",\n \"0.45271212\",\n \"0.45217526\",\n \"0.45112702\",\n \"0.45087907\",\n \"0.44999135\",\n \"0.44995096\",\n \"0.44952685\",\n \"0.44932854\",\n \"0.4492662\",\n \"0.44914004\",\n \"0.44906065\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73296267"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88985,"cells":{"query":{"kind":"string","value":"Compute basic pulse properties quickly"},"document":{"kind":"string","value":"def compute_pulse_properties(w, initial_baseline_samples):\n\n # First compute baseline\n baseline = 0.0\n initial_baseline_samples = min(initial_baseline_samples, len(w))\n for x in w[:initial_baseline_samples]:\n baseline += x\n baseline /= initial_baseline_samples\n\n # Now compute mean, noise, and min\n n = 0 # Running count of samples included in noise sample\n m2 = 0 # Running sum of squares of differences from the baseline\n max_a = -1.0e6 # Running max amplitude\n min_a = 1.0e6 # Running min amplitude\n\n for x in w:\n if x > max_a:\n max_a = x\n if x < min_a:\n min_a = x\n if x < baseline:\n delta = x - baseline\n n += 1\n m2 += delta*(x-baseline)\n\n if n == 0:\n # Should only happen if w = baseline everywhere\n noise = 0\n else:\n noise = (m2/n)**0.5\n\n return baseline, noise, min_a - baseline, max_a - baseline"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, power, T0_ps, center_wavelength_nm,\n time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, \n GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0,\n power_is_avg = False):\n\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\n # make sure we weren't passed mks units \n assert (center_wavelength_nm > 1.0) \n assert (time_window_ps > 1.0 ) \n self.set_center_wavelength_nm(center_wavelength_nm)\n self.set_time_window_ps(time_window_ps) \n \n GDD = GDD\n TOD = TOD\n \n # from https://www.rp-photonics.com/gaussian_pulses.html\n self.set_AT( np.sqrt(power) * np.exp(-2.77*0.5*self.T_ps**2/(T0_ps**2)) ) # input field (W^0.5) \n if power_is_avg: \n self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) ))\n self.chirp_pulse_W(GDD, TOD)\n self.chirp_pulse_T(chirp2, chirp3, T0_ps)","def __init__(self, power, T0_ps, center_wavelength_nm,\n time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, \n GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0,\n power_is_avg = False):\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\n # make sure we weren't passed mks units \n assert (center_wavelength_nm > 1.0) \n assert (time_window_ps > 1.0 ) \n self.set_center_wavelength_nm(center_wavelength_nm) \n self.set_time_window_ps(time_window_ps)\n \n ### Generate pulse\n if not power_is_avg:\n # from https://www.rp-photonics.com/sech2_shaped_pulses.html\n self.set_AT( np.sqrt(power)/np.cosh(self.T_ps/T0_ps) )\n else:\n self.set_AT( 1 / np.cosh(self.T_ps/T0_ps) )\n self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) ))\n \n self.chirp_pulse_W(GDD, TOD)\n self.chirp_pulse_T(chirp2, chirp3, T0_ps)","def __init__(self, power, FWHM_ps, center_wavelength_nm,\n time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, \n GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0,\n power_is_avg = False):\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\n # make sure we weren't passed mks units \n assert (center_wavelength_nm > 1.0) \n assert (time_window_ps > 1.0 ) \n self.set_center_wavelength_nm(center_wavelength_nm) \n self.set_time_window_ps(time_window_ps)\n\n T0_ps = FWHM_ps/3.7909885\n ### Generate pulse\n if not power_is_avg:\n # numpy.sinc is sin(pi*x)/(pi*x), so we divide by pi\n self.set_AT( np.sqrt(power) * np.sinc(self.T_ps/(T0_ps*np.pi)) ) \n else:\n self.set_AT( 1 / np.sinc(np.pi * self.T_ps/(T0_ps*np.pi)) )\n self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) ))\n \n self.chirp_pulse_W(GDD, TOD)\n self.chirp_pulse_T(chirp2, chirp3, T0_ps)","def pulse_width(self) -> int:","def _pulse_analysis_determine(pulse: int) -> entity.StatusEnum:\n # minimum heart rate: https://thenextchallenge.org/resting-heart-rate/\n # After the age of 10, 60 to 100 is considered normal in a resting\n # position (not including factors such as stress and exercise etc…)\n # https://www.medicalnewstoday.com/articles/235710#target-training-heart-rates\n # https://www.heart.org/en/healthy-living/fitness/fitness-basics/target-heart-rates\n\n result = entity.StatusEnum.LIFE_THREATENING\n options = {\n entity.StatusEnum.OK: (60, 100),\n entity.StatusEnum.MINOR: (50, 120),\n entity.StatusEnum.MAJOR: (40, 160),\n }\n\n for status in options:\n min, max = options[status]\n if min <= pulse <= max:\n result = status\n break\n return result","def test_basic_pulse(self):\n coeff = np.array([0.1, 0.2, 0.3, 0.4])\n tlist = np.array([0., 1., 2., 3.])\n ham = sigmaz()\n\n # Basic tests\n pulse1 = Pulse(ham, 1, tlist, coeff)\n assert_allclose(\n pulse1.get_ideal_qobjevo(2)(0).full(),\n tensor(identity(2), sigmaz()).full() * coeff[0])\n pulse1.tlist = 2 * tlist\n assert_allclose(pulse1.tlist, 2 * tlist)\n pulse1.tlist = tlist\n pulse1.coeff = 2 * coeff\n assert_allclose(pulse1.coeff, 2 * coeff)\n pulse1.coeff = coeff\n pulse1.qobj = 2 * sigmay()\n assert_allclose(pulse1.qobj.full(), 2 * sigmay().full())\n pulse1.qobj = ham\n pulse1.targets = 3\n assert_allclose(pulse1.targets, 3)\n pulse1.targets = 1\n qobjevo = pulse1.get_ideal_qobjevo(2)\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\n expected = QobjEvo(\n [tensor(identity(2), sigmaz()), coeff],\n tlist=tlist,\n order=0\n )\n else:\n expected = QobjEvo(\n [tensor(identity(2), sigmaz()), coeff],\n tlist=tlist,\n args={\"_step_func_coeff\": True}\n )\n _compare_qobjevo(qobjevo, expected, 0, 3)","def pulse_width_percent(self) -> float:","def nearest_test_pulse(self):","def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:","def __init__(self, time_window_ps, center_wavelength_nm, power,frep_MHz = 100., NPTS = 2**10,\n power_is_avg = False,\n fileloc = '',\n flip_phase = True):\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\n try:\n self.fileloc = fileloc\n # make sure we weren't passed mks units\n assert (center_wavelength_nm > 1.0) \n assert (time_window_ps > 1.0 )\n self.set_time_window_ps(time_window_ps)\n self.set_center_wavelength_nm(center_wavelength_nm) # reference wavelength (nm) \n \n # power -> EPP\n if power_is_avg:\n power = power / self.frep_mks\n \n # Read in retrieved FROG trace\n frog_data = np.genfromtxt(self.fileloc)\n wavelengths = frog_data[:,0]# (nm)\n intensity = frog_data[:,1]# (arb. units)\n phase = frog_data[:,2]# (radians)\n\n if flip_phase:\n phase = -1 * phase\n \n pulse_envelope = interp1d(wavelengths, intensity, kind='linear',\n bounds_error=False,fill_value=0)\n phase_envelope = interp1d(wavelengths, phase, kind='linear', \n bounds_error=False,fill_value=0)\n \n gridded_intensity = pulse_envelope(self.wl_nm)\n gridded_phase = phase_envelope(self.wl_nm)\n\n # Calculate time domain complex electric field A\n self.set_AW(gridded_intensity*np.exp(1j*gridded_phase))\n # Calculate normalization factor to achieve requested \n # pulse energy\n e_scale = np.sqrt(power / self.calc_epp() )\n self.set_AT(self.AT * e_scale )\n\n except IOError:\n print ('File not found.' )","def pulse(amplitude, onsets, width, t_stop, baseline=0.0):\n times = [0]\n amps = [baseline]\n for onset in onsets:\n times += [onset, onset + width]\n amps += [amplitude, baseline]\n times += [t_stop]\n amps += [baseline]\n return np.array(times), np.array(amps)","def _calpara(self):\n self.up = math.exp(self.sigma*math.sqrt(self.deltatime))\n self.down = math.exp(-self.sigma*math.sqrt(self.deltatime))\n self.upprob = (math.exp((self.r-self.d)*self.deltatime)-self.down)/(self.up-self.down)","def calculate_pulse(processed_video, recorded_time, show_processed_image):\n if show_processed_image:\n processed_video = extract_red_values(processed_video, show_processed_image)\n processed_video = np.asarray(processed_video, dtype=np.float32)\n red_values = []\n for i in range(0, processed_video.shape[0]):\n img = processed_video[i]\n red_intensity = np.mean(img)\n red_values.append(red_intensity)\n peaks, _ = find_peaks(red_values)\n pulse = (len(peaks) / float(recorded_time)) * 60\n pulse = np.int16(pulse)\n rospy.loginfo(\"[EulerianMotionMagnification] Pulse: \" + str(pulse))\n return pulse, red_values","def velPulse (t,Dp,t1,Tp):\r\n\tdiscretePulse=(Dp*math.pi)/(Tp*float(2))*np.cos(math.pi*(t-t1-Tp/float(2))/float(Tp))\r\n\treturn discretePulse","def test_pulse_constructor(self):\n coeff = np.array([0.1, 0.2, 0.3, 0.4])\n tlist = np.array([0., 1., 2., 3.])\n ham = sigmaz()\n # Special ways of initializing pulse\n pulse2 = Pulse(sigmax(), 0, tlist, True)\n assert_allclose(pulse2.get_ideal_qobjevo(2)(0).full(),\n tensor(sigmax(), identity(2)).full())\n\n pulse3 = Pulse(sigmay(), 0)\n assert_allclose(pulse3.get_ideal_qobjevo(2)(0).norm(), 0.)\n\n pulse4 = Pulse(None, None) # Dummy empty ham\n assert_allclose(pulse4.get_ideal_qobjevo(2)(0).norm(), 0.)\n\n tlist_noise = np.array([1., 2.5, 3.])\n coeff_noise = np.array([0.5, 0.1, 0.5])\n tlist_noise2 = np.array([0.5, 2, 3.])\n coeff_noise2 = np.array([0.1, 0.2, 0.3])\n # Pulse with different dims\n random_qobj = Qobj(np.random.random((3, 3)))\n pulse5 = Pulse(sigmaz(), 1, tlist, True)\n pulse5.add_coherent_noise(sigmay(), 1, tlist_noise, coeff_noise)\n pulse5.add_lindblad_noise(\n random_qobj, 0, tlist=tlist_noise2, coeff=coeff_noise2)\n qu, c_ops = pulse5.get_noisy_qobjevo(dims=[3, 2])\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\n expected = QobjEvo(\n [\n tensor([identity(3), sigmaz()]),\n [tensor([identity(3), sigmay()]), coeff_noise]\n ],\n tlist=tlist_noise,\n order=0)\n else:\n expected = QobjEvo(\n [\n tensor([identity(3), sigmaz()]),\n [tensor([identity(3), sigmay()]), coeff_noise]\n ],\n tlist=tlist_noise,\n args={\"_step_func_coeff\": True})\n _compare_qobjevo(qu, expected, 0, 3)","def build_pulse_waveform(startper,endper):\r\n mywaveform = numpy.zeros(100, dtype=numpy.int)\r\n if startper > endper:\r\n mywaveform[0:endper]=1\r\n mywaveform[startper:100]=1\r\n else:\r\n mywaveform[startper:endper]=1 \r\n return mywaveform","def test_pulse_counter_loop(self):\n self.l.output(conf_d=0x01, state_d=0x0)\n self.l.count(reset=True)\n t10, t20 = 0.001231, 0.002063\n errmask, t1, t2 = self.l.pulse(t1=t10, t2=t20,\n lines=0x01, num_pulses=100)\n self.assertTrue(abs(t1-t10)/t10 < .1)\n self.assertTrue(abs(t2-t20)/t20 < .1)\n c, t = self.l.count()\n self.assertEqual(c, 100,\n \"counted %g pulses\" % c)","def accPulse (t,Dp,t1,Tp):\r\n\tdiscretePulse=-(Dp*math.pi**2)/(float(2)*Tp**2)*np.sin(math.pi*(t-t1-Tp/float(2))/float(Tp))\r\n\treturn discretePulse/float(981)","def get_scale_data(pin, timeout=1.0):\n timestamp = time.monotonic()\n with pulseio.PulseIn(pin, maxlen=96, idle_state=True) as pulses:\n pulses.pause()\n pulses.clear()\n pulses.resume()\n\n while len(pulses) < 35:\n if (time.monotonic() - timestamp) > timeout:\n raise RuntimeError(\"Timed out waiting for data\")\n pulses.pause()\n bits = [0] * 96 # there are 12 bytes = 96 bits of data\n bit_idx = 0 # we will count a bit at a time\n bit_val = False # first pulses will be LOW\n print(pulses[1])\n for i in range(len(pulses)):\n if pulses[i] == 65535: # This is the pulse between transmits\n break\n num_bits = int(pulses[i] / 75 + 0.5) # ~14KHz == ~7.5us per clock\n #print(\"%d (%d),\" % (pulses[i], num_bits), end='')\n for bit in range(num_bits):\n #print(\"bit #\", bit_idx)\n bits[bit_idx] = bit_val\n bit_idx += 1\n if bit_idx == 96: # we have read all the data we wanted\n #print(\"DONE\")\n break\n bit_val = not bit_val\n #print(bits)\n data_bytes = [0] * 12\n for byte_n in range(12):\n thebyte = 0\n for bit_n in range(8):\n thebyte <<= 1\n thebyte |= bits[byte_n*8 + bit_n]\n data_bytes[byte_n] = thebyte\n print([hex(i) for i in data_bytes])\n # do some very basic data checking\n if data_bytes[0] != 3 or data_bytes[1] != 3 or data_bytes[7] != 4 \\\n or data_bytes[8] != 0x1C or data_bytes[9] != 0 or data_bytes[10] \\\n or data_bytes[11] != 0:\n raise RuntimeError(\"Bad data capture\")\n reading = ScaleReading()\n\n reading.stable = data_bytes[2] & 0x4\n reading.units = data_bytes[3]\n reading.weight = data_bytes[5] + (data_bytes[6] << 8)\n if data_bytes[2] & 0x1:\n reading.weight *= -1\n if reading.units == ScaleReading.OUNCES:\n # oi no easy way to cast to int8_t\n if data_bytes[4] & 0x80:\n data_bytes[4] -= 0x100\n reading.weight *= 10 ** data_bytes[4]\n return reading","def generatePulse(self, duration=100, gaussian=False, frequency=12., amplitude=1., phase=0., DelayFromZero=0, useCalibration=False, shape=None, name=None):\n if name is None:\n name = 'self%i' % self.index\n self.index += 1\n self._params[\"pulses\"][name] = dict()\n self._params[\"pulses\"][name][\"frequency\"] = frequency\n self._params[\"pulses\"][name][\"name\"] = name\n if shape is None:\n self._params[\"pulses\"][name][\"shape\"] = None\n self._params[\"pulses\"][name][\"duration\"] = duration\n self._params[\"pulses\"][name][\"gaussian\"] = gaussian\n self._params[\"pulses\"][name][\"amplitude\"] = amplitude\n self._params[\"pulses\"][name][\"phase\"] = phase\n self._params[\"pulses\"][name][\"DelayFromZero\"] = DelayFromZero\n self._params[\"pulses\"][name][\"useCalibration\"] = useCalibration\n else:\n self._params[\"pulses\"][name][\"shape\"] = \"userDefined\"\n\n pulse = numpy.zeros(self.numberOfPoints(), dtype=numpy.complex128)\n if self._params['modulationMode'] == \"IQMixer\":\n MWFrequency = float(self._MWSource.frequency())\n self._MWSource.turnOn()\n IF = frequency - MWFrequency\n try:\n if shape is None:\n if gaussian:\n print 'gaussian pulse is not working !!!'\n pulse = self.gaussianPulse(\n sigma=duration, delay=DelayFromZero, amplitude=amplitude)\n else:\n pulse[DelayFromZero:DelayFromZero + duration] = amplitude\n else:\n pulse[:] = shape[:]\n pulse *= numpy.exp(1.0j * phase) / 2\n # REPLACED BY DV IN FEB 2015 (see line below supressed section)\n # if useCalibration:\n #calibrationParameters=self._mixer.calibrationParameters(f_sb=f_sb, f_c=MWFrequency)\n #self.debugPrint( calibrationParameters)\n #cr = float(calibrationParameters['c'])*exp(1j*float(calibrationParameters['phi']))\n #self.debugPrint( \"f_sb=\",f_sb)\n #sidebandPulse = exp(-1.j*f_sb*2.0*math.pi*(arange(DelayFromZero,DelayFromZero+len(pulse))))+cr*exp(1.j*f_sb*2.0*math.pi*(arange(DelayFromZero,DelayFromZero+len(pulse))))\n # self._AWG.setOffset(self._params[\"AWGChannels\"][0],calibrationParameters['i0'])\n # self._AWG.setOffset(self._params[\"AWGChannels\"][1],calibrationParameters['q0'])\n # else:\n #sidebandPulse = exp(-1.j*2.0*math.pi*f_sb*(arange(DelayFromZero,DelayFromZero+len(pulse))))\n #waveformIQ =exp(-2.0j*pi*IF*(times+float(delay)))\n # self._AWG.setOffset(self._params[\"AWGChannels\"][0],0)\n # self._AWG.setOffset(self._params[\"AWGChannels\"][1],0)\n sidebandPulse = self._mixer.generateSidebandWaveform(\n IF=IF, useCalibIfNone=useCalibration, length=self.numberOfPoints())\n pulse[:] *= sidebandPulse\n except:\n raise\n\n if self._params['modulationMode'] == \"SimpleMixer\":\n self._MWSource.setFrequency(frequency)\n if shape is None:\n if gaussian:\n print 'gaussian pulse is not working !!!'\n print duration, DelayFromZero, amplitude\n pulse = self.gaussianPulse(\n sigma=duration, delay=DelayFromZero, amplitude=amplitude)\n else:\n pulse[DelayFromZero:DelayFromZero + duration] = amplitude\n else:\n pulse[:] = shape[:]\n if useCalibration:\n self._AWG.setOffset(\n self._params[\"AWGChannels\"], self._mixer.calibrationParameters())\n if self._params['modulationMode'] == \"InternalModulation\":\n print \"NOT CONFIGURED YET ! DO NOT USE !\"\n self.pulses[name] = [pulse, True]","def calibration(\n self,\n pulse_min: int,\n pulse_max: int,\n pulse_centre: int,\n pulse_angle_90: int,\n pulse_speed_100: int,\n /,\n ) -> None:","def visit_pulseexpr(self, state, channels, t, n_samp, waveform, phase):\n pass","async def Pulse_Lights():\n busylightapi.manager.apply_effect_to_light(ALL_LIGHTS, pulse)\n return {\n \"action\": \"effect\",\n \"name\": \"pulse\",\n \"light_id\": \"all\",\n \"color\": \"red\",\n }","def __init__(self, servo_gpio, pi=None, pulse_left_ns=2500, pulse_right_ns=1000, pulse_centre_ns=None):\n\n self.gpio = servo_gpio\n\n if pi is None:\n self.pi = pi = pigpio.pi()\n else:\n self.pi = pi\n\n self.pulse_left_ns = pulse_left_ns\n self.pulse_right_ns = pulse_right_ns\n\n if pulse_centre_ns is None:\n self.pulse_centre_ns = ((pulse_left_ns - pulse_right_ns) // 2) + pulse_right_ns","def pulse(\n self,\n cycles=1,\n duty_cycle=0.5,\n transient=1,\n period=1.0,\n skew_ratio=sb.NotSpecified,\n **kwargs\n ):\n if skew_ratio is sb.NotSpecified:\n skew_ratio = 1 - duty_cycle\n return dict(\n waveform=Waveform.PULSE,\n cycles=cycles,\n skew_ratio=skew_ratio,\n transient=transient,\n period=period,\n )","def __call__(self, x : float) -> float:\n current = 0\n for key in self.pulses:\n pulseAmmount = self.pulses[key]\n startTime = key[0]\n stopTime=key[1]\n if x >= startTime and x < stopTime:\n current += pulseAmmount\n return current","def time_pulse_us(pin:Pin, pulse_level:int, timeout_us:int=1000000, /) -> int:","def __init__(\n self,\n pin,\n min_pulse_width=500,\n max_pulse_width=2500,\n min_full_sweep_time=0.5,\n rotation_update_freq=25,\n ):\n assert (\n 500 <= min_pulse_width <= 2500\n ), \"min_pulse_width should be between 500 and 2500\"\n assert (\n 500 <= max_pulse_width <= 2500\n ), \"max_pulse_width should be between 500 and 2500\"\n assert (\n min_pulse_width < max_pulse_width\n ), \"min_pulse_width should be less than max_pulse_width\"\n assert (\n min_full_sweep_time > 0\n ), \"min_full_sweep_time should be positive\"\n assert (\n rotation_update_freq > 0\n ), \"rotation_update_freq should be positive\"\n\n self._pin = pin\n self._min_pulse_width = min_pulse_width\n self._max_pulse_width = max_pulse_width\n self._mid_pulse_width = (max_pulse_width + min_pulse_width) / 2\n self._max_pos_change_per_update = 2 / (\n rotation_update_freq * min_full_sweep_time\n )\n self._rotation_update_freq = rotation_update_freq\n self._latest_rotation_start_time = None\n self._position = None\n self._rotation_speed = 0\n self._stopped = False\n\n self._pi = pigpio.pi()\n if not self._pi.connected:\n raise RuntimeError(\"Could not connect to pigpio daemon\")\n self._pi.set_mode(self._pin, pigpio.OUTPUT)\n self._pi.set_servo_pulsewidth(self._pin, 0)","def wave_get_pulses():\n return _u2i(_pigpio_command(_control, _PI_CMD_WVSP, 0, 0))","def computeProp(self):\n self.chem = {}\n for key in self.config.C:\n if key in ['P', 'T', 'Z', 'DZ']:\n continue\n self.chem[key] = chemistry.ConstituentProperties(key)\n\n # nAtm = len(self.gas[self.config.C['P']])\n self.property = []\n for op in self.config.LP:\n self.property.append([])\n zOffset = 0.0\n iOffset = 0\n psep = 1.0E6\n for i, zv in enumerate(self.gas[self.config.C['Z']]): # find the nearest z value at p_ref\n P = self.gas[self.config.C['P']][i]\n if abs(P - self.config.p_ref) < psep:\n psep = abs(P - self.config.p_ref)\n iOffset = i\n zOffset = self.gas[self.config.C['Z']][iOffset]\n z_at_p_ref = self.config.Req\n\n for i, zv in enumerate(self.gas[self.config.C['Z']]):\n T = self.gas[self.config.C['T']][i]\n P = self.gas[self.config.C['P']][i]\n self.property[self.config.LP['P']].append(P)\n self.property[self.config.LP['Z']].append(zv)\n rr = z_at_p_ref + zv - zOffset\n # note that this is the \"actual\"z along equator referenced to planet center (aka radius)\n self.property[self.config.LP['R']].append(rr)\n # ##set mean amu\n amulyr = 0.0\n for key in self.chem:\n amulyr += self.chem[key].amu * self.gas[self.config.C[key]][i]\n self.property[self.config.LP['AMU']].append(amulyr)\n # ##set GM pre-calc (normalized further down) and get lapse rate\n if not i:\n self.property[self.config.LP['GM']].append(0.0)\n self.property[self.config.LP['LAPSE']].append(0.0)\n self.property[self.config.LP['LAPSEP']].append(0.0)\n else:\n rho = (amulyr * P) / (chemistry.R * T)\n dr = abs(zv - self.gas[self.config.C['Z']][i - 1])\n dV = 4.0 * np.pi * (rr**2) * dr\n dM = 1.0e11 * rho * dV\n GdM = self.property[self.config.LP['GM']][i - 1] + chemistry.GravConst * dM\n # in km3/s2\n # mass added as you make way into atmosphere by radius r (times G)\n self.property[self.config.LP['GM']].append(GdM)\n dT = abs(T - self.gas[self.config.C['T']][i - 1])\n dP = abs(P - self.gas[self.config.C['P']][i - 1])\n self.property[self.config.LP['LAPSE']].append(dT / dr)\n self.property[self.config.LP['LAPSEP']].append(dT / dP)\n # ##set refractivity and index of refraction\n refrlyr = 0.0\n for key in self.chem:\n refrlyr += self.chem[key].refractivity(T=T) * self.gas[self.config.C[key]][i]\n refrlyr = refrlyr * P * (293.0 / T)\n self.property[self.config.LP['REFR']].append(refrlyr)\n nlyr = refrlyr / 1.0E6 + 1.0\n self.property[self.config.LP['N']].append(nlyr)\n\n # ##Now need to normalize GM to planet and calculate scale height (H)\n GMnorm = self.property[self.config.LP['GM']][iOffset] # G*(Mass added by p_ref)\n for i, mv in enumerate(self.property[self.config.LP['GM']]):\n gm = self.config.GM_ref - (mv - GMnorm)\n self.property[self.config.LP['GM']][i] = gm\n little_g = gm / self.property[self.config.LP['R']][i]**2\n m_bar = self.property[self.config.LP['AMU']][i]\n T = self.gas[self.config.C['T']][i]\n self.property[self.config.LP['H']].append((chemistry.R * T) /\n (little_g * m_bar) / 1000.0)\n self.property[self.config.LP['g']].append(little_g)\n self.property = np.array(self.property)","def pulse_width(self, value: int, /) -> None:","def pulsewidth2pct(pw): \n shifted = pw - 500.0\n scaled = shifted / 2000.0 * 100.0\n pct = scaled\n return pct","def photometric_calibration():\n pass","def _get_pulse_shaping_waveform(self):\n self.pulse_shaping_list = []\n # Make the rise time be 3.3333% if the dot time.\n rise_time_in_msec = 0.03333333333333 * self.dot_time_in_msec\n # Limit the rise time to 2 milliseconds.\n if rise_time_in_msec > 0.002:\n rise_time_in_msec = 0.002\n rising_falling_count = int(rise_time_in_msec * self.sample_rate)\n step = math.pi / rising_falling_count\n # The first value is zero, so skip that value.\n # The last value is 1.0, so skip that value too.\n for i in range(1, rising_falling_count - 1):\n gain = 0.5 * (1.0 - math.cos(step * i))\n self.pulse_shaping_list.append(gain)","def key_length(x, *args):\n ###########################################################################\n ## Store input as named arrays/parameters for ease of use\n ###########################################################################\n # Asymmetric basis choice probability\n Px = x[0]\n # Weak coherent pulse intensities, mu3 is fixed\n mu = np.array([x[3],x[4],mu3])\n # Probability of Alice sending a pulse of intensity mu_k\n P = np.array([x[1],x[2],1 - x[1] - x[2]])\n \n ###########################################################################\n ## Define total system loss and convert to efficiency\n ###########################################################################\n # Excess loss in decibels\n etaExcess = 10**(-ls / 10.0)\n # Scale excess loss by detector efficiency\n eta = etaExcess*eta_d\n # Take the outer product of FSeff, the free space loss, and mu, the pulse\n # intensities, where FSeff has a length t.\n # Use dt to take a window of t values from FSeff.\n # Returns the (3,t) array mu_FSeff\n mu_FSeff = np.outer(mu, FSeff[time0pos-dt:time0pos+dt+1])\n # Exponential loss decay function\n # Returns the (3,t) array exp_loss_jt\n exp_loss_jt = np.exp(-mu_FSeff*eta)\n\n ###########################################################################\n ## Estimate count and error rates for signals\n ###########################################################################\n # Expected detection rate (including afterpulse contributions)\n # Returns the (3,t) array Dj\n Dj = DRate_j(eta,Pap,Pec,exp_loss_jt)\n ###print('Dj =',np.sum(Dj,axis=1))\n # Probability of having a bit error per intensity for a given time slot\n # Returns the (3,t) array ej\n ej = error_j(Dj,Pap,Pec,QBERI,exp_loss_jt)\n \n ###########################################################################\n ## Store some useful array products\n ###########################################################################\n # Take the dot product of the (3,) array P and the (3,t) array ej.\n # Returns the (t,) array P_dot_ej\n P_dot_ej = np.dot(P, ej)\n # Take the dot product of the (3,) array P and the (3,t) array Dj.\n # Returns the (t,) array P_dot_Dj\n P_dot_Dj = np.dot(P, Dj)\n # Do an element-wise multiplication of the (3,) array P and the (3,t) \n # array Dj.\n # Returns the (3,t) array P_times_Dj\n P_times_Dj = np.transpose(np.multiply(np.transpose(Dj), P))\n\n ###########################################################################\n ## Estimate count statistics\n ###########################################################################\n # Number of events in the sifted X basis for each time slot and intensity\n # Returns the (3,t) array nx\n nx = nxz(Px, Px, Npulse, P_times_Dj)\n # Number of events in the sifted Z basis for each time slot and intensity\n # Returns the (3,t) array nz\n nz = nxz(1 - Px, 1 - Px, Npulse, P_times_Dj)\n\n # Total number of events in the sifted X basis for each intensity\n # Returns the (3,) array nx_mu\n nx_mu = np.sum(nx, axis=1)\n # Total number of events in the sifted Z basis for each intensity\n # Returns the (3,) array nz_mu\n nz_mu = np.sum(nz, axis=1)\n \n # Total number of events in the sifted X basis\n nX = np.sum(nx_mu)\n # Total number of events in the sifted Z basis\n nZ = np.sum(nz_mu) # Not used but written out\n \n # Number of errors in the sifted X basis for each time slot\n # Returns the (t,) array mX\n mX = mXZ(nx, P_dot_Dj, P_dot_ej)\n mZ = mXZ(nz, P_dot_Dj, P_dot_ej)\n # Number of errors in the sifted X basis for each time slot and intensity\n # Returns the (3,t) array mx\n #mx = mxz(mX, P_dot_Dj, P_times_Dj) # Not used\n mz = mxz(mZ, P_dot_Dj, P_times_Dj)\n # Total number of errors in the sifted X basis\n mXtot = np.sum(mX)\n mZtot = np.sum(mZ)\n # Number of errors in the sifted X basis for each intensity\n # Returns the (3,) array mXj\n #mXj = np.sum(mx, axis=1) # Not used\n mZj = np.sum(mz, axis=1)\n \n ###########################################################################\n ## Estimate bounds on count estimates due to statistical fluctuations\n ###########################################################################\n # Upper and lower bounds used to estimate the ideal number of X and Z basis\n # events accounting for statistical fluctuations \n if boundFunc in ['Chernoff','chernoff']:\n # Use Chernoff bounds\n # Returns the (3,) arrays nXmin, nXplus\n nXmin, nXplus = nXZpm(mu,P,nx_mu,eps_s)\n # Returns the (3,) arrays nZmin, nZplus\n nZmin, nZplus = nXZpm(mu,P,nz_mu,eps_s)\n # Returns the (3,) arrays mXmin and mXplus\n #mXmin, mXplus = mXZpm(mu,P,mXj,eps_s) # Not used\n # Returns the (3,) arrays mZmin and mZplus\n mZmin, mZplus = mXZpm(mu,P,mZj,eps_s)\n elif boundFunc in ['Hoeffding','hoeffding']:\n # Use Hoeffding bound\n # Returns the (3,) arrays nXmin, nXplus\n nXmin, nXplus = nXZpm_HB(mu,P,nx_mu,nX,eps_s)\n # Returns the (3,) arrays nZmin, nZplus\n nZmin, nZplus = nXZpm_HB(mu,P,nz_mu,nZ,eps_s)\n # Returns the (3,) arrays mXmin and mXplus\n #mXmin, mXplus = mXZpm_HB(mu,P,mXj,mXtot,eps_s) # Not used\n # Returns the (3,) arrays mZmin and mZplus\n mZmin, mZplus = mXZpm_HB(mu,P,mZj,mZtot,eps_s)\n elif boundFunc in ['Asymptotic','asymptotic']:\n # Use asymptotic bounds - no bounds\n # Returns the (3,) arrays nXmin, nXplus\n nXmin, nXplus = nXZpm_inf(mu,P,nx_mu)\n # Returns the (3,) arrays nZmin, nZplus\n nZmin, nZplus = nXZpm_inf(mu,P,nz_mu)\n # Returns the (3,) arrays mXmin and mXplus\n #mXmin, mXplus = mXZpm_inf(mu,P,mXj,eps_s) # Not used\n # Returns the (3,) arrays mZmin and mZplus\n mZmin, mZplus = mXZpm_inf(mu,P,mZj)\n else:\n # Use Chernoff bounds\n # Returns the (3,) arrays nXmin, nXplus\n nXmin, nXplus = nXZpm(mu,P,nx_mu,eps_s)\n # Returns the (3,) arrays nZmin, nZplus\n nZmin, nZplus = nXZpm(mu,P,nz_mu,eps_s)\n # Returns the (3,) arrays mXmin and mXplus\n #mXmin, mXplus = mXZpm(mu,P,mXj,eps_s) # Not used\n # Returns the (3,) arrays mZmin and mZplus\n mZmin, mZplus = mXZpm(mu,P,mZj,eps_s)\n\n ###########################################################################\n ## Calculate the number of n-photon events\n ###########################################################################\n # Number of vacuum events in the sifted X basis\n sx0 = max(s0(mu,P,nXmin), num_zero)\n # Number of vacuum events in the sifted Z basis\n sz0 = max(s0(mu,P,nZmin), num_zero)\n\n # Number of single photon events in the sifted X basis\n sx1 = max(s1(mu,P,nXmin,nXplus,sx0), num_zero)\n # Number of single photon events in the sifted Z basis\n sz1 = max(s1(mu,P,nZmin,nZplus,sz0), num_zero)\n\n ###########################################################################\n ## Calculate metrics such as the error rate, QBER and mean photon number\n ###########################################################################\n # Number of bit errors associated with single photon events in the sifted\n # Z basis \n vz1 = min(max(vxz1(mu,P,mZmin,mZplus), num_zero), mZtot)\n # Ratio between the number of bit errors and the number of events\n # associated with single photons in the sifted Z basis.\n ratio = min(vz1 / sz1, 1 - num_min)\n # The quantum bit error rate in the sifted X basis\n QBERx = mXtot / nX\n # Calculate the mean photon number\n mpn = mean_photon_a(P,mu)\n\n ###########################################################################\n ## Estimate the number of bits sacrificed for error correction\n ###########################################################################\n if errcorrFunc in ['logM','logm']:\n lambdaEC = logM(nX, QBERx, eps_c)\n elif errcorrFunc in ['Block','block']:\n lambdaEC = 1.16 * nX * h(QBERx)\n elif errcorrFunc in ['mXtot','mxtot']:\n lambdaEC = 1.16 * mXtot\n elif errcorrFunc in ['None','none']:\n lambdaEC = 0\n else:\n lambdaEC = 0\n \n ###########################################################################\n ## Calculate the approximate length of the secret key per pass\n ## See Eq. (1) in [1].\n ###########################################################################\n if boundFunc in ['Asymptotic','asymptotic']:\n # Asymptotic phase error rate for single photon events in the sifted X\n # basis\n phi_x = min(ratio, 0.5)\n # Secret key length in the asymptotic regime\n l = max((sx0 + sx1 * (1 - h(phi_x)) - lambdaEC) * \n heaviside(mu[0] - mu[1] - mu[2]) * heaviside(P[2]), 0.0)\n else:\n # Phase error rate for single photon events in the sifted X basis\n phi_x = min(ratio + gamma(eps_s,ratio,sz1,sx1), 0.5)\n # Secret key length in the finite regime\n l = max((sx0 + sx1 * (1 - h(phi_x)) - lambdaEC -\n 6*np.math.log(21.0 / eps_s, 2) - np.math.log(2.0 / eps_c, 2)) * \n heaviside(mu[0] - mu[1] - mu[2]) * heaviside(P[2]), 0.0)\n l = l / NoPass # Normalise by the number of satellite passes used\n\n return l, QBERx, phi_x, nX, nZ, mXtot, lambdaEC, sx0, sx1, vz1, sz1, mpn","def __pulse_all(self):\n\n if len(self.__bus_dict) == 0:\n return\n bus_dict_copy = self.__bus_dict.copy()\n for line in bus_dict_copy.values():\n for bus in line:\n self.__indevidual_pulse(bus)","def test_pulse(self):\n report(_(\"Testing PULSE sound output\"))\n return self.audio_try_play(type='pulse')","def npulses(self):\n return self.header.pulse_count","def speed_pulse(x, v0=U_I, drop: float = 1, delay: int = 250, duration: float = 1000):\n return v0 - pulse_sigmoid(x=x, A=drop, d=delay, duration=duration)","def prop_delayed_by_airline(jb_sw):\n\n return ...","def getCummulativeValues(self):\n self.cumulativePhaseHeightInRing1 = np.cumsum(self.phaseHeightInRing1)\n self.cumulativePhaseHeightInRing2 = np.cumsum(self.phaseHeightInRing2)\n self.cumulativeLeftCriticalPointsRing1 = np.cumsum(self.leftCriticalPointsRing1)\n self.cumulativeRightCriticalPointsRing1 = np.cumsum(self.rightCriticalPointsRing1)\n self.cumulativeLeftCriticalPointsRing2 = np.cumsum(self.leftCriticalPointsRing2)\n self.cumulativeRightCriticalPointsRing2 = np.cumsum(self.rightCriticalPointsRing2)\n\n if(self.init1 > 0):\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing1):\n self.cumulativeLeftCriticalPointsRing1[index] = value + self.init1\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing1):\n self.cumulativeRightCriticalPointsRing1[index] = value + self.init1\n\n if(self.init2 > 0):\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing2):\n self.cumulativeLeftCriticalPointsRing2[index] = value + self.init2\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing2):\n self.cumulativeRightCriticalPointsRing2[index] = value + self.init2\n\n self.cumulativePhaseHeightInRing1 = np.insert(self.cumulativePhaseHeightInRing1, 0, 0.0)\n self.cumulativePhaseHeightInRing2 = np.insert(self.cumulativePhaseHeightInRing2, 0, 0.0)\n self.cumulativeLeftCriticalPointsRing1 = np.insert(self.cumulativeLeftCriticalPointsRing1, 0, 0.0)\n self.cumulativeRightCriticalPointsRing1 = np.insert(self.cumulativeRightCriticalPointsRing1, 0, 0.0)\n self.cumulativeLeftCriticalPointsRing2 = np.insert(self.cumulativeLeftCriticalPointsRing2, 0, 0.0)\n self.cumulativeRightCriticalPointsRing2 = np.insert(self.cumulativeRightCriticalPointsRing2, 0, 0.0)","def test_pressure_increasing_check_some_constants(mocker, pressure_values, expected):\n profile = mocker.patch.object(argortqcpy.profile, \"Profile\")\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\n\n pic = PressureIncreasingCheck(profile, None)\n output = pic.run()\n\n assert np.all(output.get_output_flags_for_property(\"PRES\").data == expected)","def _pulse_width_record(self, pin):\n self._time = time.ticks_us()\n if self._prev_time == 0:\n self._prev_time = self._time\n return\n self.pulse_buffer.append(self._time - self._prev_time)\n self._prev_time = self._time\n self.lenth = self.lenth + 1","def calcMisc(t, q, u, p):\n m=dict()\n # Split state into positions and speeds (qx, qxd), uaero states (qxa_ua), dynamic inflow states (qxa_di)\n m['qx'], m['qxd'], m['qxa_ua'], m['qxa_di'] = split_q(q, p['Iqxs'], p['Iqxsd'], p['Iqxa_ua'], p['Iqxa_di'])\n\n # Structural states (length 3, even if not all DOFs are actice)\n m['q_full'], m['x'], m['xd'] = inflate_q(q, Iq=p['Iq'])\n\n # Orientation of the section\n m['Ux'], m['Uy'], m['theta_p'] = inputsAtTime(t, u)\n th = m['x'][2]\n m['omega'] = m['xd'][2]\n m['theta'] = th + m['theta_p'] + p['beta'] \n m['rho_x'] = (-p['x_AG']* np.sin(m['theta']) + p['y_AG']*np.cos(m['theta']) )\n m['rho_y'] = (-p['x_AG']* np.sin(m['theta']) + p['y_AG']*np.cos(m['theta']) )\n return m","def get_properties(self):\n assert self.kekulize, '#ERROR: u need to get explicit BOs for amon generation'\n self.vs = np.array([ ai.GetTotalValence() for ai in self.m0.GetAtoms() ], np.int)\n #self.update_bom()\n self.ias_heav = self.ias[ self.zs > 1 ]\n bom_heav = self.bom[ self.ias_heav, : ][ :, self.ias_heav ]\n self.vs_heav = bom_heav.sum(axis=0)\n self.cns_heav = ( bom_heav > 0 ).sum(axis=0)\n self.nhs = self.vs[:self.nheav] - self.vs_heav - self.chgs[:self.nheav]\n self.dvs = self.vs_heav - self.cns_heav\n self.hybs = np.array([ _hyb[ai.GetHybridization()] for ai in self.m.GetAtoms() ])","def dispPulse (t,Dp,t1,Tp):\r\n\tdiscretePulse=Dp/float(2)*np.sin(math.pi*(t-t1-Tp/float(2))/float(Tp))+Dp/float(2)\r\n\treturn discretePulse","def pulse_analysis(\n pulse: int, measurement_statistics: entity.MeasurementStatistics\n) -> entity.StatusEnum:\n result = entity.StatusEnum.MISSING\n if not str(pulse).isnumeric() or isinstance(pulse, str):\n result = entity.StatusEnum.MISSING\n\n elif 0 < pulse < 230:\n result = _pulse_analysis_determine(pulse)\n\n measurement_statistics.increment(result)\n return result","def init_servos():\n for i in range(0, 7):\n kit.servo[i].actuation_range = 180\n kit.servo[i].set_pulse_width_range(450, 2550)","def calculate_averaged_properties(poly_data, bucket):\n\n locator = vtk.vtkPointLocator()\n locator.SetDataSet(poly_data)\n locator.BuildLocator()\n\n LENGTH = 0.03\n MODIFIER = 3e3\n\n volume = numpy.zeros(poly_data.GetNumberOfPoints())\n temperature = numpy.zeros(poly_data.GetNumberOfPoints())\n solid_pressure = numpy.zeros(poly_data.GetNumberOfPoints())\n velocity = numpy.zeros((poly_data.GetNumberOfPoints(), 3))\n solid_pressure_gradient = numpy.zeros((poly_data.GetNumberOfPoints(), 3))\n\n for particle in bucket:\n point_list = vtk.vtkIdList()\n locator.FindPointsWithinRadius(LENGTH, particle.pos, point_list)\n\n beta = 1.0/6.0*numpy.pi*particle.parameters.diameter**3\n\n for _ in range(point_list.GetNumberOfIds()):\n point_index = point_list.GetId(_)\n\n particle2 = bucket.particles[point_index]\n\n rad2 = distance2(particle2.pos, particle.pos)\n rad2 /= LENGTH**2\n\n gamma = beta*numpy.exp(-rad2)*MODIFIER\n\n volume[point_index] += gamma\n\n velocity[point_index, :] += particle.vel*gamma\n\n volume /= 0.5*LENGTH**2*(1.0-numpy.exp(-1.0**2))\n velocity /= 0.5*LENGTH**2*(1.0-numpy.exp(-1.0**2))\n\n for i in range(3):\n velocity[:, i] /= volume\n\n for k, particle in enumerate(bucket):\n point_list = vtk.vtkIdList()\n locator.FindPointsWithinRadius(LENGTH, particle.pos, point_list)\n\n beta = 1.0/6.0*numpy.pi*particle.parameters.diameter**3\n\n for _ in range(point_list.GetNumberOfIds()):\n point_index = point_list.GetId(_)\n\n rad2 = distance2(poly_data.GetPoints().GetPoint(point_index), particle.pos)\n rad2 /= LENGTH**2\n\n gamma = beta*numpy.exp(-rad2)*MODIFIER\n\n c = distance2(particle.vel, velocity[k, :])\n\n temperature[point_index] += c*gamma\n\n\n for particle in bucket:\n point_list = vtk.vtkIdList()\n locator.FindPointsWithinRadius(LENGTH, particle.pos, point_list)\n\n beta = 1.0/6.0*numpy.pi*particle.parameters.diameter**3\n\n for _ in range(point_list.GetNumberOfIds()):\n point_index = point_list.GetId(_)\n\n rad2 = distance2(poly_data.GetPoints().GetPoint(point_index), particle.pos)\n rad2 /= LENGTH **2\n\n gamma = beta*numpy.exp(-rad2)*MODIFIER\n\n c = distance2(particle.vel, velocity[point_index, :])\n\n val = (bucket.particles[point_index].pos-particle.pos)/LENGTH**2\n\n spg = ((radial_distribution_function(volume[point_index])\n +volume[point_index]*rdf_deriv(volume[point_index]))*temperature[point_index]\n +c*volume[point_index]*radial_distribution_function(volume[point_index]))\n\n solid_pressure_gradient[point_index, :] += (val*spg*gamma)\n\n for _ in range(poly_data.GetNumberOfPoints()):\n\n solid_pressure[_] = (bucket.particles[0].parameters.rho*volume[_]\n *radial_distribution_function(volume[_])*temperature[_])\n\n data = [vtk.vtkDoubleArray()]\n data[0].SetName('SolidVolumeFraction')\n data.append(vtk.vtkDoubleArray())\n data[1].SetName('SolidVolumeVelocity')\n data[1].SetNumberOfComponents(3)\n data.append(vtk.vtkDoubleArray())\n data[2].SetName('GranularTemperature')\n data.append(vtk.vtkDoubleArray())\n data[3].SetName('SolidPressure')\n data.append(vtk.vtkDoubleArray())\n data[4].SetName('SolidPressureGradient')\n data[4].SetNumberOfComponents(3)\n\n for _ in range(poly_data.GetNumberOfPoints()):\n data[0].InsertNextValue(volume[_])\n data[1].InsertNextTuple3(*velocity[_])\n data[2].InsertNextValue(temperature[_])\n data[3].InsertNextValue(solid_pressure[_])\n data[4].InsertNextTuple3(*solid_pressure_gradient[_])\n\n for _ in data:\n poly_data.GetPointData().AddArray(_)\n\n return data[4]","def test_survival_prob():\n t_start = time()\n from pisa.core.binning import OneDimBinning\n\n absorption_length = 1 # m\n n_photons = int(1e6)\n speed_of_light = SPEED_OF_LIGHT_IN_VACUUM #/ 1.5 # m/s\n dom_radius = DOM_RADIUS\n dom_efficiency = 1\n seed = 0\n\n r_binning = OneDimBinning(\n name='r',\n domain=(0, 25),\n is_lin=True,\n num_bins=25,\n units='m'\n )\n phi_binning = OneDimBinning(\n name='phi',\n tex=r'\\phi',\n domain=(0, 2*np.pi),\n is_lin=True,\n num_bins=32,\n units='rad'\n )\n t_binning = OneDimBinning(\n name='time',\n domain=(0, 100),\n is_lin=True,\n num_bins=10,\n units='ns'\n )\n phidir_binning = OneDimBinning(\n name='phidir',\n tex=r'\\phi_{\\rm dir}',\n domain=(0, 2*np.pi),\n is_lin=True,\n num_bins=96,\n units='rad'\n )\n binning = r_binning * phi_binning * t_binning * phidir_binning\n\n for r_idx in range(binning.r.num_bins):\n # Pick a bin that will have non-zero entries\n out_binning, _ = pick_nonzero_bin(\n binning=binning,\n r_idx=r_idx,\n phi_idx=0,\n dom_radius=dom_radius,\n speed_of_light=speed_of_light\n )\n #print('indices of bin0 in table:', indices0)\n #print('bin0:\\n{}'.format(bin0))\n\n #indices0 = np.array(indices0)\n\n #r0_idx, phi0_idx, t0_idx, phidir0_idx = indices0\n\n # Get probs for nominal r and t bins +/- 2 bins away\n #r_slice = slice(r0_idx - 2, r0_idx + 3)\n #t_slice = slice(t0_idx - 2, t0_idx + 3)\n #r_slice = slice(None)\n #t_slice = slice(None)\n #out_binning = binning[r_slice, phi0_idx, t_slice, phidir0_idx + 2]\n\n survival_probs = out_binning.empty(name='survival_prob')\n geom_norms = out_binning.empty(name='geom_norm')\n for bin_flat_idx, this_bin in enumerate(out_binning.iterbins()):\n prob, num_hits = forward_survival_prob(\n absorption_length=absorption_length,\n binning=this_bin,\n n_photons=n_photons,\n dom_efficiency=dom_efficiency,\n dom_radius=dom_radius,\n speed_of_light=speed_of_light,\n seed=seed\n )\n #print('')\n survival_probs[out_binning.index2coord(bin_flat_idx)] = prob\n geom_norms[out_binning.index2coord(bin_flat_idx)] = num_hits / n_photons\n\n print('Total time to run:', time() - t_start)\n\n return survival_probs, geom_norms, binning","def prosody_dynamic(self, audio):\n fs, data_audio = read(audio)\n\n if len(data_audio.shape)>1:\n data_audio = data_audio.mean(1)\n data_audio = data_audio-np.mean(data_audio)\n data_audio = data_audio/float(np.max(np.abs(data_audio)))\n size_frameS = self.size_frame*float(fs)\n size_stepS = self.step*float(fs)\n overlap = size_stepS/size_frameS\n\n if self.pitch_method == 'praat':\n name_audio = audio.split('/')\n temp_uuid = 'prosody'+name_audio[-1][0:-4]\n if not os.path.exists(PATH+'/../tempfiles/'):\n os.makedirs(PATH+'/../tempfiles/')\n temp_filename_f0 = PATH+'/../tempfiles/tempF0'+temp_uuid+'.txt'\n temp_filename_vuv = PATH+'/../tempfiles/tempVUV'+temp_uuid+'.txt'\n praat_functions.praat_vuv(audio, temp_filename_f0, temp_filename_vuv,\n time_stepF0=self.step, minf0=self.minf0, maxf0=self.maxf0)\n\n F0, _ = praat_functions.decodeF0(\n temp_filename_f0, len(data_audio)/float(fs), self.step)\n os.remove(temp_filename_f0)\n os.remove(temp_filename_vuv)\n elif self.pitch_method == 'rapt':\n data_audiof = np.asarray(data_audio*(2**15), dtype=np.float32)\n F0 = pysptk.sptk.rapt(data_audiof, fs, int(\n size_stepS), min=self.minf0, max=self.maxf0, voice_bias=self.voice_bias, otype='f0')\n\n pitchON = np.where(F0 != 0)[0]\n dchange = np.diff(pitchON)\n change = np.where(dchange > 1)[0]\n iniV = pitchON[0]\n\n featvec = []\n iniVoiced = (pitchON[0]*size_stepS)+size_stepS\n seg_voiced = []\n f0v = []\n Ev = []\n for indx in change:\n finV = pitchON[indx]+1\n finVoiced = (pitchON[indx]*size_stepS)+size_stepS\n VoicedSeg = data_audio[int(iniVoiced):int(finVoiced)]\n temp = F0[iniV:finV]\n tempvec = []\n if len(VoicedSeg) > int(size_frameS):\n seg_voiced.append(VoicedSeg)\n dur = len(VoicedSeg)/float(fs)\n x = np.arange(0,len(temp))\n z = np.poly1d(np.polyfit(x,temp,self.P))\n f0v.append(temp)\n tempvec.extend(z.coeffs)\n temp=get_energy_segment(size_frameS, size_stepS, VoicedSeg, overlap)\n Ev.append(temp)\n x = np.arange(0, len(temp))\n z = np.poly1d(np.polyfit(x, temp, self.P))\n tempvec.extend(z.coeffs)\n tempvec.append(dur)\n featvec.append(tempvec)\n iniV = pitchON[indx+1]\n iniVoiced = (pitchON[indx+1]*size_stepS)+size_stepS\n\n # Add the last voiced segment\n finV = (pitchON[len(pitchON)-1])\n finVoiced = (pitchON[len(pitchON)-1]*size_stepS)+size_stepS\n VoicedSeg = data_audio[int(iniVoiced):int(finVoiced)]\n temp = F0[iniV:finV]\n tempvec = []\n\n if len(VoicedSeg) > int(size_frameS):\n # Compute duration\n dur = len(VoicedSeg)/float(fs)\n \n x = np.arange(0, len(temp))\n z = np.poly1d(np.polyfit(x, temp, self.P))\n tempvec.extend(z.coeffs)\n # Energy coefficients\n temp=get_energy_segment(size_frameS, size_stepS, VoicedSeg, overlap)\n x = np.arange(0, len(temp))\n z = np.poly1d(np.polyfit(x, temp, self.P))\n tempvec.extend(z.coeffs)\n tempvec.append(dur)\n # Compute duration\n featvec.append(tempvec)\n\n return np.asarray(featvec)","def beam_property_along_s(ps, id_slices):\n\n prop_s = np.zeros((14, len(id_slices)))\n for n in range(len(id_slices)):\n ps_s = np.take(ps, id_slices[n], axis=1)\n prop_s[0, n] = np.average(ps_s[0,:])\n prop_s[1, n] = np.average(ps_s[1,:])\n prop_s[2, n] = np.average(ps_s[2,:])\n prop_s[3, n] = np.average(ps_s[3,:])\n prop_s[4, n] = np.std(ps_s[0,:])\n prop_s[5, n] = np.std(ps_s[2,:])\n prop_s[6:, n] = emittance_and_twiss(ps_s)\n\n return prop_s","def single_pulse_SCPI(pulsewidth, updown, high_voltage, low_voltage, channel = '1', *args, **kwargs):\n\tif pulsewidth[-2:] not in set({'ns', 'us', 'ms',}):\n\t\tif pulsewidth[-1] != 's':\n\t\t\traise ValueError('pulsewidth ' + str(pulsewidth) + ' not supported')\n\tif updown not in set({'up', 'down'}):\n\t\traise ValueError('updown ' + str(updown) + ' not supported')\n\tif high_voltage[-2:].lower() not in set({'mv'}):\n\t\tif high_voltage[-1].lower() != 'v':\n\t\t\traise ValueError('high_voltage ' + str(high_voltage) + ' not supported')\n\tif low_voltage[-2:].lower() not in set({'mv'}):\n\t\tif low_voltage[-1].lower() != 'v':\n\t\t\traise ValueError('low_voltage ' + str(low_voltage) + ' not supported')\n\tif channel not in set({'1', '2'}):\n\t\traise ValueError('channel ' + str(channel) + ' not supported')\n\t\n\tif updown == 'up':\n\t\tout = 'outp'+channel+':puls:mode sin;'\n\t\tout += ':sour'+channel+':inv off;'\n\t\tout += ':sour'+channel+':volt:lev:imm:high '+high_voltage + ';'\n\t\tout += ':sour'+channel+':volt:lev:imm:low '+low_voltage + ';'\n\t\t#puls1 means the first pulse because we are in single mode\n\t\tout += ':sour'+channel+':puls1:wid '+pulsewidth + ';'\n\t\treturn out\n\telse:\n\t\tout = 'outp'+channel+':puls:mode sin;'\n\t\tout += ':sour'+channel+':inv on;'\n\t\tout += ':sour'+channel+':volt:lev:imm:low '+low_voltage + ';'\n\t\tout += ':sour'+channel+':volt:lev:imm:high '+high_voltage + ';'\n\t\t#puls1 means the first pulse because we are in single mode\n\t\tout += ':sour'+channel+':puls1:wid '+pulsewidth + ';'\n\t\treturn out","def gen_pulsed_stimulus(T, dt, odor_idx, pulse_duration=(0.1, 0.5), n_stim=1):\n # randomly sample pulse duration\n pulses = np.random.uniform(pulse_duration[0], pulse_duration[1], size=100)\n pulse_bins = (pulses / dt).astype(np.int).tolist()\n random.shuffle(pulse_bins)\n X = np.zeros((n_stim, int(T / dt)))\n\n # randomly position pulse - use poisson to have more variability in positioning\n n_bins = int(T / dt)\n spaced_pulses = [[1] * pulse_bins[0]]\n start_bins = np.random.randint(0, n_bins-int(0.1/dt), size=200).astype(np.int).tolist()\n #start_bins = (np.random.poisson(int(T * 100), size=10) / 100 / dt).astype(np.int)\n #print(\"start_bins: {}\".format(start_bins))\n start_bins = list(filter(lambda p: (p+pulse_bins[0]) < (n_bins-5), start_bins))\n random.shuffle(start_bins)\n #print(\"start_bins: {} | {} sec\".format(start_bins, np.array(start_bins)*dt))\n start_bin = start_bins[0]\n print(\"pulse offset: {}sec | duration: {}sec\".format(start_bin * dt, pulse_bins[0] * dt))\n\n pulse_times = [[] for _ in range(n_stim)]\n for k, s in enumerate(spaced_pulses):\n X[odor_idx, start_bin:start_bin + len(s)] = s\n pulse_times[odor_idx].append(start_bin * dt)\n\n X_prime = np.c_[np.zeros((n_stim, 1)), X]\n return X, [len(np.where(np.diff(X_prime[n, :]) == 1)[0]) for n in range(n_stim)], pulse_times","def pulses_to_mps(pulses, period=10):\n return pulses / (period * 4) # there are 4 pulses per rotation of the annemometer","def ohms(self):\n # Rwb = Rwiper + Rtotal * (counts / 256)\n # Rwa = Rwiper + Rtotal * ((256 - counts) / 256)\n g = 0\n rtotal=0.0\n reach=[]\n for chan in self.get_channel_list(self.nchans):\n self.rwa[chan] = float( 256 - self.vals[chan] ) / 256.0\n self.rwb[chan] = float( self.vals[chan] ) / 256.0\n self.rwa[chan] *= self.Rtotal\n self.rwb[chan] *= self.Rtotal \n self.rwa[chan] += self.Rwiper\n self.rwb[chan] += self.Rwiper","def getCalibration(self):\n self.a0 = float(self.getParameter(index=1))\n self.a1 = float(self.getParameter(index=2))\n self.a2 = float(self.getParameter(index=3))\n self.a3 = float(self.getParameter(index=4))\n status = self.getStatus()\n self.wavelength = [ self.a0 + self.a1*x + self.a2*x*x + self.a3*x*x*x \n for x in range(status.pixels)]\n if self.discardTrailingSamples > 0:\n self.wavelength = self.wavelength[:-self.discardTrailingSamples]\n if self.discardLeadingSamples > 0:\n self.wavelength = self.wavelength[self.discardLeadingSamples:]","def delay(self):\r\n p_shape = self.phase.shape[:-1]\r\n delay = np.zeros(self.phase.shape)\r\n for i in range(p_shape[0]):\r\n for j in range(p_shape[1]):\r\n this_phase = self.phase[i, j]\r\n #If requested, unwrap the phases:\r\n if self._unwrap_phases:\r\n this_phase = tsu.unwrap_phases(this_phase)\r\n\r\n delay[i, j] = this_phase / (2 * np.pi * self.frequencies)\r\n\r\n return delay","def read(self):\n interval = self._low_ticks + self._high_ticks\n\n if interval > 0:\n ratio = float(self._low_ticks)/float(interval)*100.0\n conc = 1.1*pow(ratio,3)-3.8*pow(ratio,2)+520*ratio+0.62;\n else:\n ratio = 0\n conc = 0.0\n\n self._start_tick = None\n self._last_tick = None\n self._low_ticks = 0\n self._high_ticks = 0\n\n return (self.gpio, ratio, conc)","def test_str_pulse(self):\n xknx = XKNX()\n sensor = Sensor(\n xknx, \"TestSensor\", group_address_state=\"1/2/3\", value_type=\"pulse\"\n )\n sensor.sensor_value.payload = DPTArray((0xFC,))\n\n self.assertEqual(sensor.resolve_state(), 252)\n self.assertEqual(sensor.unit_of_measurement(), \"counter pulses\")\n self.assertEqual(sensor.ha_device_class(), None)","def __getPressureCalibrationCoefficients(self):\n src13 = self.read_byte_data(self.address, 0x13)\n src14 = self.read_byte_data(self.address, 0x14)\n src15 = self.read_byte_data(self.address, 0x15)\n src16 = self.read_byte_data(self.address, 0x16)\n src17 = self.read_byte_data(self.address, 0x17)\n src18 = self.read_byte_data(self.address, 0x18)\n src19 = self.read_byte_data(self.address, 0x19)\n src1A = self.read_byte_data(self.address, 0x1A)\n src1B = self.read_byte_data(self.address, 0x1B)\n src1C = self.read_byte_data(self.address, 0x1C)\n src1D = self.read_byte_data(self.address, 0x1D)\n src1E = self.read_byte_data(self.address, 0x1E)\n src1F = self.read_byte_data(self.address, 0x1F)\n src20 = self.read_byte_data(self.address, 0x20)\n src21 = self.read_byte_data(self.address, 0x21)\n c00 = (src13 << 12) | (src14 << 4) | (src15 >> 4)\n c00 = getTwosComplement(c00, 20)\n c10 = ((src15 & 0x0F) << 16) | (src16 << 8) | src17\n c10 = getTwosComplement(c10, 20)\n c20 = (src1C << 8) | src1D\n c20 = getTwosComplement(c20, 16)\n c30 = (src20 << 8) | src21\n c30 = getTwosComplement(c30, 16)\n c01 = (src18 << 8) | src19\n c01 = getTwosComplement(c01, 16)\n c11 = (src1A << 8) | src1B\n c11 = getTwosComplement(c11, 16)\n c21 = (src1E < 8) | src1F\n c21 = getTwosComplement(c21, 16)\n return c00, c10, c20, c30, c01, c11, c21","def pulse_width_percent(self, value: int | float, /) -> None:","def time_function(self, t):\n\n\tif type(t) == float:\n\t if t > self.pulse_duration:\n\t\tfield_strength = 0.0\n\t else:\n\t\tfield_strength = (self.amplitude * \n\t\t sin(pi * t / self.pulse_duration)**2 * \n\t\t cos(self.omega * t))\n\telse:\n\t field_strength = zeros(shape(t))\n\t for i, time in enumerate(t):\n\t\tif time > self.pulse_duration:\n\t\t temp_field_strength = 0.0\n\t\telse:\n\t\t temp_field_strength = (self.amplitude * \n\t\t\tsin(pi * time / self.pulse_duration)**2 * \n\t\t\tcos(self.omega * time))\n\n\t\tfield_strength[i] = temp_field_strength\n\t\n\treturn field_strength","def calc(self,index, counter_values):\n try:\n angles = self.ik220_dev.read_attribute('Angles').value\n if index == 9:\n return sum(angles[:3])/3.0 # Excluded channel 4 of grating pitch encoder because of problems of Homing in the last header of the RON grating encoder.\n elif index == 10:\n return sum(angles[4:6])/2.0 # Modified from 4 channels to 2 channels because of problems of Homing in the 2 last headers of the RON mirror3 encoder.\n else:\n return angles[index - 1]\n except:\n return 1e-100","def _pulse_enable(self):\n self.set_low(self._en_pin)\n self._usleep(1)\n self.set_high(self._en_pin)\n self._usleep(1)\n self.set_low(self._en_pin)\n # commands need > 37us to settle\n self._usleep(100)","def raw_measure(self) -> List[int]:\n # name, command, signals, delay\n return self._run_profile((\"raw_measure\", [0x20, 0x50], 2, 0.025))","def get_chisqrs(prf,diff,nbins): \n off_pulse = np.zeros(39)\n off_pulse[:20] = prf[:20]\n off_pulse[20:] = prf[45:] #Making off pulse region\n # print(\"Off pulse Region \",off_pulse)\n op_rms = np.var(off_pulse) #Rms\n # print(\"Off pulse RMS \",op_rms)\n s = 0\n for d in diff:\n s += d**2/op_rms\n\n s = s/(nbins - 1)\n # print(\"Chisqr value = \",s)\n\n return s","def calibration(self) -> int:","def setInternalPulser(self,pulserEnable,pulseHeight):\n pass","def test_noisy_pulse(self):\n coeff = np.array([0.1, 0.2, 0.3, 0.4])\n tlist = np.array([0., 1., 2., 3.])\n ham = sigmaz()\n pulse1 = Pulse(ham, 1, tlist, coeff)\n # Add coherent noise and lindblad noise with different tlist\n pulse1.spline_kind = \"step_func\"\n tlist_noise = np.array([0., 1., 2.5, 3.])\n coeff_noise = np.array([0., 0.5, 0.1, 0.5])\n pulse1.add_coherent_noise(sigmay(), 0, tlist_noise, coeff_noise)\n tlist_noise2 = np.array([0., 0.5, 2, 3.])\n coeff_noise2 = np.array([0., 0.1, 0.2, 0.3])\n pulse1.add_lindblad_noise(sigmax(), 1, coeff=True)\n pulse1.add_lindblad_noise(\n sigmax(), 0, tlist=tlist_noise2, coeff=coeff_noise2)\n\n assert_allclose(\n pulse1.get_ideal_qobjevo(2)(0).full(),\n tensor(identity(2), sigmaz()).full() * 0.1)\n noise_qu, c_ops = pulse1.get_noisy_qobjevo(2)\n assert_allclose(\n pulse1.get_full_tlist(), np.array([0., 0.5, 1., 2., 2.5, 3.]))\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\n expected = QobjEvo([\n [tensor(identity(2), sigmaz()),\n np.array([0.1, 0.1, 0.2, 0.3, 0.3, 0.4])],\n [tensor(sigmay(), identity(2)),\n np.array([0., 0., 0.5, 0.5, 0.1, 0.5])]\n ],\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\n order=0)\n else:\n expected = QobjEvo([\n [tensor(identity(2), sigmaz()),\n np.array([0.1, 0.1, 0.2, 0.3, 0.3, 0.4])],\n [tensor(sigmay(), identity(2)),\n np.array([0., 0., 0.5, 0.5, 0.1, 0.5])]\n ],\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\n args={\"_step_func_coeff\": True})\n _compare_qobjevo(noise_qu, expected, 0, 3)\n\n for c_op in c_ops:\n try:\n isconstant = c_op.isconstant\n except AttributeError:\n isconstant = (len(c_op.ops) == 0)\n if isconstant:\n assert_allclose(c_op(0).full(),\n tensor(identity(2), sigmax()).full())\n else:\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\n expected = QobjEvo(\n [tensor(sigmax(), identity(2)),\n np.array([0., 0.1, 0.1, 0.2, 0.2, 0.3])],\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\n order=0)\n else:\n expected = QobjEvo(\n [tensor(sigmax(), identity(2)),\n np.array([0., 0.1, 0.1, 0.2, 0.2, 0.3])],\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\n args={\"_step_func_coeff\": True})\n _compare_qobjevo(c_op, expected, 0, 3)","def test_pressure_increasing_check_all_pass(mocker, pressure_values):\n profile = mocker.patch.object(argortqcpy.profile, \"Profile\")\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\n\n pic = PressureIncreasingCheck(profile, None)\n output = pic.run()\n\n assert np.all(output.get_output_flags_for_property(\"PRES\").data == ArgoQcFlag.GOOD.value)","def _calc(self):\r\n tot_sum: float = 0 # ? total sum of the noise values\r\n max_amp: float = 0 # ? keep the sum in [0,1]\r\n amp: float = 1.0 # ? amplitude of each noise value\r\n freq: float = 1.0 # ? frequency for getting the detailed noise\r\n\r\n # for each octave we twice the frequency and multiply the amplitude \r\n # by persistance to get the detailed noise value\r\n # to keep the final sum value in the range [0, 1] we keep track of the \r\n # max amplitude (sum of all the amplitudes)\r\n for octave in range(self.octaves):\r\n noise_obj = PerlinNoise(self.inp_x*freq, self.inp_y*freq, self.inp_z*freq)\r\n # ? multiply the noise value by the amplitude\r\n tot_sum += noise_obj.val() * amp\r\n max_amp += amp\r\n\r\n amp *= self.persist\r\n freq *= 2.0 # double the freq each iteration\r\n\r\n # value is in the range [0,1]\r\n self.value = tot_sum / max_amp","def initialize_2pulse(pg, channel = '1', pulsewidth = '10e-9', delay = '10e-9',\n\t\t\t\t\t low_voltage = '0', high_voltage = '4.8'):\n\terr = ''\n\twhile err != 'Error: 0, No error\\n':#clear errors\n\t\terr = pg.query('syst:err:next?')\n\n\tpgchannel = channel\n\tpw = pulsewidth\n\n\tdelay1 = str(float(pw) + float(delay))\n\tdelay2 = str(float(delay1)*2)\n\tpg.write('outp'+pgchannel+':puls:mode dou')\n\tpg.write('source'+pgchannel+':pulse1:wid '+pw)\n\tpg.write('source'+pgchannel+':pulse2:wid '+pw)\n\n\tpg.write('source'+pgchannel+':pulse1:del '+'0')\n\tpg.write('source'+pgchannel+':pulse2:del '+delay1)\n\n\tpg.write('source'+pgchannel+':volt:lev:imm:low '+low_voltage)\n\tpg.write('source'+pgchannel+':volt:lev:imm:high '+high_voltage)\n\tpg.write('trig:seq:sour man')\n\tpg.write('outp'+pgchannel+':stat on')\n\tpg.write('PULSEGENControl:START')\n\tif pg.query('syst:err:next?') != 'Error: 0, No error\\n':\n\t\tstop(pg,)\n\t\traise ValueError('error in initialize_2pulse init')\n\t\t\n\treturn","def __init__(\n self,\n acquire_alignment: int = 1,\n pulse_alignment: int = 1,\n ):\n super().__init__()\n self.acquire_align = acquire_alignment\n self.pulse_align = pulse_alignment","def generatePulseSequence(ham: Dict[str, Any], name: Union[str, List[str]]) -> List[float]:\n\n assert isinstance(name, str), \"In generatePulseSequence, para `names` only accepts str.\"\n\n dt = ham[\"circuit\"][\"dt\"]\n maxDt = ham[\"circuit\"][\"max_time_dt\"]\n\n ctrls = ham[\"control\"][name]\n sequenceList = []\n # Traverse all the time slices.\n for nowDt in range(0, maxDt):\n currentAmp = 0\n nowNs = nowDt * dt + dt / 2\n # Traverse all the waveforms\n for waveForm in ctrls[\"waveforms\"]:\n insertNs = waveForm[\"insert_ns\"]\n endNs = waveForm[\"insert_ns\"] + waveForm[\"duration_ns\"]\n if insertNs <= nowNs < endNs:\n # Calculate the waveforms' amplitudes.\n waveFunc = waveForm[\"func\"]\n if waveFunc is None:\n seq = waveForm[\"sequence\"]\n realTime = nowNs - waveForm[\"insert_ns\"]\n if int(realTime / dt) >= len(seq):\n currentAmp += seq[-1]\n else:\n currentAmp += seq[int(realTime / dt)]\n elif isinstance(waveFunc, str):\n currentAmp += play(waveForm[\"func\"], nowNs - waveForm[\"insert_ns\"], waveForm[\"para\"])\n elif callable(waveFunc):\n currentAmp += waveFunc(nowNs - waveForm[\"insert_ns\"], waveForm[\"para\"])\n else:\n assert False, \"Unsupported type of func.\"\n sequenceList.append(currentAmp)\n\n return sequenceList","def __init__(self):\n self.risepower = 4.\n self.min_event_amplitude = 5.0e-12 # pA default\n self.template = None\n pass","def get_prop(self):\n\t\tnewframe = copy.deepcopy(self)\n\t\tfor f in newframe.header[1:]:\n\t\t\tsum = newframe.sum_field(f)\n\t\t\tfor d in newframe:\n\t\t\t\ttry:\n\t\t\t\t\td[f]= d[f]/float(sum)*100\n\t\t\t\texcept ZeroDivisionError:\n\t\t\t\t\td[f] = 0\n\t\t\n\t\treturn newframe","def rectpulse(L, fsT, normalize = True):\n u = np.ones(L * fsT, dtype='float')\n\n # Normalize so that the integral of the pulse is 1/2 max\n if normalize:\n u = u / (2.0 * np.sum(u))\n \n return u","def hasPulse(self):\n return True if self.pulses is not None else False","def amaoccupancyscore(pwm_dictionary, seq):\n if \"N\" in seq:\n return 0\n else:\n # pwm_length = len(pwm_dictionary)\n pwm_length = len(pwm_dictionary[\"A\"])\n occupancy_list = []\n pwm_dictionary_rc = rc_pwm(pwm_dictionary, pwm_length)\n for i in range(len(seq) - 1):\n occupancy = 1\n occupancy_rc = 1\n for j in range(pwm_length - 1):\n if (j + i) >= len(seq):\n occupancy *= 0.25\n occupancy_rc *= 0.25\n else:\n occupancy *= pwm_dictionary[seq[j + i]][j]\n occupancy_rc *= pwm_dictionary_rc[seq[j + i]][j]\n occupancy_list.append(occupancy + occupancy_rc)\n ama_occupancy = sum(occupancy_list) / len(occupancy_list)\n return ama_occupancy","def calculate_averaged_properties_cpp(poly_data):\n\n gt_filter = vtkParticlesPython.vtkGranularTemperature()\n if vtk.vtkVersion.GetVTKMajorVersion() < 6:\n gt_filter.SetInput(poly_data)\n else:\n gt_filter.SetInputData(poly_data)\n gt_filter.Update()\n poly_data.DeepCopy(gt_filter.GetOutput())\n\n return numpy_support.vtk_to_numpy(poly_data.GetPointData().GetVectors(\"SolidPressureGradient\"))","def measure_state(self, pulse, out1, out2, res, adc=None):\n bias = self.saved_data[\"bias\"]\n # currently it allows only 3 states\n\n d1_st0 = declare(fixed)\n d2_st0 = declare(fixed)\n d1_st1 = declare(fixed)\n d2_st1 = declare(fixed)\n d1_st2 = declare(fixed)\n d2_st2 = declare(fixed)\n\n st0 = declare(fixed)\n st1 = declare(fixed)\n st2 = declare(fixed)\n\n measure(\n pulse,\n self.rr_qe,\n adc,\n demod.full(f\"state_0_in1_{self.rr_qe}\", d1_st0, out1),\n demod.full(f\"state_0_in2_{self.rr_qe}\", d2_st0, out2),\n demod.full(f\"state_1_in1_{self.rr_qe}\", d1_st1, out1),\n demod.full(f\"state_1_in2_{self.rr_qe}\", d2_st1, out2),\n demod.full(f\"state_2_in1_{self.rr_qe}\", d1_st2, out1),\n demod.full(f\"state_2_in2_{self.rr_qe}\", d2_st2, out2),\n )\n\n assign(st0, d1_st0 + d2_st0 - bias[0])\n assign(st1, d1_st1 + d2_st1 - bias[1])\n assign(st2, d1_st2 + d2_st2 - bias[2])\n\n with if_((st0 >= st1) & (st0 >= st2)):\n assign(res, 0)\n with if_((st1 >= st0) & (st1 >= st2)):\n assign(res, 1)\n with if_((st2 >= st0) & (st2 >= st1)):\n assign(res, 2)","def read_particle_measurement(self):\n self.port.write(self.READ_PM_RESULTS)\n result = bytearray(self.port.read(8))\n if not result:\n # Timeout\n return None\n if len(result) != 8:\n # Sometimes not enough results are returned\n logger.error(\"Didn't get enough data back\")\n return None\n head, length, cmd, df1, df2, df3, df4, cs = result\n assert self.is_checksum_valid(result)\n return 256*df1 + df2, 256*df3 + df4","def pressure_ashpa(self):\n hpa = None # Variable declaration\n raw_comp1 = None # Variable declaration\n raw_comp2 = None # Variable declaration\n raw_comp3 = None # Variable declaration\n raw_pressure = None # Variable declaration\n raw_temperature = None # Variable declaration\n value_d_p1 = None # Variable declaration\n value_d_p2 = None # Variable declaration\n value_d_p3 = None # Variable declaration\n value_d_p4 = None # Variable declaration\n value_d_p5 = None # Variable declaration\n value_d_p6 = None # Variable declaration\n value_d_p7 = None # Variable declaration\n value_d_p8 = None # Variable declaration\n value_d_p9 = None # Variable declaration\n value_lsb = None # Variable declaration\n value_msb = None # Variable declaration\n value_xlsb = None # Variable declaration\n\n value_msb = self.get_pressuremsb()\n value_lsb = self.get_pressurelsb()\n value_xlsb = self.get_pressurexlsb()\n value_d_p1 = self.get_digp1()\n value_d_p2 = self.get_digp2()\n value_d_p3 = self.get_digp3()\n value_d_p4 = self.get_digp4()\n value_d_p5 = self.get_digp5()\n value_d_p6 = self.get_digp6()\n value_d_p7 = self.get_digp7()\n value_d_p8 = self.get_digp8()\n value_d_p9 = self.get_digp9()\n raw_temperature = self.temperature_ascelsius()\n raw_temperature = (raw_temperature*5120.0)\n raw_pressure = ((value_msb << 12)+(value_lsb << 4)+(value_xlsb >> 4))\n raw_comp1 = ((raw_temperature/2)-64000.0)\n raw_comp2 = ((raw_comp1*raw_comp1*value_d_p6)/32768.0)\n raw_comp2 = (raw_comp2+(raw_comp1*value_d_p5*2.0))\n raw_comp2 = ((raw_comp2/4.0)+(value_d_p4*65536.0))\n raw_comp3 = (value_d_p3*raw_comp1*raw_comp1)\n raw_comp1 = (((raw_comp3/524288.0)+(value_d_p2*raw_comp1))/524288.0)\n raw_comp1 = ((1.0+(raw_comp1/32768.0))*value_d_p1)\n hpa = (1048576.0-raw_pressure)\n hpa = ((hpa-(raw_comp2/4096.0))*(6250.0/raw_comp1))\n raw_comp1 = ((value_d_p9*hpa*hpa)/2147483648.0)\n raw_comp2 = ((hpa*value_d_p8)/32768.0)\n hpa = (hpa+((raw_comp1+raw_comp2+value_d_p7)/16.0))\n hpa = (hpa/100.0)\n return hpa","def _concatenate_pulses(\n self, pulse_instructions, scheduled_start_time, num_controls\n ):\n min_step_size = np.inf\n # Concatenate tlist and coeffs for each control pulses\n compiled_tlist = [[] for tmp in range(num_controls)]\n compiled_coeffs = [[] for tmp in range(num_controls)]\n for pulse_ind in range(num_controls):\n last_pulse_time = 0.0\n for start_time, tlist, coeff in pulse_instructions[pulse_ind]:\n # compute the gate time, step size and coeffs\n # according to different pulse mode\n (\n gate_tlist,\n coeffs,\n step_size,\n pulse_mode,\n ) = self._process_gate_pulse(start_time, tlist, coeff)\n min_step_size = min(step_size, min_step_size)\n\n if abs(last_pulse_time) < step_size * 1.0e-6: # if first pulse\n compiled_tlist[pulse_ind].append([0.0])\n if pulse_mode == \"continuous\":\n compiled_coeffs[pulse_ind].append([0.0])\n # for discrete pulse len(coeffs) = len(tlist) - 1\n\n # If there is idling time between the last pulse and\n # the current one, we need to add zeros in between.\n if np.abs(start_time - last_pulse_time) > step_size * 1.0e-6:\n idling_tlist = self._process_idling_tlist(\n pulse_mode, start_time, last_pulse_time, step_size\n )\n compiled_tlist[pulse_ind].append(idling_tlist)\n compiled_coeffs[pulse_ind].append(\n np.zeros(len(idling_tlist))\n )\n\n # Add the gate time and coeffs to the list.\n execution_time = gate_tlist + start_time\n last_pulse_time = execution_time[-1]\n compiled_tlist[pulse_ind].append(execution_time)\n compiled_coeffs[pulse_ind].append(coeffs)\n\n final_time = np.max([tlist[-1][-1] for tlist in compiled_tlist])\n for pulse_ind in range(num_controls):\n if not compiled_tlist[pulse_ind]:\n continue\n last_pulse_time = compiled_tlist[pulse_ind][-1][-1]\n if np.abs(final_time - last_pulse_time) > min_step_size * 1.0e-6:\n idling_tlist = self._process_idling_tlist(\n pulse_mode, final_time, last_pulse_time, min_step_size\n )\n compiled_tlist[pulse_ind].append(idling_tlist)\n compiled_coeffs[pulse_ind].append(np.zeros(len(idling_tlist)))\n\n for i in range(num_controls):\n if not compiled_coeffs[i]:\n compiled_tlist[i] = None\n compiled_coeffs[i] = None\n else:\n compiled_tlist[i] = np.concatenate(compiled_tlist[i])\n compiled_coeffs[i] = np.concatenate(compiled_coeffs[i])\n return compiled_tlist, compiled_coeffs","def enable_pulse_modulation(self):\n self.write(\":SOUR:PULM:STAT ON\")","def __init__(self, name=\"untitled\", pulseGenerator=None, start1=0, stop1=10000, start2=None, stop2=None):\n self.name = name\n self._pulseGenerator = pulseGenerator\n self._numberOfPoints = self._pulseGenerator.numberOfPoints()\n self._samplingTime = self._pulseGenerator.samplingTime()\n self._shape1 = numpy.zeros(self._numberOfPoints)\n self._shape2 = numpy.zeros(self._numberOfPoints)\n self._shape1[:] = getattr(generatorFunctionLib, 'square')(\n self._numberOfPoints, self._samplingTime, start1, stop1, amplitude=1)\n if start2 is None:\n start2 = start1\n if stop2 is None:\n stop2 = stop1\n self._shape2[:] = getattr(generatorFunctionLib, 'square')(\n self._numberOfPoints, self._samplingTime, start2, stop2, amplitude=2)\n self.markerArray = [sum(i)for i in zip(self._shape1, self._shape2)]","def events(self):\n\n events = []\n # Update the totals\n self.update_totals()\n\n # Replication - total number of bacteria of metabolism * prob of replication\n events.append((self.total_f * self.rates[P_REPLICATE_FAST], lambda f: self.replicate(BACTERIA_FAST)))\n events.append((self.total_s * self.rates[P_REPLICATE_SLOW], lambda f: self.replicate(BACTERIA_SLOW)))\n events.append((self.total_intra * self.rates[P_REPLICATE_INTRACELLULAR],\n lambda f: self.replicate(BACTERIA_INTRACELLULAR)))\n\n # Metabolism change - sum of (number of bacteria of metabolism in patch * o2 tension) * prob of change\n # TODO - check if this is ok\n events.append((self.total_f_o2 * self.rates[P_CHANGE_FAST_SLOW], lambda f: self.change(BACTERIA_SLOW)))\n events.append((self.total_s_o2 * self.rates[P_CHANGE_SLOW_FAST], lambda f: self.change(BACTERIA_FAST)))\n\n # Migrate - sum of (number of bacteria of metabolism in patch * degree of patch) * prob of migration\n events.append((self.total_f_degree * self.rates[P_MIGRATE_FAST], lambda f: self.migrate(BACTERIA_FAST)))\n events.append((self.total_s_degree * self.rates[P_MIGRATE_SLOW], lambda f: self.migrate(BACTERIA_SLOW)))\n\n # Recruit mac - num of nodes * prob of recruit\n events.append((len(self.nodes()) * self.rates[P_RECRUIT], lambda f: self.recruit_mac()))\n\n # Death of mac - total number of macs * prob of death\n events.append((self.total_mac_regular * self.rates[P_DEATH_REGULAR],\n lambda f: self.death_mac(MACROPHAGE_REGULAR)))\n events.append((self.total_mac_infected * self.rates[P_DEATH_INFECTED],\n lambda f: self.death_mac(MACROPHAGE_INFECTED)))\n\n # Mac ingest - sum of (number of bacteria of metabolism in patch * num of macrophages in patch) * prob of ingest\n events.append((self.total_regular_fast * self.rates[P_REGULAR_INGEST_FAST],\n lambda f: self.ingest(BACTERIA_FAST, MACROPHAGE_REGULAR)))\n events.append((self.total_regular_slow * self.rates[P_REGULAR_INGEST_SLOW],\n lambda f: self.ingest(BACTERIA_SLOW, MACROPHAGE_REGULAR)))\n events.append((self.total_infected_fast * self.rates[P_INFECTED_INGEST_FAST],\n lambda f: self.ingest(BACTERIA_FAST, MACROPHAGE_INFECTED)))\n events.append((self.total_infected_slow * self.rates[P_INFECTED_INGEST_SLOW],\n lambda f: self.ingest(BACTERIA_SLOW, MACROPHAGE_INFECTED)))\n\n # Activation\n events.append((self.total_activation * self.rates[P_ACTIVATION], lambda f: self.activate()))\n\n return events","def _get_speed(self):\n t_now = time.perf_counter()\n delta_t = t_now - self._t_last_count\n p = self._pulse\n if p: # if pulses > 0, reset counter and timer\n self._t_last_count = t_now\n self._pulse = 0\n else:\n return 0.0\n rps = (p / self._ppr) * delta_t # wheel rotations per second.\n mps = rps * self._wheel_circumference\n return mps","def read_raw(self):\n beats = self.microblaze.read_mailbox(0x4)\n interval_ms = self.microblaze.read_mailbox(0x8 + (beats % 4)*4)\n return beats, interval_ms","def set_pulse_width(self):\n\t\t\"\"\"For PWM Register-0\"\"\"\n\t\tbus.write_byte_data(PCA9530_2C_1_DEFAULT_ADDRESS, PCA9530_2C_1_REG_PWM0, PCA9530_2C_1_PWM0_USERDEFINED)\n\t\t\n\t\t\"\"\"For PWM Register-1\"\"\"\n\t\tbus.write_byte_data(PCA9530_2C_1_DEFAULT_ADDRESS, PCA9530_2C_1_REG_PWM1, PCA9530_2C_1_PWM1_USERDEFINED)","def pulses(waveform,template,tmax,thresh,deltat,tbef,tafter):\n print ' find pulses '\n wave = np.copy(waveform)\n ifig = 0\n\n tp = []\n ap = []\n plot = False\n lfront = int(np.argmax(template)) # length of template before the peak \n #lfront = 100\n lback = int(len(template) - lfront) # length of template after the peak\n \n ibeg = tbef + 0\n iend = tafter + 0\n \n while ibeg < iend:\n \n if plot:\n ifig += 1\n plt.figure(ifig)\n plt.plot(wave)\n \n wh = np.where(wave[ibeg:iend] > thresh)\n if len(wh[0])==0:\n break\n ith = int(wh[0][0] + ibeg)\n #print 'threshold crossing ', ith \n valmax = np.max(wave[ith:ith+deltat])\n #print wave[ith:ith+deltat]\n posmax = int(ith + np.argmax(wave[ith:ith+deltat]))\n tp.append(posmax)\n ap.append(valmax)\n #print 'pos ',posmax, ' value ',wave[posmax]\n if plot:\n ifig += 1\n print posmax,lfront,lback,ith,ith+deltat\n plt.figure(ifig)\n plt.plot(wave[posmax-lfront:posmax+lback])\n plt.plot(valmax*template)\n \n for i in range(min(len(template),len(wave)-posmax)):\n wave[posmax-lfront+i] += -valmax*template[i]\n \n ibeg += deltat\n if plot:\n plt.show()\n #print 'done pulses'\n \n return tp,ap","def pumpprobe_signal_test_build():\r\n inst.write(\"*RST\")\r\n #inst.write(\"DISP OFF\")\r\n inst.write(\":TRAC:CHAN1 ON\") # enables channel coupling at output 1\r\n inst.write(\":FUNC1 USER\") # set signal output to Arbitrary\r\n inst.write(\"FUNC1:USER p_short_1per\") # set Arbitrary waveform to pump pulse\r\n #inst.query(\"FUNC1:USER?\")\r\n #inst.write(\"FUNC1 USER\")\r\n #inst.write(\"FUNC1:USER 100KHZ, 0.1\") #FUNC can't seem to overwrite freq & amp settings\r\n \r\n inst.write(\":VOLT1 1\")\r\n inst.write(\":FREQ1 200KHZ\") \r\n \r\n inst.write(\":AM1:DEPT 100PCT\")\r\n inst.write(\":AM1:STAT ON\") #AM needs activation using STATus ON\r\n \r\n inst.write(\":AM1:SOUR EXT\") #sets source of AM\r\n \r\n \r\n inst.write(\"FUNC2:USER probe_2_12_p\")\r\n #inst.query(\"FUNC2:USER?\")\r\n inst.write(\":VOLT2 .1\")\r\n inst.write(\":FREQ2 200KHZ\")\r\n inst.write(\":AM2:DEPT 100PCT\")\r\n inst.write(\":AM2:STAT ON\")\r\n \r\n inst.write(\"CHAN:MATH plus\") #adds both channels at one output\r\n inst.write(\":OUTP1 ON\")","def PTS(self):","def v(self):\n\n # TODO This translation formula works, but needs simplified.\n\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\n# print(\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\", MuleBot.dcMotorPWMDurationLeft)\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\n# print(\"speed_percentage: \", speed_percentage)\n\n rpm = speed_percentage * self.motorMaxRPM\n# print(\"rpm: \", rpm)\n\n secondsPerMinute = 60\n revs_per_second = rpm / secondsPerMinute\n# print(\"--revs_per_second\", revs_per_second)\n\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\n INCHES_PER_METER = 39.3701\n meters_per_rev = inches_per_rev / INCHES_PER_METER\n# print(\"--meters_per_rev\", meters_per_rev)\n\n meters_per_second = meters_per_rev * revs_per_second\n\n# print(\"--meters_per_second: \", meters_per_second)\n return meters_per_second","def main(ms, field, use_astropy, calcweights, binwidth):\n\n parang = ParallacticAngle(ms=ms, use_astropy=use_astropy)\n\n if calcweights:\n weights, bins = parang.parang_weights(bin_width=binwidth)\n # Create fractional weights - this doesn't change anything in the averaging\n weights = weights/np.sum(weights)\n\n with open('parang_weights.txt', 'w') as fptr:\n fptr.write(\"#parang weight\\n\")\n for ww, bb in zip(weights, bins):\n fptr.write(\"%.2f % .2f\\n\" % (bb, ww))\n\n logger.info(f\"First parallactic angle is : {parang.parang_start:.2f}\")\n logger.info(f\"Middle parallactic angle is : {parang.parang_mid:.2f}\")\n logger.info(f\"Last parallactic angle is : {parang.parang_end:.2f}\")\n\n plt.style.use('seaborn-poster')\n\n fig, ax = plt.subplots(1, 1)\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n\n ax.plot(parang.source_times.to_datetime(), parang.parangs, 'o')\n fmt = DateFormatter('%Y-%m-%d %H:%M')\n ax.xaxis.set_major_formatter(fmt)\n ax.xaxis.set_tick_params(rotation=45)\n\n ax.set_xlabel('Date')\n ax.set_ylabel('Parallactic Angle (deg)')\n\n ms_basename = os.path.basename(ms).strip('.mms')\n ms_basename = os.path.basename(ms).strip('.ms')\n\n outname = f\"{ms_basename}_parallactic_angles.png\"\n plt.savefig(outname, bbox_inches='tight')","def properties(self):\n return {'u': {'name': 'streamwise velocity',\n 'range': self.u_range},\n 'uf': {'name': 'streamwise velocity',\n 'range': self.u_range},\n 'w': {'name': 'vertical velocity',\n 'range': self.w_range},\n 'wf': {'name': 'vertical velocity',\n 'range': self.w_range},\n 'uf_': {'name': 'mean streamwise velocity',\n 'range': self.u_range},\n 'wf_': {'name': 'mean vertical velocity',\n 'range': self.w_range},\n 'uf_abs': {'name': 'absolute velocity',\n 'range': self.u_abs_range},\n 'vorticity': {'name': 'vorticity',\n 'range': self.w_range},\n 'vertical_shear': {'name': 'vertical_shear',\n 'range': self.w_range}}","def __init__(self):\r\n # set up the class variables\r\n self.rangeTop = 85 # MIDI number of top note\r\n self.rangeBottom = 42 # MIDI number of bottom note\r\n self.currentUrlinie = []\r\n self.baseMotif = []\r\n self.workingMotif = []\r\n self.ULLength = 120 # this is the number of values in the UL vector - which is determined by the Urlinie generator\r\n self.ULPosition = 0 # index\r\n self.nextTargetNoteRelative = 0\r\n self.ULJump = 30\r\n self.ULBeatWait = 4\r\n self.ULBeatsToGo = 0\r\n self.MotifBeatsToGo = 0\r\n self.DBAffinity = 127\r\n self.IAffinity = 127\r\n self.swinging = False\r\n self.noteDensity = 63\r\n self.beatHeirarchy = 127\r\n self.heirarchyZero = 0 # extra weight given to the downbeat\r\n self.heirarchyOne = 0 # extra weight given to beat 3\r\n self.heirarchyThree = 0 # extra weight given to the off quavers\r\n self.scale = [0, 2, 4, 5, 7, 9, 11] # start with the Major/Ionian scale\r\n self.scaleBase = 0 # start with 'C'\r\n self.fullRangedScale = [] # holder for the current scale expressed across the current range of the Player\r\n self.rangedScaleOf1s = [] # holder for the current 1st degrees of the scale, across current range\r\n self.rangedScaleOf3s = [] # holder for the current 3rd degrees of the scale, across current range\r\n self.rangedScaleOf5s = [] # holder for the current 5th degrees of the scale, across current range\r\n self.rangedScaleOf0s = [] # holder for scale notes that are not 1st, 3rd or 5th degrees, across current range\r\n self.finishedUL = False\r\n self.weight_1 = 80 # assume slider 1 starts at value 15\r\n self.weight_3 = 22\r\n self.weight_5 = 22\r\n self.weight_other = 0\r\n self.thisTick = 0\r\n self.thisBar = 0\r\n self.ticksPerBar = 48\r\n self.cumulativeBars = 0\r\n self.motifScale = 30\r\n self.newULTimer = Timer(0, self.getNewUrlinie, [], False) # the idea is to put the Urlinie generator on its own thread\r\n\r\n # set placeholder for references to other classes\r\n self.UL = None # placeholder for UrLinie object\r\n self.NS = None # placeholder for Note Sender object\r\n self.LS = None # placeholder for Lead Sheet object\r\n self.MI = None # placeholder for MIDI Input object\r","def __init__(self, name=\"untitled\", pulseGenerator=None, frequency=None, phase=0, generatorFunction=\"square\", applyCorrections=False, pulseOn=True, **kwargs):\n self._pulseGenerator = pulseGenerator\n self.frequency = frequency\n self.phase = phase\n self.applyCorrections = applyCorrections\n self.name = name\n self.pulseOn = pulseOn\n self._numberOfPoints = self._pulseGenerator.numberOfPoints()\n self._samplingTime = self._pulseGenerator.samplingTime()\n # made complex by Kiddi 09/03/2015\n self._pulseArray = zeros(self._numberOfPoints, dtype=numpy.complex128)\n self._generatorFunction = generatorFunction\n self._parameters = kwargs\n\n try:\n self._pulseArray[:] = getattr(generatorFunctionLib, generatorFunction)(\n self._numberOfPoints, self._samplingTime, **kwargs)\n except \"Attribute Error\":\n print \"function %s does not exist\" % generatorFunction\n except:\n raise","def pulse(*args, **kwargs):\n weight_key = kwargs.get('weight')\n\n pulses_generator = _pulse(*args, **kwargs)\n\n if not configuration.pulse_return_best:\n return pulses_generator\n\n best = None\n best_cost = None\n for pulse, weights in pulses_generator:\n if best is None or best_cost > weights.get(weight_key):\n best_cost = weights.get(weight_key)\n best = pulse, weights\n\n return [best]"],"string":"[\n \"def __init__(self, power, T0_ps, center_wavelength_nm,\\n time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, \\n GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0,\\n power_is_avg = False):\\n\\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\\n # make sure we weren't passed mks units \\n assert (center_wavelength_nm > 1.0) \\n assert (time_window_ps > 1.0 ) \\n self.set_center_wavelength_nm(center_wavelength_nm)\\n self.set_time_window_ps(time_window_ps) \\n \\n GDD = GDD\\n TOD = TOD\\n \\n # from https://www.rp-photonics.com/gaussian_pulses.html\\n self.set_AT( np.sqrt(power) * np.exp(-2.77*0.5*self.T_ps**2/(T0_ps**2)) ) # input field (W^0.5) \\n if power_is_avg: \\n self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) ))\\n self.chirp_pulse_W(GDD, TOD)\\n self.chirp_pulse_T(chirp2, chirp3, T0_ps)\",\n \"def __init__(self, power, T0_ps, center_wavelength_nm,\\n time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, \\n GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0,\\n power_is_avg = False):\\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\\n # make sure we weren't passed mks units \\n assert (center_wavelength_nm > 1.0) \\n assert (time_window_ps > 1.0 ) \\n self.set_center_wavelength_nm(center_wavelength_nm) \\n self.set_time_window_ps(time_window_ps)\\n \\n ### Generate pulse\\n if not power_is_avg:\\n # from https://www.rp-photonics.com/sech2_shaped_pulses.html\\n self.set_AT( np.sqrt(power)/np.cosh(self.T_ps/T0_ps) )\\n else:\\n self.set_AT( 1 / np.cosh(self.T_ps/T0_ps) )\\n self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) ))\\n \\n self.chirp_pulse_W(GDD, TOD)\\n self.chirp_pulse_T(chirp2, chirp3, T0_ps)\",\n \"def __init__(self, power, FWHM_ps, center_wavelength_nm,\\n time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, \\n GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0,\\n power_is_avg = False):\\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\\n # make sure we weren't passed mks units \\n assert (center_wavelength_nm > 1.0) \\n assert (time_window_ps > 1.0 ) \\n self.set_center_wavelength_nm(center_wavelength_nm) \\n self.set_time_window_ps(time_window_ps)\\n\\n T0_ps = FWHM_ps/3.7909885\\n ### Generate pulse\\n if not power_is_avg:\\n # numpy.sinc is sin(pi*x)/(pi*x), so we divide by pi\\n self.set_AT( np.sqrt(power) * np.sinc(self.T_ps/(T0_ps*np.pi)) ) \\n else:\\n self.set_AT( 1 / np.sinc(np.pi * self.T_ps/(T0_ps*np.pi)) )\\n self.set_AT(self.AT * np.sqrt( power / ( frep_MHz*1.0e6 * self.calc_epp()) ))\\n \\n self.chirp_pulse_W(GDD, TOD)\\n self.chirp_pulse_T(chirp2, chirp3, T0_ps)\",\n \"def pulse_width(self) -> int:\",\n \"def _pulse_analysis_determine(pulse: int) -> entity.StatusEnum:\\n # minimum heart rate: https://thenextchallenge.org/resting-heart-rate/\\n # After the age of 10, 60 to 100 is considered normal in a resting\\n # position (not including factors such as stress and exercise etc…)\\n # https://www.medicalnewstoday.com/articles/235710#target-training-heart-rates\\n # https://www.heart.org/en/healthy-living/fitness/fitness-basics/target-heart-rates\\n\\n result = entity.StatusEnum.LIFE_THREATENING\\n options = {\\n entity.StatusEnum.OK: (60, 100),\\n entity.StatusEnum.MINOR: (50, 120),\\n entity.StatusEnum.MAJOR: (40, 160),\\n }\\n\\n for status in options:\\n min, max = options[status]\\n if min <= pulse <= max:\\n result = status\\n break\\n return result\",\n \"def test_basic_pulse(self):\\n coeff = np.array([0.1, 0.2, 0.3, 0.4])\\n tlist = np.array([0., 1., 2., 3.])\\n ham = sigmaz()\\n\\n # Basic tests\\n pulse1 = Pulse(ham, 1, tlist, coeff)\\n assert_allclose(\\n pulse1.get_ideal_qobjevo(2)(0).full(),\\n tensor(identity(2), sigmaz()).full() * coeff[0])\\n pulse1.tlist = 2 * tlist\\n assert_allclose(pulse1.tlist, 2 * tlist)\\n pulse1.tlist = tlist\\n pulse1.coeff = 2 * coeff\\n assert_allclose(pulse1.coeff, 2 * coeff)\\n pulse1.coeff = coeff\\n pulse1.qobj = 2 * sigmay()\\n assert_allclose(pulse1.qobj.full(), 2 * sigmay().full())\\n pulse1.qobj = ham\\n pulse1.targets = 3\\n assert_allclose(pulse1.targets, 3)\\n pulse1.targets = 1\\n qobjevo = pulse1.get_ideal_qobjevo(2)\\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\\n expected = QobjEvo(\\n [tensor(identity(2), sigmaz()), coeff],\\n tlist=tlist,\\n order=0\\n )\\n else:\\n expected = QobjEvo(\\n [tensor(identity(2), sigmaz()), coeff],\\n tlist=tlist,\\n args={\\\"_step_func_coeff\\\": True}\\n )\\n _compare_qobjevo(qobjevo, expected, 0, 3)\",\n \"def pulse_width_percent(self) -> float:\",\n \"def nearest_test_pulse(self):\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def __init__(self, time_window_ps, center_wavelength_nm, power,frep_MHz = 100., NPTS = 2**10,\\n power_is_avg = False,\\n fileloc = '',\\n flip_phase = True):\\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\\n try:\\n self.fileloc = fileloc\\n # make sure we weren't passed mks units\\n assert (center_wavelength_nm > 1.0) \\n assert (time_window_ps > 1.0 )\\n self.set_time_window_ps(time_window_ps)\\n self.set_center_wavelength_nm(center_wavelength_nm) # reference wavelength (nm) \\n \\n # power -> EPP\\n if power_is_avg:\\n power = power / self.frep_mks\\n \\n # Read in retrieved FROG trace\\n frog_data = np.genfromtxt(self.fileloc)\\n wavelengths = frog_data[:,0]# (nm)\\n intensity = frog_data[:,1]# (arb. units)\\n phase = frog_data[:,2]# (radians)\\n\\n if flip_phase:\\n phase = -1 * phase\\n \\n pulse_envelope = interp1d(wavelengths, intensity, kind='linear',\\n bounds_error=False,fill_value=0)\\n phase_envelope = interp1d(wavelengths, phase, kind='linear', \\n bounds_error=False,fill_value=0)\\n \\n gridded_intensity = pulse_envelope(self.wl_nm)\\n gridded_phase = phase_envelope(self.wl_nm)\\n\\n # Calculate time domain complex electric field A\\n self.set_AW(gridded_intensity*np.exp(1j*gridded_phase))\\n # Calculate normalization factor to achieve requested \\n # pulse energy\\n e_scale = np.sqrt(power / self.calc_epp() )\\n self.set_AT(self.AT * e_scale )\\n\\n except IOError:\\n print ('File not found.' )\",\n \"def pulse(amplitude, onsets, width, t_stop, baseline=0.0):\\n times = [0]\\n amps = [baseline]\\n for onset in onsets:\\n times += [onset, onset + width]\\n amps += [amplitude, baseline]\\n times += [t_stop]\\n amps += [baseline]\\n return np.array(times), np.array(amps)\",\n \"def _calpara(self):\\n self.up = math.exp(self.sigma*math.sqrt(self.deltatime))\\n self.down = math.exp(-self.sigma*math.sqrt(self.deltatime))\\n self.upprob = (math.exp((self.r-self.d)*self.deltatime)-self.down)/(self.up-self.down)\",\n \"def calculate_pulse(processed_video, recorded_time, show_processed_image):\\n if show_processed_image:\\n processed_video = extract_red_values(processed_video, show_processed_image)\\n processed_video = np.asarray(processed_video, dtype=np.float32)\\n red_values = []\\n for i in range(0, processed_video.shape[0]):\\n img = processed_video[i]\\n red_intensity = np.mean(img)\\n red_values.append(red_intensity)\\n peaks, _ = find_peaks(red_values)\\n pulse = (len(peaks) / float(recorded_time)) * 60\\n pulse = np.int16(pulse)\\n rospy.loginfo(\\\"[EulerianMotionMagnification] Pulse: \\\" + str(pulse))\\n return pulse, red_values\",\n \"def velPulse (t,Dp,t1,Tp):\\r\\n\\tdiscretePulse=(Dp*math.pi)/(Tp*float(2))*np.cos(math.pi*(t-t1-Tp/float(2))/float(Tp))\\r\\n\\treturn discretePulse\",\n \"def test_pulse_constructor(self):\\n coeff = np.array([0.1, 0.2, 0.3, 0.4])\\n tlist = np.array([0., 1., 2., 3.])\\n ham = sigmaz()\\n # Special ways of initializing pulse\\n pulse2 = Pulse(sigmax(), 0, tlist, True)\\n assert_allclose(pulse2.get_ideal_qobjevo(2)(0).full(),\\n tensor(sigmax(), identity(2)).full())\\n\\n pulse3 = Pulse(sigmay(), 0)\\n assert_allclose(pulse3.get_ideal_qobjevo(2)(0).norm(), 0.)\\n\\n pulse4 = Pulse(None, None) # Dummy empty ham\\n assert_allclose(pulse4.get_ideal_qobjevo(2)(0).norm(), 0.)\\n\\n tlist_noise = np.array([1., 2.5, 3.])\\n coeff_noise = np.array([0.5, 0.1, 0.5])\\n tlist_noise2 = np.array([0.5, 2, 3.])\\n coeff_noise2 = np.array([0.1, 0.2, 0.3])\\n # Pulse with different dims\\n random_qobj = Qobj(np.random.random((3, 3)))\\n pulse5 = Pulse(sigmaz(), 1, tlist, True)\\n pulse5.add_coherent_noise(sigmay(), 1, tlist_noise, coeff_noise)\\n pulse5.add_lindblad_noise(\\n random_qobj, 0, tlist=tlist_noise2, coeff=coeff_noise2)\\n qu, c_ops = pulse5.get_noisy_qobjevo(dims=[3, 2])\\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\\n expected = QobjEvo(\\n [\\n tensor([identity(3), sigmaz()]),\\n [tensor([identity(3), sigmay()]), coeff_noise]\\n ],\\n tlist=tlist_noise,\\n order=0)\\n else:\\n expected = QobjEvo(\\n [\\n tensor([identity(3), sigmaz()]),\\n [tensor([identity(3), sigmay()]), coeff_noise]\\n ],\\n tlist=tlist_noise,\\n args={\\\"_step_func_coeff\\\": True})\\n _compare_qobjevo(qu, expected, 0, 3)\",\n \"def build_pulse_waveform(startper,endper):\\r\\n mywaveform = numpy.zeros(100, dtype=numpy.int)\\r\\n if startper > endper:\\r\\n mywaveform[0:endper]=1\\r\\n mywaveform[startper:100]=1\\r\\n else:\\r\\n mywaveform[startper:endper]=1 \\r\\n return mywaveform\",\n \"def test_pulse_counter_loop(self):\\n self.l.output(conf_d=0x01, state_d=0x0)\\n self.l.count(reset=True)\\n t10, t20 = 0.001231, 0.002063\\n errmask, t1, t2 = self.l.pulse(t1=t10, t2=t20,\\n lines=0x01, num_pulses=100)\\n self.assertTrue(abs(t1-t10)/t10 < .1)\\n self.assertTrue(abs(t2-t20)/t20 < .1)\\n c, t = self.l.count()\\n self.assertEqual(c, 100,\\n \\\"counted %g pulses\\\" % c)\",\n \"def accPulse (t,Dp,t1,Tp):\\r\\n\\tdiscretePulse=-(Dp*math.pi**2)/(float(2)*Tp**2)*np.sin(math.pi*(t-t1-Tp/float(2))/float(Tp))\\r\\n\\treturn discretePulse/float(981)\",\n \"def get_scale_data(pin, timeout=1.0):\\n timestamp = time.monotonic()\\n with pulseio.PulseIn(pin, maxlen=96, idle_state=True) as pulses:\\n pulses.pause()\\n pulses.clear()\\n pulses.resume()\\n\\n while len(pulses) < 35:\\n if (time.monotonic() - timestamp) > timeout:\\n raise RuntimeError(\\\"Timed out waiting for data\\\")\\n pulses.pause()\\n bits = [0] * 96 # there are 12 bytes = 96 bits of data\\n bit_idx = 0 # we will count a bit at a time\\n bit_val = False # first pulses will be LOW\\n print(pulses[1])\\n for i in range(len(pulses)):\\n if pulses[i] == 65535: # This is the pulse between transmits\\n break\\n num_bits = int(pulses[i] / 75 + 0.5) # ~14KHz == ~7.5us per clock\\n #print(\\\"%d (%d),\\\" % (pulses[i], num_bits), end='')\\n for bit in range(num_bits):\\n #print(\\\"bit #\\\", bit_idx)\\n bits[bit_idx] = bit_val\\n bit_idx += 1\\n if bit_idx == 96: # we have read all the data we wanted\\n #print(\\\"DONE\\\")\\n break\\n bit_val = not bit_val\\n #print(bits)\\n data_bytes = [0] * 12\\n for byte_n in range(12):\\n thebyte = 0\\n for bit_n in range(8):\\n thebyte <<= 1\\n thebyte |= bits[byte_n*8 + bit_n]\\n data_bytes[byte_n] = thebyte\\n print([hex(i) for i in data_bytes])\\n # do some very basic data checking\\n if data_bytes[0] != 3 or data_bytes[1] != 3 or data_bytes[7] != 4 \\\\\\n or data_bytes[8] != 0x1C or data_bytes[9] != 0 or data_bytes[10] \\\\\\n or data_bytes[11] != 0:\\n raise RuntimeError(\\\"Bad data capture\\\")\\n reading = ScaleReading()\\n\\n reading.stable = data_bytes[2] & 0x4\\n reading.units = data_bytes[3]\\n reading.weight = data_bytes[5] + (data_bytes[6] << 8)\\n if data_bytes[2] & 0x1:\\n reading.weight *= -1\\n if reading.units == ScaleReading.OUNCES:\\n # oi no easy way to cast to int8_t\\n if data_bytes[4] & 0x80:\\n data_bytes[4] -= 0x100\\n reading.weight *= 10 ** data_bytes[4]\\n return reading\",\n \"def generatePulse(self, duration=100, gaussian=False, frequency=12., amplitude=1., phase=0., DelayFromZero=0, useCalibration=False, shape=None, name=None):\\n if name is None:\\n name = 'self%i' % self.index\\n self.index += 1\\n self._params[\\\"pulses\\\"][name] = dict()\\n self._params[\\\"pulses\\\"][name][\\\"frequency\\\"] = frequency\\n self._params[\\\"pulses\\\"][name][\\\"name\\\"] = name\\n if shape is None:\\n self._params[\\\"pulses\\\"][name][\\\"shape\\\"] = None\\n self._params[\\\"pulses\\\"][name][\\\"duration\\\"] = duration\\n self._params[\\\"pulses\\\"][name][\\\"gaussian\\\"] = gaussian\\n self._params[\\\"pulses\\\"][name][\\\"amplitude\\\"] = amplitude\\n self._params[\\\"pulses\\\"][name][\\\"phase\\\"] = phase\\n self._params[\\\"pulses\\\"][name][\\\"DelayFromZero\\\"] = DelayFromZero\\n self._params[\\\"pulses\\\"][name][\\\"useCalibration\\\"] = useCalibration\\n else:\\n self._params[\\\"pulses\\\"][name][\\\"shape\\\"] = \\\"userDefined\\\"\\n\\n pulse = numpy.zeros(self.numberOfPoints(), dtype=numpy.complex128)\\n if self._params['modulationMode'] == \\\"IQMixer\\\":\\n MWFrequency = float(self._MWSource.frequency())\\n self._MWSource.turnOn()\\n IF = frequency - MWFrequency\\n try:\\n if shape is None:\\n if gaussian:\\n print 'gaussian pulse is not working !!!'\\n pulse = self.gaussianPulse(\\n sigma=duration, delay=DelayFromZero, amplitude=amplitude)\\n else:\\n pulse[DelayFromZero:DelayFromZero + duration] = amplitude\\n else:\\n pulse[:] = shape[:]\\n pulse *= numpy.exp(1.0j * phase) / 2\\n # REPLACED BY DV IN FEB 2015 (see line below supressed section)\\n # if useCalibration:\\n #calibrationParameters=self._mixer.calibrationParameters(f_sb=f_sb, f_c=MWFrequency)\\n #self.debugPrint( calibrationParameters)\\n #cr = float(calibrationParameters['c'])*exp(1j*float(calibrationParameters['phi']))\\n #self.debugPrint( \\\"f_sb=\\\",f_sb)\\n #sidebandPulse = exp(-1.j*f_sb*2.0*math.pi*(arange(DelayFromZero,DelayFromZero+len(pulse))))+cr*exp(1.j*f_sb*2.0*math.pi*(arange(DelayFromZero,DelayFromZero+len(pulse))))\\n # self._AWG.setOffset(self._params[\\\"AWGChannels\\\"][0],calibrationParameters['i0'])\\n # self._AWG.setOffset(self._params[\\\"AWGChannels\\\"][1],calibrationParameters['q0'])\\n # else:\\n #sidebandPulse = exp(-1.j*2.0*math.pi*f_sb*(arange(DelayFromZero,DelayFromZero+len(pulse))))\\n #waveformIQ =exp(-2.0j*pi*IF*(times+float(delay)))\\n # self._AWG.setOffset(self._params[\\\"AWGChannels\\\"][0],0)\\n # self._AWG.setOffset(self._params[\\\"AWGChannels\\\"][1],0)\\n sidebandPulse = self._mixer.generateSidebandWaveform(\\n IF=IF, useCalibIfNone=useCalibration, length=self.numberOfPoints())\\n pulse[:] *= sidebandPulse\\n except:\\n raise\\n\\n if self._params['modulationMode'] == \\\"SimpleMixer\\\":\\n self._MWSource.setFrequency(frequency)\\n if shape is None:\\n if gaussian:\\n print 'gaussian pulse is not working !!!'\\n print duration, DelayFromZero, amplitude\\n pulse = self.gaussianPulse(\\n sigma=duration, delay=DelayFromZero, amplitude=amplitude)\\n else:\\n pulse[DelayFromZero:DelayFromZero + duration] = amplitude\\n else:\\n pulse[:] = shape[:]\\n if useCalibration:\\n self._AWG.setOffset(\\n self._params[\\\"AWGChannels\\\"], self._mixer.calibrationParameters())\\n if self._params['modulationMode'] == \\\"InternalModulation\\\":\\n print \\\"NOT CONFIGURED YET ! DO NOT USE !\\\"\\n self.pulses[name] = [pulse, True]\",\n \"def calibration(\\n self,\\n pulse_min: int,\\n pulse_max: int,\\n pulse_centre: int,\\n pulse_angle_90: int,\\n pulse_speed_100: int,\\n /,\\n ) -> None:\",\n \"def visit_pulseexpr(self, state, channels, t, n_samp, waveform, phase):\\n pass\",\n \"async def Pulse_Lights():\\n busylightapi.manager.apply_effect_to_light(ALL_LIGHTS, pulse)\\n return {\\n \\\"action\\\": \\\"effect\\\",\\n \\\"name\\\": \\\"pulse\\\",\\n \\\"light_id\\\": \\\"all\\\",\\n \\\"color\\\": \\\"red\\\",\\n }\",\n \"def __init__(self, servo_gpio, pi=None, pulse_left_ns=2500, pulse_right_ns=1000, pulse_centre_ns=None):\\n\\n self.gpio = servo_gpio\\n\\n if pi is None:\\n self.pi = pi = pigpio.pi()\\n else:\\n self.pi = pi\\n\\n self.pulse_left_ns = pulse_left_ns\\n self.pulse_right_ns = pulse_right_ns\\n\\n if pulse_centre_ns is None:\\n self.pulse_centre_ns = ((pulse_left_ns - pulse_right_ns) // 2) + pulse_right_ns\",\n \"def pulse(\\n self,\\n cycles=1,\\n duty_cycle=0.5,\\n transient=1,\\n period=1.0,\\n skew_ratio=sb.NotSpecified,\\n **kwargs\\n ):\\n if skew_ratio is sb.NotSpecified:\\n skew_ratio = 1 - duty_cycle\\n return dict(\\n waveform=Waveform.PULSE,\\n cycles=cycles,\\n skew_ratio=skew_ratio,\\n transient=transient,\\n period=period,\\n )\",\n \"def __call__(self, x : float) -> float:\\n current = 0\\n for key in self.pulses:\\n pulseAmmount = self.pulses[key]\\n startTime = key[0]\\n stopTime=key[1]\\n if x >= startTime and x < stopTime:\\n current += pulseAmmount\\n return current\",\n \"def time_pulse_us(pin:Pin, pulse_level:int, timeout_us:int=1000000, /) -> int:\",\n \"def __init__(\\n self,\\n pin,\\n min_pulse_width=500,\\n max_pulse_width=2500,\\n min_full_sweep_time=0.5,\\n rotation_update_freq=25,\\n ):\\n assert (\\n 500 <= min_pulse_width <= 2500\\n ), \\\"min_pulse_width should be between 500 and 2500\\\"\\n assert (\\n 500 <= max_pulse_width <= 2500\\n ), \\\"max_pulse_width should be between 500 and 2500\\\"\\n assert (\\n min_pulse_width < max_pulse_width\\n ), \\\"min_pulse_width should be less than max_pulse_width\\\"\\n assert (\\n min_full_sweep_time > 0\\n ), \\\"min_full_sweep_time should be positive\\\"\\n assert (\\n rotation_update_freq > 0\\n ), \\\"rotation_update_freq should be positive\\\"\\n\\n self._pin = pin\\n self._min_pulse_width = min_pulse_width\\n self._max_pulse_width = max_pulse_width\\n self._mid_pulse_width = (max_pulse_width + min_pulse_width) / 2\\n self._max_pos_change_per_update = 2 / (\\n rotation_update_freq * min_full_sweep_time\\n )\\n self._rotation_update_freq = rotation_update_freq\\n self._latest_rotation_start_time = None\\n self._position = None\\n self._rotation_speed = 0\\n self._stopped = False\\n\\n self._pi = pigpio.pi()\\n if not self._pi.connected:\\n raise RuntimeError(\\\"Could not connect to pigpio daemon\\\")\\n self._pi.set_mode(self._pin, pigpio.OUTPUT)\\n self._pi.set_servo_pulsewidth(self._pin, 0)\",\n \"def wave_get_pulses():\\n return _u2i(_pigpio_command(_control, _PI_CMD_WVSP, 0, 0))\",\n \"def computeProp(self):\\n self.chem = {}\\n for key in self.config.C:\\n if key in ['P', 'T', 'Z', 'DZ']:\\n continue\\n self.chem[key] = chemistry.ConstituentProperties(key)\\n\\n # nAtm = len(self.gas[self.config.C['P']])\\n self.property = []\\n for op in self.config.LP:\\n self.property.append([])\\n zOffset = 0.0\\n iOffset = 0\\n psep = 1.0E6\\n for i, zv in enumerate(self.gas[self.config.C['Z']]): # find the nearest z value at p_ref\\n P = self.gas[self.config.C['P']][i]\\n if abs(P - self.config.p_ref) < psep:\\n psep = abs(P - self.config.p_ref)\\n iOffset = i\\n zOffset = self.gas[self.config.C['Z']][iOffset]\\n z_at_p_ref = self.config.Req\\n\\n for i, zv in enumerate(self.gas[self.config.C['Z']]):\\n T = self.gas[self.config.C['T']][i]\\n P = self.gas[self.config.C['P']][i]\\n self.property[self.config.LP['P']].append(P)\\n self.property[self.config.LP['Z']].append(zv)\\n rr = z_at_p_ref + zv - zOffset\\n # note that this is the \\\"actual\\\"z along equator referenced to planet center (aka radius)\\n self.property[self.config.LP['R']].append(rr)\\n # ##set mean amu\\n amulyr = 0.0\\n for key in self.chem:\\n amulyr += self.chem[key].amu * self.gas[self.config.C[key]][i]\\n self.property[self.config.LP['AMU']].append(amulyr)\\n # ##set GM pre-calc (normalized further down) and get lapse rate\\n if not i:\\n self.property[self.config.LP['GM']].append(0.0)\\n self.property[self.config.LP['LAPSE']].append(0.0)\\n self.property[self.config.LP['LAPSEP']].append(0.0)\\n else:\\n rho = (amulyr * P) / (chemistry.R * T)\\n dr = abs(zv - self.gas[self.config.C['Z']][i - 1])\\n dV = 4.0 * np.pi * (rr**2) * dr\\n dM = 1.0e11 * rho * dV\\n GdM = self.property[self.config.LP['GM']][i - 1] + chemistry.GravConst * dM\\n # in km3/s2\\n # mass added as you make way into atmosphere by radius r (times G)\\n self.property[self.config.LP['GM']].append(GdM)\\n dT = abs(T - self.gas[self.config.C['T']][i - 1])\\n dP = abs(P - self.gas[self.config.C['P']][i - 1])\\n self.property[self.config.LP['LAPSE']].append(dT / dr)\\n self.property[self.config.LP['LAPSEP']].append(dT / dP)\\n # ##set refractivity and index of refraction\\n refrlyr = 0.0\\n for key in self.chem:\\n refrlyr += self.chem[key].refractivity(T=T) * self.gas[self.config.C[key]][i]\\n refrlyr = refrlyr * P * (293.0 / T)\\n self.property[self.config.LP['REFR']].append(refrlyr)\\n nlyr = refrlyr / 1.0E6 + 1.0\\n self.property[self.config.LP['N']].append(nlyr)\\n\\n # ##Now need to normalize GM to planet and calculate scale height (H)\\n GMnorm = self.property[self.config.LP['GM']][iOffset] # G*(Mass added by p_ref)\\n for i, mv in enumerate(self.property[self.config.LP['GM']]):\\n gm = self.config.GM_ref - (mv - GMnorm)\\n self.property[self.config.LP['GM']][i] = gm\\n little_g = gm / self.property[self.config.LP['R']][i]**2\\n m_bar = self.property[self.config.LP['AMU']][i]\\n T = self.gas[self.config.C['T']][i]\\n self.property[self.config.LP['H']].append((chemistry.R * T) /\\n (little_g * m_bar) / 1000.0)\\n self.property[self.config.LP['g']].append(little_g)\\n self.property = np.array(self.property)\",\n \"def pulse_width(self, value: int, /) -> None:\",\n \"def pulsewidth2pct(pw): \\n shifted = pw - 500.0\\n scaled = shifted / 2000.0 * 100.0\\n pct = scaled\\n return pct\",\n \"def photometric_calibration():\\n pass\",\n \"def _get_pulse_shaping_waveform(self):\\n self.pulse_shaping_list = []\\n # Make the rise time be 3.3333% if the dot time.\\n rise_time_in_msec = 0.03333333333333 * self.dot_time_in_msec\\n # Limit the rise time to 2 milliseconds.\\n if rise_time_in_msec > 0.002:\\n rise_time_in_msec = 0.002\\n rising_falling_count = int(rise_time_in_msec * self.sample_rate)\\n step = math.pi / rising_falling_count\\n # The first value is zero, so skip that value.\\n # The last value is 1.0, so skip that value too.\\n for i in range(1, rising_falling_count - 1):\\n gain = 0.5 * (1.0 - math.cos(step * i))\\n self.pulse_shaping_list.append(gain)\",\n \"def key_length(x, *args):\\n ###########################################################################\\n ## Store input as named arrays/parameters for ease of use\\n ###########################################################################\\n # Asymmetric basis choice probability\\n Px = x[0]\\n # Weak coherent pulse intensities, mu3 is fixed\\n mu = np.array([x[3],x[4],mu3])\\n # Probability of Alice sending a pulse of intensity mu_k\\n P = np.array([x[1],x[2],1 - x[1] - x[2]])\\n \\n ###########################################################################\\n ## Define total system loss and convert to efficiency\\n ###########################################################################\\n # Excess loss in decibels\\n etaExcess = 10**(-ls / 10.0)\\n # Scale excess loss by detector efficiency\\n eta = etaExcess*eta_d\\n # Take the outer product of FSeff, the free space loss, and mu, the pulse\\n # intensities, where FSeff has a length t.\\n # Use dt to take a window of t values from FSeff.\\n # Returns the (3,t) array mu_FSeff\\n mu_FSeff = np.outer(mu, FSeff[time0pos-dt:time0pos+dt+1])\\n # Exponential loss decay function\\n # Returns the (3,t) array exp_loss_jt\\n exp_loss_jt = np.exp(-mu_FSeff*eta)\\n\\n ###########################################################################\\n ## Estimate count and error rates for signals\\n ###########################################################################\\n # Expected detection rate (including afterpulse contributions)\\n # Returns the (3,t) array Dj\\n Dj = DRate_j(eta,Pap,Pec,exp_loss_jt)\\n ###print('Dj =',np.sum(Dj,axis=1))\\n # Probability of having a bit error per intensity for a given time slot\\n # Returns the (3,t) array ej\\n ej = error_j(Dj,Pap,Pec,QBERI,exp_loss_jt)\\n \\n ###########################################################################\\n ## Store some useful array products\\n ###########################################################################\\n # Take the dot product of the (3,) array P and the (3,t) array ej.\\n # Returns the (t,) array P_dot_ej\\n P_dot_ej = np.dot(P, ej)\\n # Take the dot product of the (3,) array P and the (3,t) array Dj.\\n # Returns the (t,) array P_dot_Dj\\n P_dot_Dj = np.dot(P, Dj)\\n # Do an element-wise multiplication of the (3,) array P and the (3,t) \\n # array Dj.\\n # Returns the (3,t) array P_times_Dj\\n P_times_Dj = np.transpose(np.multiply(np.transpose(Dj), P))\\n\\n ###########################################################################\\n ## Estimate count statistics\\n ###########################################################################\\n # Number of events in the sifted X basis for each time slot and intensity\\n # Returns the (3,t) array nx\\n nx = nxz(Px, Px, Npulse, P_times_Dj)\\n # Number of events in the sifted Z basis for each time slot and intensity\\n # Returns the (3,t) array nz\\n nz = nxz(1 - Px, 1 - Px, Npulse, P_times_Dj)\\n\\n # Total number of events in the sifted X basis for each intensity\\n # Returns the (3,) array nx_mu\\n nx_mu = np.sum(nx, axis=1)\\n # Total number of events in the sifted Z basis for each intensity\\n # Returns the (3,) array nz_mu\\n nz_mu = np.sum(nz, axis=1)\\n \\n # Total number of events in the sifted X basis\\n nX = np.sum(nx_mu)\\n # Total number of events in the sifted Z basis\\n nZ = np.sum(nz_mu) # Not used but written out\\n \\n # Number of errors in the sifted X basis for each time slot\\n # Returns the (t,) array mX\\n mX = mXZ(nx, P_dot_Dj, P_dot_ej)\\n mZ = mXZ(nz, P_dot_Dj, P_dot_ej)\\n # Number of errors in the sifted X basis for each time slot and intensity\\n # Returns the (3,t) array mx\\n #mx = mxz(mX, P_dot_Dj, P_times_Dj) # Not used\\n mz = mxz(mZ, P_dot_Dj, P_times_Dj)\\n # Total number of errors in the sifted X basis\\n mXtot = np.sum(mX)\\n mZtot = np.sum(mZ)\\n # Number of errors in the sifted X basis for each intensity\\n # Returns the (3,) array mXj\\n #mXj = np.sum(mx, axis=1) # Not used\\n mZj = np.sum(mz, axis=1)\\n \\n ###########################################################################\\n ## Estimate bounds on count estimates due to statistical fluctuations\\n ###########################################################################\\n # Upper and lower bounds used to estimate the ideal number of X and Z basis\\n # events accounting for statistical fluctuations \\n if boundFunc in ['Chernoff','chernoff']:\\n # Use Chernoff bounds\\n # Returns the (3,) arrays nXmin, nXplus\\n nXmin, nXplus = nXZpm(mu,P,nx_mu,eps_s)\\n # Returns the (3,) arrays nZmin, nZplus\\n nZmin, nZplus = nXZpm(mu,P,nz_mu,eps_s)\\n # Returns the (3,) arrays mXmin and mXplus\\n #mXmin, mXplus = mXZpm(mu,P,mXj,eps_s) # Not used\\n # Returns the (3,) arrays mZmin and mZplus\\n mZmin, mZplus = mXZpm(mu,P,mZj,eps_s)\\n elif boundFunc in ['Hoeffding','hoeffding']:\\n # Use Hoeffding bound\\n # Returns the (3,) arrays nXmin, nXplus\\n nXmin, nXplus = nXZpm_HB(mu,P,nx_mu,nX,eps_s)\\n # Returns the (3,) arrays nZmin, nZplus\\n nZmin, nZplus = nXZpm_HB(mu,P,nz_mu,nZ,eps_s)\\n # Returns the (3,) arrays mXmin and mXplus\\n #mXmin, mXplus = mXZpm_HB(mu,P,mXj,mXtot,eps_s) # Not used\\n # Returns the (3,) arrays mZmin and mZplus\\n mZmin, mZplus = mXZpm_HB(mu,P,mZj,mZtot,eps_s)\\n elif boundFunc in ['Asymptotic','asymptotic']:\\n # Use asymptotic bounds - no bounds\\n # Returns the (3,) arrays nXmin, nXplus\\n nXmin, nXplus = nXZpm_inf(mu,P,nx_mu)\\n # Returns the (3,) arrays nZmin, nZplus\\n nZmin, nZplus = nXZpm_inf(mu,P,nz_mu)\\n # Returns the (3,) arrays mXmin and mXplus\\n #mXmin, mXplus = mXZpm_inf(mu,P,mXj,eps_s) # Not used\\n # Returns the (3,) arrays mZmin and mZplus\\n mZmin, mZplus = mXZpm_inf(mu,P,mZj)\\n else:\\n # Use Chernoff bounds\\n # Returns the (3,) arrays nXmin, nXplus\\n nXmin, nXplus = nXZpm(mu,P,nx_mu,eps_s)\\n # Returns the (3,) arrays nZmin, nZplus\\n nZmin, nZplus = nXZpm(mu,P,nz_mu,eps_s)\\n # Returns the (3,) arrays mXmin and mXplus\\n #mXmin, mXplus = mXZpm(mu,P,mXj,eps_s) # Not used\\n # Returns the (3,) arrays mZmin and mZplus\\n mZmin, mZplus = mXZpm(mu,P,mZj,eps_s)\\n\\n ###########################################################################\\n ## Calculate the number of n-photon events\\n ###########################################################################\\n # Number of vacuum events in the sifted X basis\\n sx0 = max(s0(mu,P,nXmin), num_zero)\\n # Number of vacuum events in the sifted Z basis\\n sz0 = max(s0(mu,P,nZmin), num_zero)\\n\\n # Number of single photon events in the sifted X basis\\n sx1 = max(s1(mu,P,nXmin,nXplus,sx0), num_zero)\\n # Number of single photon events in the sifted Z basis\\n sz1 = max(s1(mu,P,nZmin,nZplus,sz0), num_zero)\\n\\n ###########################################################################\\n ## Calculate metrics such as the error rate, QBER and mean photon number\\n ###########################################################################\\n # Number of bit errors associated with single photon events in the sifted\\n # Z basis \\n vz1 = min(max(vxz1(mu,P,mZmin,mZplus), num_zero), mZtot)\\n # Ratio between the number of bit errors and the number of events\\n # associated with single photons in the sifted Z basis.\\n ratio = min(vz1 / sz1, 1 - num_min)\\n # The quantum bit error rate in the sifted X basis\\n QBERx = mXtot / nX\\n # Calculate the mean photon number\\n mpn = mean_photon_a(P,mu)\\n\\n ###########################################################################\\n ## Estimate the number of bits sacrificed for error correction\\n ###########################################################################\\n if errcorrFunc in ['logM','logm']:\\n lambdaEC = logM(nX, QBERx, eps_c)\\n elif errcorrFunc in ['Block','block']:\\n lambdaEC = 1.16 * nX * h(QBERx)\\n elif errcorrFunc in ['mXtot','mxtot']:\\n lambdaEC = 1.16 * mXtot\\n elif errcorrFunc in ['None','none']:\\n lambdaEC = 0\\n else:\\n lambdaEC = 0\\n \\n ###########################################################################\\n ## Calculate the approximate length of the secret key per pass\\n ## See Eq. (1) in [1].\\n ###########################################################################\\n if boundFunc in ['Asymptotic','asymptotic']:\\n # Asymptotic phase error rate for single photon events in the sifted X\\n # basis\\n phi_x = min(ratio, 0.5)\\n # Secret key length in the asymptotic regime\\n l = max((sx0 + sx1 * (1 - h(phi_x)) - lambdaEC) * \\n heaviside(mu[0] - mu[1] - mu[2]) * heaviside(P[2]), 0.0)\\n else:\\n # Phase error rate for single photon events in the sifted X basis\\n phi_x = min(ratio + gamma(eps_s,ratio,sz1,sx1), 0.5)\\n # Secret key length in the finite regime\\n l = max((sx0 + sx1 * (1 - h(phi_x)) - lambdaEC -\\n 6*np.math.log(21.0 / eps_s, 2) - np.math.log(2.0 / eps_c, 2)) * \\n heaviside(mu[0] - mu[1] - mu[2]) * heaviside(P[2]), 0.0)\\n l = l / NoPass # Normalise by the number of satellite passes used\\n\\n return l, QBERx, phi_x, nX, nZ, mXtot, lambdaEC, sx0, sx1, vz1, sz1, mpn\",\n \"def __pulse_all(self):\\n\\n if len(self.__bus_dict) == 0:\\n return\\n bus_dict_copy = self.__bus_dict.copy()\\n for line in bus_dict_copy.values():\\n for bus in line:\\n self.__indevidual_pulse(bus)\",\n \"def test_pulse(self):\\n report(_(\\\"Testing PULSE sound output\\\"))\\n return self.audio_try_play(type='pulse')\",\n \"def npulses(self):\\n return self.header.pulse_count\",\n \"def speed_pulse(x, v0=U_I, drop: float = 1, delay: int = 250, duration: float = 1000):\\n return v0 - pulse_sigmoid(x=x, A=drop, d=delay, duration=duration)\",\n \"def prop_delayed_by_airline(jb_sw):\\n\\n return ...\",\n \"def getCummulativeValues(self):\\n self.cumulativePhaseHeightInRing1 = np.cumsum(self.phaseHeightInRing1)\\n self.cumulativePhaseHeightInRing2 = np.cumsum(self.phaseHeightInRing2)\\n self.cumulativeLeftCriticalPointsRing1 = np.cumsum(self.leftCriticalPointsRing1)\\n self.cumulativeRightCriticalPointsRing1 = np.cumsum(self.rightCriticalPointsRing1)\\n self.cumulativeLeftCriticalPointsRing2 = np.cumsum(self.leftCriticalPointsRing2)\\n self.cumulativeRightCriticalPointsRing2 = np.cumsum(self.rightCriticalPointsRing2)\\n\\n if(self.init1 > 0):\\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing1):\\n self.cumulativeLeftCriticalPointsRing1[index] = value + self.init1\\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing1):\\n self.cumulativeRightCriticalPointsRing1[index] = value + self.init1\\n\\n if(self.init2 > 0):\\n for index, value in enumerate(self.cumulativeLeftCriticalPointsRing2):\\n self.cumulativeLeftCriticalPointsRing2[index] = value + self.init2\\n for index, value in enumerate(self.cumulativeRightCriticalPointsRing2):\\n self.cumulativeRightCriticalPointsRing2[index] = value + self.init2\\n\\n self.cumulativePhaseHeightInRing1 = np.insert(self.cumulativePhaseHeightInRing1, 0, 0.0)\\n self.cumulativePhaseHeightInRing2 = np.insert(self.cumulativePhaseHeightInRing2, 0, 0.0)\\n self.cumulativeLeftCriticalPointsRing1 = np.insert(self.cumulativeLeftCriticalPointsRing1, 0, 0.0)\\n self.cumulativeRightCriticalPointsRing1 = np.insert(self.cumulativeRightCriticalPointsRing1, 0, 0.0)\\n self.cumulativeLeftCriticalPointsRing2 = np.insert(self.cumulativeLeftCriticalPointsRing2, 0, 0.0)\\n self.cumulativeRightCriticalPointsRing2 = np.insert(self.cumulativeRightCriticalPointsRing2, 0, 0.0)\",\n \"def test_pressure_increasing_check_some_constants(mocker, pressure_values, expected):\\n profile = mocker.patch.object(argortqcpy.profile, \\\"Profile\\\")\\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\\n\\n pic = PressureIncreasingCheck(profile, None)\\n output = pic.run()\\n\\n assert np.all(output.get_output_flags_for_property(\\\"PRES\\\").data == expected)\",\n \"def _pulse_width_record(self, pin):\\n self._time = time.ticks_us()\\n if self._prev_time == 0:\\n self._prev_time = self._time\\n return\\n self.pulse_buffer.append(self._time - self._prev_time)\\n self._prev_time = self._time\\n self.lenth = self.lenth + 1\",\n \"def calcMisc(t, q, u, p):\\n m=dict()\\n # Split state into positions and speeds (qx, qxd), uaero states (qxa_ua), dynamic inflow states (qxa_di)\\n m['qx'], m['qxd'], m['qxa_ua'], m['qxa_di'] = split_q(q, p['Iqxs'], p['Iqxsd'], p['Iqxa_ua'], p['Iqxa_di'])\\n\\n # Structural states (length 3, even if not all DOFs are actice)\\n m['q_full'], m['x'], m['xd'] = inflate_q(q, Iq=p['Iq'])\\n\\n # Orientation of the section\\n m['Ux'], m['Uy'], m['theta_p'] = inputsAtTime(t, u)\\n th = m['x'][2]\\n m['omega'] = m['xd'][2]\\n m['theta'] = th + m['theta_p'] + p['beta'] \\n m['rho_x'] = (-p['x_AG']* np.sin(m['theta']) + p['y_AG']*np.cos(m['theta']) )\\n m['rho_y'] = (-p['x_AG']* np.sin(m['theta']) + p['y_AG']*np.cos(m['theta']) )\\n return m\",\n \"def get_properties(self):\\n assert self.kekulize, '#ERROR: u need to get explicit BOs for amon generation'\\n self.vs = np.array([ ai.GetTotalValence() for ai in self.m0.GetAtoms() ], np.int)\\n #self.update_bom()\\n self.ias_heav = self.ias[ self.zs > 1 ]\\n bom_heav = self.bom[ self.ias_heav, : ][ :, self.ias_heav ]\\n self.vs_heav = bom_heav.sum(axis=0)\\n self.cns_heav = ( bom_heav > 0 ).sum(axis=0)\\n self.nhs = self.vs[:self.nheav] - self.vs_heav - self.chgs[:self.nheav]\\n self.dvs = self.vs_heav - self.cns_heav\\n self.hybs = np.array([ _hyb[ai.GetHybridization()] for ai in self.m.GetAtoms() ])\",\n \"def dispPulse (t,Dp,t1,Tp):\\r\\n\\tdiscretePulse=Dp/float(2)*np.sin(math.pi*(t-t1-Tp/float(2))/float(Tp))+Dp/float(2)\\r\\n\\treturn discretePulse\",\n \"def pulse_analysis(\\n pulse: int, measurement_statistics: entity.MeasurementStatistics\\n) -> entity.StatusEnum:\\n result = entity.StatusEnum.MISSING\\n if not str(pulse).isnumeric() or isinstance(pulse, str):\\n result = entity.StatusEnum.MISSING\\n\\n elif 0 < pulse < 230:\\n result = _pulse_analysis_determine(pulse)\\n\\n measurement_statistics.increment(result)\\n return result\",\n \"def init_servos():\\n for i in range(0, 7):\\n kit.servo[i].actuation_range = 180\\n kit.servo[i].set_pulse_width_range(450, 2550)\",\n \"def calculate_averaged_properties(poly_data, bucket):\\n\\n locator = vtk.vtkPointLocator()\\n locator.SetDataSet(poly_data)\\n locator.BuildLocator()\\n\\n LENGTH = 0.03\\n MODIFIER = 3e3\\n\\n volume = numpy.zeros(poly_data.GetNumberOfPoints())\\n temperature = numpy.zeros(poly_data.GetNumberOfPoints())\\n solid_pressure = numpy.zeros(poly_data.GetNumberOfPoints())\\n velocity = numpy.zeros((poly_data.GetNumberOfPoints(), 3))\\n solid_pressure_gradient = numpy.zeros((poly_data.GetNumberOfPoints(), 3))\\n\\n for particle in bucket:\\n point_list = vtk.vtkIdList()\\n locator.FindPointsWithinRadius(LENGTH, particle.pos, point_list)\\n\\n beta = 1.0/6.0*numpy.pi*particle.parameters.diameter**3\\n\\n for _ in range(point_list.GetNumberOfIds()):\\n point_index = point_list.GetId(_)\\n\\n particle2 = bucket.particles[point_index]\\n\\n rad2 = distance2(particle2.pos, particle.pos)\\n rad2 /= LENGTH**2\\n\\n gamma = beta*numpy.exp(-rad2)*MODIFIER\\n\\n volume[point_index] += gamma\\n\\n velocity[point_index, :] += particle.vel*gamma\\n\\n volume /= 0.5*LENGTH**2*(1.0-numpy.exp(-1.0**2))\\n velocity /= 0.5*LENGTH**2*(1.0-numpy.exp(-1.0**2))\\n\\n for i in range(3):\\n velocity[:, i] /= volume\\n\\n for k, particle in enumerate(bucket):\\n point_list = vtk.vtkIdList()\\n locator.FindPointsWithinRadius(LENGTH, particle.pos, point_list)\\n\\n beta = 1.0/6.0*numpy.pi*particle.parameters.diameter**3\\n\\n for _ in range(point_list.GetNumberOfIds()):\\n point_index = point_list.GetId(_)\\n\\n rad2 = distance2(poly_data.GetPoints().GetPoint(point_index), particle.pos)\\n rad2 /= LENGTH**2\\n\\n gamma = beta*numpy.exp(-rad2)*MODIFIER\\n\\n c = distance2(particle.vel, velocity[k, :])\\n\\n temperature[point_index] += c*gamma\\n\\n\\n for particle in bucket:\\n point_list = vtk.vtkIdList()\\n locator.FindPointsWithinRadius(LENGTH, particle.pos, point_list)\\n\\n beta = 1.0/6.0*numpy.pi*particle.parameters.diameter**3\\n\\n for _ in range(point_list.GetNumberOfIds()):\\n point_index = point_list.GetId(_)\\n\\n rad2 = distance2(poly_data.GetPoints().GetPoint(point_index), particle.pos)\\n rad2 /= LENGTH **2\\n\\n gamma = beta*numpy.exp(-rad2)*MODIFIER\\n\\n c = distance2(particle.vel, velocity[point_index, :])\\n\\n val = (bucket.particles[point_index].pos-particle.pos)/LENGTH**2\\n\\n spg = ((radial_distribution_function(volume[point_index])\\n +volume[point_index]*rdf_deriv(volume[point_index]))*temperature[point_index]\\n +c*volume[point_index]*radial_distribution_function(volume[point_index]))\\n\\n solid_pressure_gradient[point_index, :] += (val*spg*gamma)\\n\\n for _ in range(poly_data.GetNumberOfPoints()):\\n\\n solid_pressure[_] = (bucket.particles[0].parameters.rho*volume[_]\\n *radial_distribution_function(volume[_])*temperature[_])\\n\\n data = [vtk.vtkDoubleArray()]\\n data[0].SetName('SolidVolumeFraction')\\n data.append(vtk.vtkDoubleArray())\\n data[1].SetName('SolidVolumeVelocity')\\n data[1].SetNumberOfComponents(3)\\n data.append(vtk.vtkDoubleArray())\\n data[2].SetName('GranularTemperature')\\n data.append(vtk.vtkDoubleArray())\\n data[3].SetName('SolidPressure')\\n data.append(vtk.vtkDoubleArray())\\n data[4].SetName('SolidPressureGradient')\\n data[4].SetNumberOfComponents(3)\\n\\n for _ in range(poly_data.GetNumberOfPoints()):\\n data[0].InsertNextValue(volume[_])\\n data[1].InsertNextTuple3(*velocity[_])\\n data[2].InsertNextValue(temperature[_])\\n data[3].InsertNextValue(solid_pressure[_])\\n data[4].InsertNextTuple3(*solid_pressure_gradient[_])\\n\\n for _ in data:\\n poly_data.GetPointData().AddArray(_)\\n\\n return data[4]\",\n \"def test_survival_prob():\\n t_start = time()\\n from pisa.core.binning import OneDimBinning\\n\\n absorption_length = 1 # m\\n n_photons = int(1e6)\\n speed_of_light = SPEED_OF_LIGHT_IN_VACUUM #/ 1.5 # m/s\\n dom_radius = DOM_RADIUS\\n dom_efficiency = 1\\n seed = 0\\n\\n r_binning = OneDimBinning(\\n name='r',\\n domain=(0, 25),\\n is_lin=True,\\n num_bins=25,\\n units='m'\\n )\\n phi_binning = OneDimBinning(\\n name='phi',\\n tex=r'\\\\phi',\\n domain=(0, 2*np.pi),\\n is_lin=True,\\n num_bins=32,\\n units='rad'\\n )\\n t_binning = OneDimBinning(\\n name='time',\\n domain=(0, 100),\\n is_lin=True,\\n num_bins=10,\\n units='ns'\\n )\\n phidir_binning = OneDimBinning(\\n name='phidir',\\n tex=r'\\\\phi_{\\\\rm dir}',\\n domain=(0, 2*np.pi),\\n is_lin=True,\\n num_bins=96,\\n units='rad'\\n )\\n binning = r_binning * phi_binning * t_binning * phidir_binning\\n\\n for r_idx in range(binning.r.num_bins):\\n # Pick a bin that will have non-zero entries\\n out_binning, _ = pick_nonzero_bin(\\n binning=binning,\\n r_idx=r_idx,\\n phi_idx=0,\\n dom_radius=dom_radius,\\n speed_of_light=speed_of_light\\n )\\n #print('indices of bin0 in table:', indices0)\\n #print('bin0:\\\\n{}'.format(bin0))\\n\\n #indices0 = np.array(indices0)\\n\\n #r0_idx, phi0_idx, t0_idx, phidir0_idx = indices0\\n\\n # Get probs for nominal r and t bins +/- 2 bins away\\n #r_slice = slice(r0_idx - 2, r0_idx + 3)\\n #t_slice = slice(t0_idx - 2, t0_idx + 3)\\n #r_slice = slice(None)\\n #t_slice = slice(None)\\n #out_binning = binning[r_slice, phi0_idx, t_slice, phidir0_idx + 2]\\n\\n survival_probs = out_binning.empty(name='survival_prob')\\n geom_norms = out_binning.empty(name='geom_norm')\\n for bin_flat_idx, this_bin in enumerate(out_binning.iterbins()):\\n prob, num_hits = forward_survival_prob(\\n absorption_length=absorption_length,\\n binning=this_bin,\\n n_photons=n_photons,\\n dom_efficiency=dom_efficiency,\\n dom_radius=dom_radius,\\n speed_of_light=speed_of_light,\\n seed=seed\\n )\\n #print('')\\n survival_probs[out_binning.index2coord(bin_flat_idx)] = prob\\n geom_norms[out_binning.index2coord(bin_flat_idx)] = num_hits / n_photons\\n\\n print('Total time to run:', time() - t_start)\\n\\n return survival_probs, geom_norms, binning\",\n \"def prosody_dynamic(self, audio):\\n fs, data_audio = read(audio)\\n\\n if len(data_audio.shape)>1:\\n data_audio = data_audio.mean(1)\\n data_audio = data_audio-np.mean(data_audio)\\n data_audio = data_audio/float(np.max(np.abs(data_audio)))\\n size_frameS = self.size_frame*float(fs)\\n size_stepS = self.step*float(fs)\\n overlap = size_stepS/size_frameS\\n\\n if self.pitch_method == 'praat':\\n name_audio = audio.split('/')\\n temp_uuid = 'prosody'+name_audio[-1][0:-4]\\n if not os.path.exists(PATH+'/../tempfiles/'):\\n os.makedirs(PATH+'/../tempfiles/')\\n temp_filename_f0 = PATH+'/../tempfiles/tempF0'+temp_uuid+'.txt'\\n temp_filename_vuv = PATH+'/../tempfiles/tempVUV'+temp_uuid+'.txt'\\n praat_functions.praat_vuv(audio, temp_filename_f0, temp_filename_vuv,\\n time_stepF0=self.step, minf0=self.minf0, maxf0=self.maxf0)\\n\\n F0, _ = praat_functions.decodeF0(\\n temp_filename_f0, len(data_audio)/float(fs), self.step)\\n os.remove(temp_filename_f0)\\n os.remove(temp_filename_vuv)\\n elif self.pitch_method == 'rapt':\\n data_audiof = np.asarray(data_audio*(2**15), dtype=np.float32)\\n F0 = pysptk.sptk.rapt(data_audiof, fs, int(\\n size_stepS), min=self.minf0, max=self.maxf0, voice_bias=self.voice_bias, otype='f0')\\n\\n pitchON = np.where(F0 != 0)[0]\\n dchange = np.diff(pitchON)\\n change = np.where(dchange > 1)[0]\\n iniV = pitchON[0]\\n\\n featvec = []\\n iniVoiced = (pitchON[0]*size_stepS)+size_stepS\\n seg_voiced = []\\n f0v = []\\n Ev = []\\n for indx in change:\\n finV = pitchON[indx]+1\\n finVoiced = (pitchON[indx]*size_stepS)+size_stepS\\n VoicedSeg = data_audio[int(iniVoiced):int(finVoiced)]\\n temp = F0[iniV:finV]\\n tempvec = []\\n if len(VoicedSeg) > int(size_frameS):\\n seg_voiced.append(VoicedSeg)\\n dur = len(VoicedSeg)/float(fs)\\n x = np.arange(0,len(temp))\\n z = np.poly1d(np.polyfit(x,temp,self.P))\\n f0v.append(temp)\\n tempvec.extend(z.coeffs)\\n temp=get_energy_segment(size_frameS, size_stepS, VoicedSeg, overlap)\\n Ev.append(temp)\\n x = np.arange(0, len(temp))\\n z = np.poly1d(np.polyfit(x, temp, self.P))\\n tempvec.extend(z.coeffs)\\n tempvec.append(dur)\\n featvec.append(tempvec)\\n iniV = pitchON[indx+1]\\n iniVoiced = (pitchON[indx+1]*size_stepS)+size_stepS\\n\\n # Add the last voiced segment\\n finV = (pitchON[len(pitchON)-1])\\n finVoiced = (pitchON[len(pitchON)-1]*size_stepS)+size_stepS\\n VoicedSeg = data_audio[int(iniVoiced):int(finVoiced)]\\n temp = F0[iniV:finV]\\n tempvec = []\\n\\n if len(VoicedSeg) > int(size_frameS):\\n # Compute duration\\n dur = len(VoicedSeg)/float(fs)\\n \\n x = np.arange(0, len(temp))\\n z = np.poly1d(np.polyfit(x, temp, self.P))\\n tempvec.extend(z.coeffs)\\n # Energy coefficients\\n temp=get_energy_segment(size_frameS, size_stepS, VoicedSeg, overlap)\\n x = np.arange(0, len(temp))\\n z = np.poly1d(np.polyfit(x, temp, self.P))\\n tempvec.extend(z.coeffs)\\n tempvec.append(dur)\\n # Compute duration\\n featvec.append(tempvec)\\n\\n return np.asarray(featvec)\",\n \"def beam_property_along_s(ps, id_slices):\\n\\n prop_s = np.zeros((14, len(id_slices)))\\n for n in range(len(id_slices)):\\n ps_s = np.take(ps, id_slices[n], axis=1)\\n prop_s[0, n] = np.average(ps_s[0,:])\\n prop_s[1, n] = np.average(ps_s[1,:])\\n prop_s[2, n] = np.average(ps_s[2,:])\\n prop_s[3, n] = np.average(ps_s[3,:])\\n prop_s[4, n] = np.std(ps_s[0,:])\\n prop_s[5, n] = np.std(ps_s[2,:])\\n prop_s[6:, n] = emittance_and_twiss(ps_s)\\n\\n return prop_s\",\n \"def single_pulse_SCPI(pulsewidth, updown, high_voltage, low_voltage, channel = '1', *args, **kwargs):\\n\\tif pulsewidth[-2:] not in set({'ns', 'us', 'ms',}):\\n\\t\\tif pulsewidth[-1] != 's':\\n\\t\\t\\traise ValueError('pulsewidth ' + str(pulsewidth) + ' not supported')\\n\\tif updown not in set({'up', 'down'}):\\n\\t\\traise ValueError('updown ' + str(updown) + ' not supported')\\n\\tif high_voltage[-2:].lower() not in set({'mv'}):\\n\\t\\tif high_voltage[-1].lower() != 'v':\\n\\t\\t\\traise ValueError('high_voltage ' + str(high_voltage) + ' not supported')\\n\\tif low_voltage[-2:].lower() not in set({'mv'}):\\n\\t\\tif low_voltage[-1].lower() != 'v':\\n\\t\\t\\traise ValueError('low_voltage ' + str(low_voltage) + ' not supported')\\n\\tif channel not in set({'1', '2'}):\\n\\t\\traise ValueError('channel ' + str(channel) + ' not supported')\\n\\t\\n\\tif updown == 'up':\\n\\t\\tout = 'outp'+channel+':puls:mode sin;'\\n\\t\\tout += ':sour'+channel+':inv off;'\\n\\t\\tout += ':sour'+channel+':volt:lev:imm:high '+high_voltage + ';'\\n\\t\\tout += ':sour'+channel+':volt:lev:imm:low '+low_voltage + ';'\\n\\t\\t#puls1 means the first pulse because we are in single mode\\n\\t\\tout += ':sour'+channel+':puls1:wid '+pulsewidth + ';'\\n\\t\\treturn out\\n\\telse:\\n\\t\\tout = 'outp'+channel+':puls:mode sin;'\\n\\t\\tout += ':sour'+channel+':inv on;'\\n\\t\\tout += ':sour'+channel+':volt:lev:imm:low '+low_voltage + ';'\\n\\t\\tout += ':sour'+channel+':volt:lev:imm:high '+high_voltage + ';'\\n\\t\\t#puls1 means the first pulse because we are in single mode\\n\\t\\tout += ':sour'+channel+':puls1:wid '+pulsewidth + ';'\\n\\t\\treturn out\",\n \"def gen_pulsed_stimulus(T, dt, odor_idx, pulse_duration=(0.1, 0.5), n_stim=1):\\n # randomly sample pulse duration\\n pulses = np.random.uniform(pulse_duration[0], pulse_duration[1], size=100)\\n pulse_bins = (pulses / dt).astype(np.int).tolist()\\n random.shuffle(pulse_bins)\\n X = np.zeros((n_stim, int(T / dt)))\\n\\n # randomly position pulse - use poisson to have more variability in positioning\\n n_bins = int(T / dt)\\n spaced_pulses = [[1] * pulse_bins[0]]\\n start_bins = np.random.randint(0, n_bins-int(0.1/dt), size=200).astype(np.int).tolist()\\n #start_bins = (np.random.poisson(int(T * 100), size=10) / 100 / dt).astype(np.int)\\n #print(\\\"start_bins: {}\\\".format(start_bins))\\n start_bins = list(filter(lambda p: (p+pulse_bins[0]) < (n_bins-5), start_bins))\\n random.shuffle(start_bins)\\n #print(\\\"start_bins: {} | {} sec\\\".format(start_bins, np.array(start_bins)*dt))\\n start_bin = start_bins[0]\\n print(\\\"pulse offset: {}sec | duration: {}sec\\\".format(start_bin * dt, pulse_bins[0] * dt))\\n\\n pulse_times = [[] for _ in range(n_stim)]\\n for k, s in enumerate(spaced_pulses):\\n X[odor_idx, start_bin:start_bin + len(s)] = s\\n pulse_times[odor_idx].append(start_bin * dt)\\n\\n X_prime = np.c_[np.zeros((n_stim, 1)), X]\\n return X, [len(np.where(np.diff(X_prime[n, :]) == 1)[0]) for n in range(n_stim)], pulse_times\",\n \"def pulses_to_mps(pulses, period=10):\\n return pulses / (period * 4) # there are 4 pulses per rotation of the annemometer\",\n \"def ohms(self):\\n # Rwb = Rwiper + Rtotal * (counts / 256)\\n # Rwa = Rwiper + Rtotal * ((256 - counts) / 256)\\n g = 0\\n rtotal=0.0\\n reach=[]\\n for chan in self.get_channel_list(self.nchans):\\n self.rwa[chan] = float( 256 - self.vals[chan] ) / 256.0\\n self.rwb[chan] = float( self.vals[chan] ) / 256.0\\n self.rwa[chan] *= self.Rtotal\\n self.rwb[chan] *= self.Rtotal \\n self.rwa[chan] += self.Rwiper\\n self.rwb[chan] += self.Rwiper\",\n \"def getCalibration(self):\\n self.a0 = float(self.getParameter(index=1))\\n self.a1 = float(self.getParameter(index=2))\\n self.a2 = float(self.getParameter(index=3))\\n self.a3 = float(self.getParameter(index=4))\\n status = self.getStatus()\\n self.wavelength = [ self.a0 + self.a1*x + self.a2*x*x + self.a3*x*x*x \\n for x in range(status.pixels)]\\n if self.discardTrailingSamples > 0:\\n self.wavelength = self.wavelength[:-self.discardTrailingSamples]\\n if self.discardLeadingSamples > 0:\\n self.wavelength = self.wavelength[self.discardLeadingSamples:]\",\n \"def delay(self):\\r\\n p_shape = self.phase.shape[:-1]\\r\\n delay = np.zeros(self.phase.shape)\\r\\n for i in range(p_shape[0]):\\r\\n for j in range(p_shape[1]):\\r\\n this_phase = self.phase[i, j]\\r\\n #If requested, unwrap the phases:\\r\\n if self._unwrap_phases:\\r\\n this_phase = tsu.unwrap_phases(this_phase)\\r\\n\\r\\n delay[i, j] = this_phase / (2 * np.pi * self.frequencies)\\r\\n\\r\\n return delay\",\n \"def read(self):\\n interval = self._low_ticks + self._high_ticks\\n\\n if interval > 0:\\n ratio = float(self._low_ticks)/float(interval)*100.0\\n conc = 1.1*pow(ratio,3)-3.8*pow(ratio,2)+520*ratio+0.62;\\n else:\\n ratio = 0\\n conc = 0.0\\n\\n self._start_tick = None\\n self._last_tick = None\\n self._low_ticks = 0\\n self._high_ticks = 0\\n\\n return (self.gpio, ratio, conc)\",\n \"def test_str_pulse(self):\\n xknx = XKNX()\\n sensor = Sensor(\\n xknx, \\\"TestSensor\\\", group_address_state=\\\"1/2/3\\\", value_type=\\\"pulse\\\"\\n )\\n sensor.sensor_value.payload = DPTArray((0xFC,))\\n\\n self.assertEqual(sensor.resolve_state(), 252)\\n self.assertEqual(sensor.unit_of_measurement(), \\\"counter pulses\\\")\\n self.assertEqual(sensor.ha_device_class(), None)\",\n \"def __getPressureCalibrationCoefficients(self):\\n src13 = self.read_byte_data(self.address, 0x13)\\n src14 = self.read_byte_data(self.address, 0x14)\\n src15 = self.read_byte_data(self.address, 0x15)\\n src16 = self.read_byte_data(self.address, 0x16)\\n src17 = self.read_byte_data(self.address, 0x17)\\n src18 = self.read_byte_data(self.address, 0x18)\\n src19 = self.read_byte_data(self.address, 0x19)\\n src1A = self.read_byte_data(self.address, 0x1A)\\n src1B = self.read_byte_data(self.address, 0x1B)\\n src1C = self.read_byte_data(self.address, 0x1C)\\n src1D = self.read_byte_data(self.address, 0x1D)\\n src1E = self.read_byte_data(self.address, 0x1E)\\n src1F = self.read_byte_data(self.address, 0x1F)\\n src20 = self.read_byte_data(self.address, 0x20)\\n src21 = self.read_byte_data(self.address, 0x21)\\n c00 = (src13 << 12) | (src14 << 4) | (src15 >> 4)\\n c00 = getTwosComplement(c00, 20)\\n c10 = ((src15 & 0x0F) << 16) | (src16 << 8) | src17\\n c10 = getTwosComplement(c10, 20)\\n c20 = (src1C << 8) | src1D\\n c20 = getTwosComplement(c20, 16)\\n c30 = (src20 << 8) | src21\\n c30 = getTwosComplement(c30, 16)\\n c01 = (src18 << 8) | src19\\n c01 = getTwosComplement(c01, 16)\\n c11 = (src1A << 8) | src1B\\n c11 = getTwosComplement(c11, 16)\\n c21 = (src1E < 8) | src1F\\n c21 = getTwosComplement(c21, 16)\\n return c00, c10, c20, c30, c01, c11, c21\",\n \"def pulse_width_percent(self, value: int | float, /) -> None:\",\n \"def time_function(self, t):\\n\\n\\tif type(t) == float:\\n\\t if t > self.pulse_duration:\\n\\t\\tfield_strength = 0.0\\n\\t else:\\n\\t\\tfield_strength = (self.amplitude * \\n\\t\\t sin(pi * t / self.pulse_duration)**2 * \\n\\t\\t cos(self.omega * t))\\n\\telse:\\n\\t field_strength = zeros(shape(t))\\n\\t for i, time in enumerate(t):\\n\\t\\tif time > self.pulse_duration:\\n\\t\\t temp_field_strength = 0.0\\n\\t\\telse:\\n\\t\\t temp_field_strength = (self.amplitude * \\n\\t\\t\\tsin(pi * time / self.pulse_duration)**2 * \\n\\t\\t\\tcos(self.omega * time))\\n\\n\\t\\tfield_strength[i] = temp_field_strength\\n\\t\\n\\treturn field_strength\",\n \"def calc(self,index, counter_values):\\n try:\\n angles = self.ik220_dev.read_attribute('Angles').value\\n if index == 9:\\n return sum(angles[:3])/3.0 # Excluded channel 4 of grating pitch encoder because of problems of Homing in the last header of the RON grating encoder.\\n elif index == 10:\\n return sum(angles[4:6])/2.0 # Modified from 4 channels to 2 channels because of problems of Homing in the 2 last headers of the RON mirror3 encoder.\\n else:\\n return angles[index - 1]\\n except:\\n return 1e-100\",\n \"def _pulse_enable(self):\\n self.set_low(self._en_pin)\\n self._usleep(1)\\n self.set_high(self._en_pin)\\n self._usleep(1)\\n self.set_low(self._en_pin)\\n # commands need > 37us to settle\\n self._usleep(100)\",\n \"def raw_measure(self) -> List[int]:\\n # name, command, signals, delay\\n return self._run_profile((\\\"raw_measure\\\", [0x20, 0x50], 2, 0.025))\",\n \"def get_chisqrs(prf,diff,nbins): \\n off_pulse = np.zeros(39)\\n off_pulse[:20] = prf[:20]\\n off_pulse[20:] = prf[45:] #Making off pulse region\\n # print(\\\"Off pulse Region \\\",off_pulse)\\n op_rms = np.var(off_pulse) #Rms\\n # print(\\\"Off pulse RMS \\\",op_rms)\\n s = 0\\n for d in diff:\\n s += d**2/op_rms\\n\\n s = s/(nbins - 1)\\n # print(\\\"Chisqr value = \\\",s)\\n\\n return s\",\n \"def calibration(self) -> int:\",\n \"def setInternalPulser(self,pulserEnable,pulseHeight):\\n pass\",\n \"def test_noisy_pulse(self):\\n coeff = np.array([0.1, 0.2, 0.3, 0.4])\\n tlist = np.array([0., 1., 2., 3.])\\n ham = sigmaz()\\n pulse1 = Pulse(ham, 1, tlist, coeff)\\n # Add coherent noise and lindblad noise with different tlist\\n pulse1.spline_kind = \\\"step_func\\\"\\n tlist_noise = np.array([0., 1., 2.5, 3.])\\n coeff_noise = np.array([0., 0.5, 0.1, 0.5])\\n pulse1.add_coherent_noise(sigmay(), 0, tlist_noise, coeff_noise)\\n tlist_noise2 = np.array([0., 0.5, 2, 3.])\\n coeff_noise2 = np.array([0., 0.1, 0.2, 0.3])\\n pulse1.add_lindblad_noise(sigmax(), 1, coeff=True)\\n pulse1.add_lindblad_noise(\\n sigmax(), 0, tlist=tlist_noise2, coeff=coeff_noise2)\\n\\n assert_allclose(\\n pulse1.get_ideal_qobjevo(2)(0).full(),\\n tensor(identity(2), sigmaz()).full() * 0.1)\\n noise_qu, c_ops = pulse1.get_noisy_qobjevo(2)\\n assert_allclose(\\n pulse1.get_full_tlist(), np.array([0., 0.5, 1., 2., 2.5, 3.]))\\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\\n expected = QobjEvo([\\n [tensor(identity(2), sigmaz()),\\n np.array([0.1, 0.1, 0.2, 0.3, 0.3, 0.4])],\\n [tensor(sigmay(), identity(2)),\\n np.array([0., 0., 0.5, 0.5, 0.1, 0.5])]\\n ],\\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\\n order=0)\\n else:\\n expected = QobjEvo([\\n [tensor(identity(2), sigmaz()),\\n np.array([0.1, 0.1, 0.2, 0.3, 0.3, 0.4])],\\n [tensor(sigmay(), identity(2)),\\n np.array([0., 0., 0.5, 0.5, 0.1, 0.5])]\\n ],\\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\\n args={\\\"_step_func_coeff\\\": True})\\n _compare_qobjevo(noise_qu, expected, 0, 3)\\n\\n for c_op in c_ops:\\n try:\\n isconstant = c_op.isconstant\\n except AttributeError:\\n isconstant = (len(c_op.ops) == 0)\\n if isconstant:\\n assert_allclose(c_op(0).full(),\\n tensor(identity(2), sigmax()).full())\\n else:\\n if parse_version(qutip.__version__) >= parse_version('5.dev'):\\n expected = QobjEvo(\\n [tensor(sigmax(), identity(2)),\\n np.array([0., 0.1, 0.1, 0.2, 0.2, 0.3])],\\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\\n order=0)\\n else:\\n expected = QobjEvo(\\n [tensor(sigmax(), identity(2)),\\n np.array([0., 0.1, 0.1, 0.2, 0.2, 0.3])],\\n tlist=np.array([0., 0.5, 1., 2., 2.5, 3.]),\\n args={\\\"_step_func_coeff\\\": True})\\n _compare_qobjevo(c_op, expected, 0, 3)\",\n \"def test_pressure_increasing_check_all_pass(mocker, pressure_values):\\n profile = mocker.patch.object(argortqcpy.profile, \\\"Profile\\\")\\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\\n\\n pic = PressureIncreasingCheck(profile, None)\\n output = pic.run()\\n\\n assert np.all(output.get_output_flags_for_property(\\\"PRES\\\").data == ArgoQcFlag.GOOD.value)\",\n \"def _calc(self):\\r\\n tot_sum: float = 0 # ? total sum of the noise values\\r\\n max_amp: float = 0 # ? keep the sum in [0,1]\\r\\n amp: float = 1.0 # ? amplitude of each noise value\\r\\n freq: float = 1.0 # ? frequency for getting the detailed noise\\r\\n\\r\\n # for each octave we twice the frequency and multiply the amplitude \\r\\n # by persistance to get the detailed noise value\\r\\n # to keep the final sum value in the range [0, 1] we keep track of the \\r\\n # max amplitude (sum of all the amplitudes)\\r\\n for octave in range(self.octaves):\\r\\n noise_obj = PerlinNoise(self.inp_x*freq, self.inp_y*freq, self.inp_z*freq)\\r\\n # ? multiply the noise value by the amplitude\\r\\n tot_sum += noise_obj.val() * amp\\r\\n max_amp += amp\\r\\n\\r\\n amp *= self.persist\\r\\n freq *= 2.0 # double the freq each iteration\\r\\n\\r\\n # value is in the range [0,1]\\r\\n self.value = tot_sum / max_amp\",\n \"def initialize_2pulse(pg, channel = '1', pulsewidth = '10e-9', delay = '10e-9',\\n\\t\\t\\t\\t\\t low_voltage = '0', high_voltage = '4.8'):\\n\\terr = ''\\n\\twhile err != 'Error: 0, No error\\\\n':#clear errors\\n\\t\\terr = pg.query('syst:err:next?')\\n\\n\\tpgchannel = channel\\n\\tpw = pulsewidth\\n\\n\\tdelay1 = str(float(pw) + float(delay))\\n\\tdelay2 = str(float(delay1)*2)\\n\\tpg.write('outp'+pgchannel+':puls:mode dou')\\n\\tpg.write('source'+pgchannel+':pulse1:wid '+pw)\\n\\tpg.write('source'+pgchannel+':pulse2:wid '+pw)\\n\\n\\tpg.write('source'+pgchannel+':pulse1:del '+'0')\\n\\tpg.write('source'+pgchannel+':pulse2:del '+delay1)\\n\\n\\tpg.write('source'+pgchannel+':volt:lev:imm:low '+low_voltage)\\n\\tpg.write('source'+pgchannel+':volt:lev:imm:high '+high_voltage)\\n\\tpg.write('trig:seq:sour man')\\n\\tpg.write('outp'+pgchannel+':stat on')\\n\\tpg.write('PULSEGENControl:START')\\n\\tif pg.query('syst:err:next?') != 'Error: 0, No error\\\\n':\\n\\t\\tstop(pg,)\\n\\t\\traise ValueError('error in initialize_2pulse init')\\n\\t\\t\\n\\treturn\",\n \"def __init__(\\n self,\\n acquire_alignment: int = 1,\\n pulse_alignment: int = 1,\\n ):\\n super().__init__()\\n self.acquire_align = acquire_alignment\\n self.pulse_align = pulse_alignment\",\n \"def generatePulseSequence(ham: Dict[str, Any], name: Union[str, List[str]]) -> List[float]:\\n\\n assert isinstance(name, str), \\\"In generatePulseSequence, para `names` only accepts str.\\\"\\n\\n dt = ham[\\\"circuit\\\"][\\\"dt\\\"]\\n maxDt = ham[\\\"circuit\\\"][\\\"max_time_dt\\\"]\\n\\n ctrls = ham[\\\"control\\\"][name]\\n sequenceList = []\\n # Traverse all the time slices.\\n for nowDt in range(0, maxDt):\\n currentAmp = 0\\n nowNs = nowDt * dt + dt / 2\\n # Traverse all the waveforms\\n for waveForm in ctrls[\\\"waveforms\\\"]:\\n insertNs = waveForm[\\\"insert_ns\\\"]\\n endNs = waveForm[\\\"insert_ns\\\"] + waveForm[\\\"duration_ns\\\"]\\n if insertNs <= nowNs < endNs:\\n # Calculate the waveforms' amplitudes.\\n waveFunc = waveForm[\\\"func\\\"]\\n if waveFunc is None:\\n seq = waveForm[\\\"sequence\\\"]\\n realTime = nowNs - waveForm[\\\"insert_ns\\\"]\\n if int(realTime / dt) >= len(seq):\\n currentAmp += seq[-1]\\n else:\\n currentAmp += seq[int(realTime / dt)]\\n elif isinstance(waveFunc, str):\\n currentAmp += play(waveForm[\\\"func\\\"], nowNs - waveForm[\\\"insert_ns\\\"], waveForm[\\\"para\\\"])\\n elif callable(waveFunc):\\n currentAmp += waveFunc(nowNs - waveForm[\\\"insert_ns\\\"], waveForm[\\\"para\\\"])\\n else:\\n assert False, \\\"Unsupported type of func.\\\"\\n sequenceList.append(currentAmp)\\n\\n return sequenceList\",\n \"def __init__(self):\\n self.risepower = 4.\\n self.min_event_amplitude = 5.0e-12 # pA default\\n self.template = None\\n pass\",\n \"def get_prop(self):\\n\\t\\tnewframe = copy.deepcopy(self)\\n\\t\\tfor f in newframe.header[1:]:\\n\\t\\t\\tsum = newframe.sum_field(f)\\n\\t\\t\\tfor d in newframe:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\td[f]= d[f]/float(sum)*100\\n\\t\\t\\t\\texcept ZeroDivisionError:\\n\\t\\t\\t\\t\\td[f] = 0\\n\\t\\t\\n\\t\\treturn newframe\",\n \"def rectpulse(L, fsT, normalize = True):\\n u = np.ones(L * fsT, dtype='float')\\n\\n # Normalize so that the integral of the pulse is 1/2 max\\n if normalize:\\n u = u / (2.0 * np.sum(u))\\n \\n return u\",\n \"def hasPulse(self):\\n return True if self.pulses is not None else False\",\n \"def amaoccupancyscore(pwm_dictionary, seq):\\n if \\\"N\\\" in seq:\\n return 0\\n else:\\n # pwm_length = len(pwm_dictionary)\\n pwm_length = len(pwm_dictionary[\\\"A\\\"])\\n occupancy_list = []\\n pwm_dictionary_rc = rc_pwm(pwm_dictionary, pwm_length)\\n for i in range(len(seq) - 1):\\n occupancy = 1\\n occupancy_rc = 1\\n for j in range(pwm_length - 1):\\n if (j + i) >= len(seq):\\n occupancy *= 0.25\\n occupancy_rc *= 0.25\\n else:\\n occupancy *= pwm_dictionary[seq[j + i]][j]\\n occupancy_rc *= pwm_dictionary_rc[seq[j + i]][j]\\n occupancy_list.append(occupancy + occupancy_rc)\\n ama_occupancy = sum(occupancy_list) / len(occupancy_list)\\n return ama_occupancy\",\n \"def calculate_averaged_properties_cpp(poly_data):\\n\\n gt_filter = vtkParticlesPython.vtkGranularTemperature()\\n if vtk.vtkVersion.GetVTKMajorVersion() < 6:\\n gt_filter.SetInput(poly_data)\\n else:\\n gt_filter.SetInputData(poly_data)\\n gt_filter.Update()\\n poly_data.DeepCopy(gt_filter.GetOutput())\\n\\n return numpy_support.vtk_to_numpy(poly_data.GetPointData().GetVectors(\\\"SolidPressureGradient\\\"))\",\n \"def measure_state(self, pulse, out1, out2, res, adc=None):\\n bias = self.saved_data[\\\"bias\\\"]\\n # currently it allows only 3 states\\n\\n d1_st0 = declare(fixed)\\n d2_st0 = declare(fixed)\\n d1_st1 = declare(fixed)\\n d2_st1 = declare(fixed)\\n d1_st2 = declare(fixed)\\n d2_st2 = declare(fixed)\\n\\n st0 = declare(fixed)\\n st1 = declare(fixed)\\n st2 = declare(fixed)\\n\\n measure(\\n pulse,\\n self.rr_qe,\\n adc,\\n demod.full(f\\\"state_0_in1_{self.rr_qe}\\\", d1_st0, out1),\\n demod.full(f\\\"state_0_in2_{self.rr_qe}\\\", d2_st0, out2),\\n demod.full(f\\\"state_1_in1_{self.rr_qe}\\\", d1_st1, out1),\\n demod.full(f\\\"state_1_in2_{self.rr_qe}\\\", d2_st1, out2),\\n demod.full(f\\\"state_2_in1_{self.rr_qe}\\\", d1_st2, out1),\\n demod.full(f\\\"state_2_in2_{self.rr_qe}\\\", d2_st2, out2),\\n )\\n\\n assign(st0, d1_st0 + d2_st0 - bias[0])\\n assign(st1, d1_st1 + d2_st1 - bias[1])\\n assign(st2, d1_st2 + d2_st2 - bias[2])\\n\\n with if_((st0 >= st1) & (st0 >= st2)):\\n assign(res, 0)\\n with if_((st1 >= st0) & (st1 >= st2)):\\n assign(res, 1)\\n with if_((st2 >= st0) & (st2 >= st1)):\\n assign(res, 2)\",\n \"def read_particle_measurement(self):\\n self.port.write(self.READ_PM_RESULTS)\\n result = bytearray(self.port.read(8))\\n if not result:\\n # Timeout\\n return None\\n if len(result) != 8:\\n # Sometimes not enough results are returned\\n logger.error(\\\"Didn't get enough data back\\\")\\n return None\\n head, length, cmd, df1, df2, df3, df4, cs = result\\n assert self.is_checksum_valid(result)\\n return 256*df1 + df2, 256*df3 + df4\",\n \"def pressure_ashpa(self):\\n hpa = None # Variable declaration\\n raw_comp1 = None # Variable declaration\\n raw_comp2 = None # Variable declaration\\n raw_comp3 = None # Variable declaration\\n raw_pressure = None # Variable declaration\\n raw_temperature = None # Variable declaration\\n value_d_p1 = None # Variable declaration\\n value_d_p2 = None # Variable declaration\\n value_d_p3 = None # Variable declaration\\n value_d_p4 = None # Variable declaration\\n value_d_p5 = None # Variable declaration\\n value_d_p6 = None # Variable declaration\\n value_d_p7 = None # Variable declaration\\n value_d_p8 = None # Variable declaration\\n value_d_p9 = None # Variable declaration\\n value_lsb = None # Variable declaration\\n value_msb = None # Variable declaration\\n value_xlsb = None # Variable declaration\\n\\n value_msb = self.get_pressuremsb()\\n value_lsb = self.get_pressurelsb()\\n value_xlsb = self.get_pressurexlsb()\\n value_d_p1 = self.get_digp1()\\n value_d_p2 = self.get_digp2()\\n value_d_p3 = self.get_digp3()\\n value_d_p4 = self.get_digp4()\\n value_d_p5 = self.get_digp5()\\n value_d_p6 = self.get_digp6()\\n value_d_p7 = self.get_digp7()\\n value_d_p8 = self.get_digp8()\\n value_d_p9 = self.get_digp9()\\n raw_temperature = self.temperature_ascelsius()\\n raw_temperature = (raw_temperature*5120.0)\\n raw_pressure = ((value_msb << 12)+(value_lsb << 4)+(value_xlsb >> 4))\\n raw_comp1 = ((raw_temperature/2)-64000.0)\\n raw_comp2 = ((raw_comp1*raw_comp1*value_d_p6)/32768.0)\\n raw_comp2 = (raw_comp2+(raw_comp1*value_d_p5*2.0))\\n raw_comp2 = ((raw_comp2/4.0)+(value_d_p4*65536.0))\\n raw_comp3 = (value_d_p3*raw_comp1*raw_comp1)\\n raw_comp1 = (((raw_comp3/524288.0)+(value_d_p2*raw_comp1))/524288.0)\\n raw_comp1 = ((1.0+(raw_comp1/32768.0))*value_d_p1)\\n hpa = (1048576.0-raw_pressure)\\n hpa = ((hpa-(raw_comp2/4096.0))*(6250.0/raw_comp1))\\n raw_comp1 = ((value_d_p9*hpa*hpa)/2147483648.0)\\n raw_comp2 = ((hpa*value_d_p8)/32768.0)\\n hpa = (hpa+((raw_comp1+raw_comp2+value_d_p7)/16.0))\\n hpa = (hpa/100.0)\\n return hpa\",\n \"def _concatenate_pulses(\\n self, pulse_instructions, scheduled_start_time, num_controls\\n ):\\n min_step_size = np.inf\\n # Concatenate tlist and coeffs for each control pulses\\n compiled_tlist = [[] for tmp in range(num_controls)]\\n compiled_coeffs = [[] for tmp in range(num_controls)]\\n for pulse_ind in range(num_controls):\\n last_pulse_time = 0.0\\n for start_time, tlist, coeff in pulse_instructions[pulse_ind]:\\n # compute the gate time, step size and coeffs\\n # according to different pulse mode\\n (\\n gate_tlist,\\n coeffs,\\n step_size,\\n pulse_mode,\\n ) = self._process_gate_pulse(start_time, tlist, coeff)\\n min_step_size = min(step_size, min_step_size)\\n\\n if abs(last_pulse_time) < step_size * 1.0e-6: # if first pulse\\n compiled_tlist[pulse_ind].append([0.0])\\n if pulse_mode == \\\"continuous\\\":\\n compiled_coeffs[pulse_ind].append([0.0])\\n # for discrete pulse len(coeffs) = len(tlist) - 1\\n\\n # If there is idling time between the last pulse and\\n # the current one, we need to add zeros in between.\\n if np.abs(start_time - last_pulse_time) > step_size * 1.0e-6:\\n idling_tlist = self._process_idling_tlist(\\n pulse_mode, start_time, last_pulse_time, step_size\\n )\\n compiled_tlist[pulse_ind].append(idling_tlist)\\n compiled_coeffs[pulse_ind].append(\\n np.zeros(len(idling_tlist))\\n )\\n\\n # Add the gate time and coeffs to the list.\\n execution_time = gate_tlist + start_time\\n last_pulse_time = execution_time[-1]\\n compiled_tlist[pulse_ind].append(execution_time)\\n compiled_coeffs[pulse_ind].append(coeffs)\\n\\n final_time = np.max([tlist[-1][-1] for tlist in compiled_tlist])\\n for pulse_ind in range(num_controls):\\n if not compiled_tlist[pulse_ind]:\\n continue\\n last_pulse_time = compiled_tlist[pulse_ind][-1][-1]\\n if np.abs(final_time - last_pulse_time) > min_step_size * 1.0e-6:\\n idling_tlist = self._process_idling_tlist(\\n pulse_mode, final_time, last_pulse_time, min_step_size\\n )\\n compiled_tlist[pulse_ind].append(idling_tlist)\\n compiled_coeffs[pulse_ind].append(np.zeros(len(idling_tlist)))\\n\\n for i in range(num_controls):\\n if not compiled_coeffs[i]:\\n compiled_tlist[i] = None\\n compiled_coeffs[i] = None\\n else:\\n compiled_tlist[i] = np.concatenate(compiled_tlist[i])\\n compiled_coeffs[i] = np.concatenate(compiled_coeffs[i])\\n return compiled_tlist, compiled_coeffs\",\n \"def enable_pulse_modulation(self):\\n self.write(\\\":SOUR:PULM:STAT ON\\\")\",\n \"def __init__(self, name=\\\"untitled\\\", pulseGenerator=None, start1=0, stop1=10000, start2=None, stop2=None):\\n self.name = name\\n self._pulseGenerator = pulseGenerator\\n self._numberOfPoints = self._pulseGenerator.numberOfPoints()\\n self._samplingTime = self._pulseGenerator.samplingTime()\\n self._shape1 = numpy.zeros(self._numberOfPoints)\\n self._shape2 = numpy.zeros(self._numberOfPoints)\\n self._shape1[:] = getattr(generatorFunctionLib, 'square')(\\n self._numberOfPoints, self._samplingTime, start1, stop1, amplitude=1)\\n if start2 is None:\\n start2 = start1\\n if stop2 is None:\\n stop2 = stop1\\n self._shape2[:] = getattr(generatorFunctionLib, 'square')(\\n self._numberOfPoints, self._samplingTime, start2, stop2, amplitude=2)\\n self.markerArray = [sum(i)for i in zip(self._shape1, self._shape2)]\",\n \"def events(self):\\n\\n events = []\\n # Update the totals\\n self.update_totals()\\n\\n # Replication - total number of bacteria of metabolism * prob of replication\\n events.append((self.total_f * self.rates[P_REPLICATE_FAST], lambda f: self.replicate(BACTERIA_FAST)))\\n events.append((self.total_s * self.rates[P_REPLICATE_SLOW], lambda f: self.replicate(BACTERIA_SLOW)))\\n events.append((self.total_intra * self.rates[P_REPLICATE_INTRACELLULAR],\\n lambda f: self.replicate(BACTERIA_INTRACELLULAR)))\\n\\n # Metabolism change - sum of (number of bacteria of metabolism in patch * o2 tension) * prob of change\\n # TODO - check if this is ok\\n events.append((self.total_f_o2 * self.rates[P_CHANGE_FAST_SLOW], lambda f: self.change(BACTERIA_SLOW)))\\n events.append((self.total_s_o2 * self.rates[P_CHANGE_SLOW_FAST], lambda f: self.change(BACTERIA_FAST)))\\n\\n # Migrate - sum of (number of bacteria of metabolism in patch * degree of patch) * prob of migration\\n events.append((self.total_f_degree * self.rates[P_MIGRATE_FAST], lambda f: self.migrate(BACTERIA_FAST)))\\n events.append((self.total_s_degree * self.rates[P_MIGRATE_SLOW], lambda f: self.migrate(BACTERIA_SLOW)))\\n\\n # Recruit mac - num of nodes * prob of recruit\\n events.append((len(self.nodes()) * self.rates[P_RECRUIT], lambda f: self.recruit_mac()))\\n\\n # Death of mac - total number of macs * prob of death\\n events.append((self.total_mac_regular * self.rates[P_DEATH_REGULAR],\\n lambda f: self.death_mac(MACROPHAGE_REGULAR)))\\n events.append((self.total_mac_infected * self.rates[P_DEATH_INFECTED],\\n lambda f: self.death_mac(MACROPHAGE_INFECTED)))\\n\\n # Mac ingest - sum of (number of bacteria of metabolism in patch * num of macrophages in patch) * prob of ingest\\n events.append((self.total_regular_fast * self.rates[P_REGULAR_INGEST_FAST],\\n lambda f: self.ingest(BACTERIA_FAST, MACROPHAGE_REGULAR)))\\n events.append((self.total_regular_slow * self.rates[P_REGULAR_INGEST_SLOW],\\n lambda f: self.ingest(BACTERIA_SLOW, MACROPHAGE_REGULAR)))\\n events.append((self.total_infected_fast * self.rates[P_INFECTED_INGEST_FAST],\\n lambda f: self.ingest(BACTERIA_FAST, MACROPHAGE_INFECTED)))\\n events.append((self.total_infected_slow * self.rates[P_INFECTED_INGEST_SLOW],\\n lambda f: self.ingest(BACTERIA_SLOW, MACROPHAGE_INFECTED)))\\n\\n # Activation\\n events.append((self.total_activation * self.rates[P_ACTIVATION], lambda f: self.activate()))\\n\\n return events\",\n \"def _get_speed(self):\\n t_now = time.perf_counter()\\n delta_t = t_now - self._t_last_count\\n p = self._pulse\\n if p: # if pulses > 0, reset counter and timer\\n self._t_last_count = t_now\\n self._pulse = 0\\n else:\\n return 0.0\\n rps = (p / self._ppr) * delta_t # wheel rotations per second.\\n mps = rps * self._wheel_circumference\\n return mps\",\n \"def read_raw(self):\\n beats = self.microblaze.read_mailbox(0x4)\\n interval_ms = self.microblaze.read_mailbox(0x8 + (beats % 4)*4)\\n return beats, interval_ms\",\n \"def set_pulse_width(self):\\n\\t\\t\\\"\\\"\\\"For PWM Register-0\\\"\\\"\\\"\\n\\t\\tbus.write_byte_data(PCA9530_2C_1_DEFAULT_ADDRESS, PCA9530_2C_1_REG_PWM0, PCA9530_2C_1_PWM0_USERDEFINED)\\n\\t\\t\\n\\t\\t\\\"\\\"\\\"For PWM Register-1\\\"\\\"\\\"\\n\\t\\tbus.write_byte_data(PCA9530_2C_1_DEFAULT_ADDRESS, PCA9530_2C_1_REG_PWM1, PCA9530_2C_1_PWM1_USERDEFINED)\",\n \"def pulses(waveform,template,tmax,thresh,deltat,tbef,tafter):\\n print ' find pulses '\\n wave = np.copy(waveform)\\n ifig = 0\\n\\n tp = []\\n ap = []\\n plot = False\\n lfront = int(np.argmax(template)) # length of template before the peak \\n #lfront = 100\\n lback = int(len(template) - lfront) # length of template after the peak\\n \\n ibeg = tbef + 0\\n iend = tafter + 0\\n \\n while ibeg < iend:\\n \\n if plot:\\n ifig += 1\\n plt.figure(ifig)\\n plt.plot(wave)\\n \\n wh = np.where(wave[ibeg:iend] > thresh)\\n if len(wh[0])==0:\\n break\\n ith = int(wh[0][0] + ibeg)\\n #print 'threshold crossing ', ith \\n valmax = np.max(wave[ith:ith+deltat])\\n #print wave[ith:ith+deltat]\\n posmax = int(ith + np.argmax(wave[ith:ith+deltat]))\\n tp.append(posmax)\\n ap.append(valmax)\\n #print 'pos ',posmax, ' value ',wave[posmax]\\n if plot:\\n ifig += 1\\n print posmax,lfront,lback,ith,ith+deltat\\n plt.figure(ifig)\\n plt.plot(wave[posmax-lfront:posmax+lback])\\n plt.plot(valmax*template)\\n \\n for i in range(min(len(template),len(wave)-posmax)):\\n wave[posmax-lfront+i] += -valmax*template[i]\\n \\n ibeg += deltat\\n if plot:\\n plt.show()\\n #print 'done pulses'\\n \\n return tp,ap\",\n \"def pumpprobe_signal_test_build():\\r\\n inst.write(\\\"*RST\\\")\\r\\n #inst.write(\\\"DISP OFF\\\")\\r\\n inst.write(\\\":TRAC:CHAN1 ON\\\") # enables channel coupling at output 1\\r\\n inst.write(\\\":FUNC1 USER\\\") # set signal output to Arbitrary\\r\\n inst.write(\\\"FUNC1:USER p_short_1per\\\") # set Arbitrary waveform to pump pulse\\r\\n #inst.query(\\\"FUNC1:USER?\\\")\\r\\n #inst.write(\\\"FUNC1 USER\\\")\\r\\n #inst.write(\\\"FUNC1:USER 100KHZ, 0.1\\\") #FUNC can't seem to overwrite freq & amp settings\\r\\n \\r\\n inst.write(\\\":VOLT1 1\\\")\\r\\n inst.write(\\\":FREQ1 200KHZ\\\") \\r\\n \\r\\n inst.write(\\\":AM1:DEPT 100PCT\\\")\\r\\n inst.write(\\\":AM1:STAT ON\\\") #AM needs activation using STATus ON\\r\\n \\r\\n inst.write(\\\":AM1:SOUR EXT\\\") #sets source of AM\\r\\n \\r\\n \\r\\n inst.write(\\\"FUNC2:USER probe_2_12_p\\\")\\r\\n #inst.query(\\\"FUNC2:USER?\\\")\\r\\n inst.write(\\\":VOLT2 .1\\\")\\r\\n inst.write(\\\":FREQ2 200KHZ\\\")\\r\\n inst.write(\\\":AM2:DEPT 100PCT\\\")\\r\\n inst.write(\\\":AM2:STAT ON\\\")\\r\\n \\r\\n inst.write(\\\"CHAN:MATH plus\\\") #adds both channels at one output\\r\\n inst.write(\\\":OUTP1 ON\\\")\",\n \"def PTS(self):\",\n \"def v(self):\\n\\n # TODO This translation formula works, but needs simplified.\\n\\n # PWM duration can go from 0 to 4095 with 4095 representing max rpm\\n# print(\\\"MuleBot.v MuleBot.dcMotorPWMDurationLeft:\\\", MuleBot.dcMotorPWMDurationLeft)\\n speed_percentage = float(MuleBot.dcMotorPWMDurationLeft) / 4095.0\\n# print(\\\"speed_percentage: \\\", speed_percentage)\\n\\n rpm = speed_percentage * self.motorMaxRPM\\n# print(\\\"rpm: \\\", rpm)\\n\\n secondsPerMinute = 60\\n revs_per_second = rpm / secondsPerMinute\\n# print(\\\"--revs_per_second\\\", revs_per_second)\\n\\n inches_per_rev = 2.0 * math.pi * MuleBot.WHEEL_RADIUS\\n INCHES_PER_METER = 39.3701\\n meters_per_rev = inches_per_rev / INCHES_PER_METER\\n# print(\\\"--meters_per_rev\\\", meters_per_rev)\\n\\n meters_per_second = meters_per_rev * revs_per_second\\n\\n# print(\\\"--meters_per_second: \\\", meters_per_second)\\n return meters_per_second\",\n \"def main(ms, field, use_astropy, calcweights, binwidth):\\n\\n parang = ParallacticAngle(ms=ms, use_astropy=use_astropy)\\n\\n if calcweights:\\n weights, bins = parang.parang_weights(bin_width=binwidth)\\n # Create fractional weights - this doesn't change anything in the averaging\\n weights = weights/np.sum(weights)\\n\\n with open('parang_weights.txt', 'w') as fptr:\\n fptr.write(\\\"#parang weight\\\\n\\\")\\n for ww, bb in zip(weights, bins):\\n fptr.write(\\\"%.2f % .2f\\\\n\\\" % (bb, ww))\\n\\n logger.info(f\\\"First parallactic angle is : {parang.parang_start:.2f}\\\")\\n logger.info(f\\\"Middle parallactic angle is : {parang.parang_mid:.2f}\\\")\\n logger.info(f\\\"Last parallactic angle is : {parang.parang_end:.2f}\\\")\\n\\n plt.style.use('seaborn-poster')\\n\\n fig, ax = plt.subplots(1, 1)\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n\\n ax.plot(parang.source_times.to_datetime(), parang.parangs, 'o')\\n fmt = DateFormatter('%Y-%m-%d %H:%M')\\n ax.xaxis.set_major_formatter(fmt)\\n ax.xaxis.set_tick_params(rotation=45)\\n\\n ax.set_xlabel('Date')\\n ax.set_ylabel('Parallactic Angle (deg)')\\n\\n ms_basename = os.path.basename(ms).strip('.mms')\\n ms_basename = os.path.basename(ms).strip('.ms')\\n\\n outname = f\\\"{ms_basename}_parallactic_angles.png\\\"\\n plt.savefig(outname, bbox_inches='tight')\",\n \"def properties(self):\\n return {'u': {'name': 'streamwise velocity',\\n 'range': self.u_range},\\n 'uf': {'name': 'streamwise velocity',\\n 'range': self.u_range},\\n 'w': {'name': 'vertical velocity',\\n 'range': self.w_range},\\n 'wf': {'name': 'vertical velocity',\\n 'range': self.w_range},\\n 'uf_': {'name': 'mean streamwise velocity',\\n 'range': self.u_range},\\n 'wf_': {'name': 'mean vertical velocity',\\n 'range': self.w_range},\\n 'uf_abs': {'name': 'absolute velocity',\\n 'range': self.u_abs_range},\\n 'vorticity': {'name': 'vorticity',\\n 'range': self.w_range},\\n 'vertical_shear': {'name': 'vertical_shear',\\n 'range': self.w_range}}\",\n \"def __init__(self):\\r\\n # set up the class variables\\r\\n self.rangeTop = 85 # MIDI number of top note\\r\\n self.rangeBottom = 42 # MIDI number of bottom note\\r\\n self.currentUrlinie = []\\r\\n self.baseMotif = []\\r\\n self.workingMotif = []\\r\\n self.ULLength = 120 # this is the number of values in the UL vector - which is determined by the Urlinie generator\\r\\n self.ULPosition = 0 # index\\r\\n self.nextTargetNoteRelative = 0\\r\\n self.ULJump = 30\\r\\n self.ULBeatWait = 4\\r\\n self.ULBeatsToGo = 0\\r\\n self.MotifBeatsToGo = 0\\r\\n self.DBAffinity = 127\\r\\n self.IAffinity = 127\\r\\n self.swinging = False\\r\\n self.noteDensity = 63\\r\\n self.beatHeirarchy = 127\\r\\n self.heirarchyZero = 0 # extra weight given to the downbeat\\r\\n self.heirarchyOne = 0 # extra weight given to beat 3\\r\\n self.heirarchyThree = 0 # extra weight given to the off quavers\\r\\n self.scale = [0, 2, 4, 5, 7, 9, 11] # start with the Major/Ionian scale\\r\\n self.scaleBase = 0 # start with 'C'\\r\\n self.fullRangedScale = [] # holder for the current scale expressed across the current range of the Player\\r\\n self.rangedScaleOf1s = [] # holder for the current 1st degrees of the scale, across current range\\r\\n self.rangedScaleOf3s = [] # holder for the current 3rd degrees of the scale, across current range\\r\\n self.rangedScaleOf5s = [] # holder for the current 5th degrees of the scale, across current range\\r\\n self.rangedScaleOf0s = [] # holder for scale notes that are not 1st, 3rd or 5th degrees, across current range\\r\\n self.finishedUL = False\\r\\n self.weight_1 = 80 # assume slider 1 starts at value 15\\r\\n self.weight_3 = 22\\r\\n self.weight_5 = 22\\r\\n self.weight_other = 0\\r\\n self.thisTick = 0\\r\\n self.thisBar = 0\\r\\n self.ticksPerBar = 48\\r\\n self.cumulativeBars = 0\\r\\n self.motifScale = 30\\r\\n self.newULTimer = Timer(0, self.getNewUrlinie, [], False) # the idea is to put the Urlinie generator on its own thread\\r\\n\\r\\n # set placeholder for references to other classes\\r\\n self.UL = None # placeholder for UrLinie object\\r\\n self.NS = None # placeholder for Note Sender object\\r\\n self.LS = None # placeholder for Lead Sheet object\\r\\n self.MI = None # placeholder for MIDI Input object\\r\",\n \"def __init__(self, name=\\\"untitled\\\", pulseGenerator=None, frequency=None, phase=0, generatorFunction=\\\"square\\\", applyCorrections=False, pulseOn=True, **kwargs):\\n self._pulseGenerator = pulseGenerator\\n self.frequency = frequency\\n self.phase = phase\\n self.applyCorrections = applyCorrections\\n self.name = name\\n self.pulseOn = pulseOn\\n self._numberOfPoints = self._pulseGenerator.numberOfPoints()\\n self._samplingTime = self._pulseGenerator.samplingTime()\\n # made complex by Kiddi 09/03/2015\\n self._pulseArray = zeros(self._numberOfPoints, dtype=numpy.complex128)\\n self._generatorFunction = generatorFunction\\n self._parameters = kwargs\\n\\n try:\\n self._pulseArray[:] = getattr(generatorFunctionLib, generatorFunction)(\\n self._numberOfPoints, self._samplingTime, **kwargs)\\n except \\\"Attribute Error\\\":\\n print \\\"function %s does not exist\\\" % generatorFunction\\n except:\\n raise\",\n \"def pulse(*args, **kwargs):\\n weight_key = kwargs.get('weight')\\n\\n pulses_generator = _pulse(*args, **kwargs)\\n\\n if not configuration.pulse_return_best:\\n return pulses_generator\\n\\n best = None\\n best_cost = None\\n for pulse, weights in pulses_generator:\\n if best is None or best_cost > weights.get(weight_key):\\n best_cost = weights.get(weight_key)\\n best = pulse, weights\\n\\n return [best]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6358498","0.6317641","0.63023865","0.60456705","0.60405445","0.59185964","0.5912954","0.58964646","0.5826671","0.5813686","0.58130246","0.5761169","0.5713485","0.56207675","0.56019944","0.55966306","0.5565917","0.55059624","0.55000675","0.5494248","0.545782","0.54425526","0.54408205","0.5389248","0.5348543","0.5345578","0.533989","0.53195786","0.5313566","0.53075576","0.527189","0.5268059","0.5251239","0.5206446","0.51682496","0.5152014","0.5145182","0.5110249","0.5092687","0.5087336","0.50872463","0.50819427","0.5079304","0.50783956","0.50774455","0.5065814","0.5044866","0.50310504","0.5030278","0.50253403","0.502501","0.50090593","0.5008598","0.5000513","0.4999075","0.49891227","0.4984719","0.49733955","0.49730304","0.4969881","0.49680692","0.4965994","0.4964622","0.49623406","0.49608168","0.4960429","0.49574146","0.49467513","0.4941558","0.49281472","0.49277622","0.49178272","0.49086076","0.4906854","0.490668","0.48981133","0.48944163","0.4892962","0.48929617","0.48831174","0.4879534","0.4867651","0.48631853","0.48620668","0.4859307","0.48561105","0.48532236","0.48370758","0.48306456","0.48291874","0.48280445","0.48275927","0.48203537","0.48103225","0.48092207","0.4806622","0.47957698","0.47839072","0.47829086","0.4782273"],"string":"[\n \"0.6358498\",\n \"0.6317641\",\n \"0.63023865\",\n \"0.60456705\",\n \"0.60405445\",\n \"0.59185964\",\n \"0.5912954\",\n \"0.58964646\",\n \"0.5826671\",\n \"0.5813686\",\n \"0.58130246\",\n \"0.5761169\",\n \"0.5713485\",\n \"0.56207675\",\n \"0.56019944\",\n \"0.55966306\",\n \"0.5565917\",\n \"0.55059624\",\n \"0.55000675\",\n \"0.5494248\",\n \"0.545782\",\n \"0.54425526\",\n \"0.54408205\",\n \"0.5389248\",\n \"0.5348543\",\n \"0.5345578\",\n \"0.533989\",\n \"0.53195786\",\n \"0.5313566\",\n \"0.53075576\",\n \"0.527189\",\n \"0.5268059\",\n \"0.5251239\",\n \"0.5206446\",\n \"0.51682496\",\n \"0.5152014\",\n \"0.5145182\",\n \"0.5110249\",\n \"0.5092687\",\n \"0.5087336\",\n \"0.50872463\",\n \"0.50819427\",\n \"0.5079304\",\n \"0.50783956\",\n \"0.50774455\",\n \"0.5065814\",\n \"0.5044866\",\n \"0.50310504\",\n \"0.5030278\",\n \"0.50253403\",\n \"0.502501\",\n \"0.50090593\",\n \"0.5008598\",\n \"0.5000513\",\n \"0.4999075\",\n \"0.49891227\",\n \"0.4984719\",\n \"0.49733955\",\n \"0.49730304\",\n \"0.4969881\",\n \"0.49680692\",\n \"0.4965994\",\n \"0.4964622\",\n \"0.49623406\",\n \"0.49608168\",\n \"0.4960429\",\n \"0.49574146\",\n \"0.49467513\",\n \"0.4941558\",\n \"0.49281472\",\n \"0.49277622\",\n \"0.49178272\",\n \"0.49086076\",\n \"0.4906854\",\n \"0.490668\",\n \"0.48981133\",\n \"0.48944163\",\n \"0.4892962\",\n \"0.48929617\",\n \"0.48831174\",\n \"0.4879534\",\n \"0.4867651\",\n \"0.48631853\",\n \"0.48620668\",\n \"0.4859307\",\n \"0.48561105\",\n \"0.48532236\",\n \"0.48370758\",\n \"0.48306456\",\n \"0.48291874\",\n \"0.48280445\",\n \"0.48275927\",\n \"0.48203537\",\n \"0.48103225\",\n \"0.48092207\",\n \"0.4806622\",\n \"0.47957698\",\n \"0.47839072\",\n \"0.47829086\",\n \"0.4782273\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60221887"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":88986,"cells":{"query":{"kind":"string","value":"Prepares the data for creating ML models"},"document":{"kind":"string","value":"def prepare_data(camera, image_nums):\n from gen_d_params import gen_d_params\n\n # Fetch the data of interest set by \"camera\" and \"image_nums\"\n imgs = [camera + x for x in image_nums]\n d_params = gen_d_params(imgs)\n \n # Add azimuth feature for pixel location\n d_params[\"err_ang\"] = np.rad2deg(np.arctan2(d_params[\"ydiff\"], d_params[\"xdiff\"]))\n d_params[\"r_img\"] = np.sqrt(np.power(d_params[\"x_img\"], 2) + np.power(d_params[\"y_img\"], 2)) \n d_params[\"err_mag\"] = d_params.pop(\"mag\")\n d_params[\"azm_img\"] = np.rad2deg(np.arctan2(d_params[\"y_img\"], d_params[\"x_img\"]))\n \n x1 = np.reshape(d_params[\"r_img\"], (len(d_params[\"r_img\"]), 1))\n x2 = np.reshape(d_params[\"azm_img\"], (len(d_params[\"azm_img\"]), 1))\n x = np.hstack((x1, x2))\n y1 = np.reshape(d_params[\"err_mag\"], (len(d_params[\"err_mag\"]), 1))\n y2 = np.reshape(d_params[\"err_ang\"], (len(d_params[\"err_ang\"]), 1))\n y = np.hstack((y1, y2))\n\n return x, y"},"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 _prepare_data(self):\n #TODO hardcoded values need to change\n print_info(\"Preprocessing the train data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"train\"),\n self.TRAIN_OUT_PATH)\n\n print_info(\"Preprocessing the test data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"test\"),\n self.TEST_OUT_PATH)\n\n print_info(\"Preprocessing the validation data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"val\"),\n self.VAL_OUT_PATH)","def prepare_data(self):\n try:\n self.train_dataset = self.datasets['train']\n self.val_dataset = self.datasets['val']\n try:\n self.test_dataset = self.datasets['test']\n except:\n pass\n except Exception as e:\n print('Data was not succesfully prepared:', e)","def prepare_data(self):\n # Set up the path\n self.path_target_train = os.path.join(self.data_dir, self.train_path_file_target + \".pkl\")\n self.path_target_test = os.path.join(self.data_dir, self.test_path_file_target + \".pkl\")\n\n if not os.path.exists(self.path_target_train) or not os.path.exists(self.path_target_test):\n # Create vocabularies of the appropriate sizes.\n self.create_vocabulary(self.train_path_file)\n\n # Create token ids for the training data.\n input_train_path = self.train_path_file\n target_train_path = self.train_path_file_target\n train_input, train_input_length, train_labels = self.data_to_token_ids(input_train_path, target_train_path)\n\n # Create token ids for the validation data.\n input_test_path = self.test_path_file\n target_test_path = self.test_path_file_target\n test_input, test_input_length, _ = self.data_to_token_ids(input_test_path, target_test_path, train=False)\n\n # Collect data into a list\n training_data = [train_input, train_input_length, train_labels]\n test_data = [test_input, test_input_length]\n\n # Save all the data\n with open(self.path_target_train, 'wb') as f:\n pickle.dump(training_data,f)\n with open(self.path_target_test, 'wb') as f:\n pickle.dump(test_data, f)\n else:\n # Load data\n with open(self.path_target_train, 'rb') as f:\n training_data = pickle.load(f)\n with open(self.path_target_test, 'rb') as f:\n test_data = pickle.load(f)\n\n # Initialize vocabulary\n self.initialize_vocabulary()\n\n # Convert list into a numpy array - train data\n train_input = pd.DataFrame(training_data[0]).fillna(value=0).astype(int).values\n train_length_input = np.array(training_data[1], dtype=int)\n train_labels = np.array(training_data[2], dtype=int)\n\n # Convert list into a numpy array - test data\n test_input = pd.DataFrame(test_data[0]).fillna(value=0).astype(int).values\n test_length_input = pd.DataFrame(test_data[1]).fillna(value=0).astype(int).values\n\n # Printing maximum length\n print(\"Shape of the input training matrix {}\".format(str(train_input.shape)))\n print(\"Shape of the input test matrix {}\".format(str(test_input.shape)))\n\n # Copy the files\n self.copy_files()\n\n # Return output\n return train_input, train_length_input, train_labels, test_input, test_length_input","def preprocess_data(self):\n\n self._preprocess_train_data()\n self._preprocess_test_data()","def prepare_data(self):\n data = self._get_dataset(self.hparams.dataset_path)\n label_encoder = data[\"label_encoder\"]\n del data[\"label_encoder\"]\n\n click.secho(\"Building inputs and labels.\", fg=\"yellow\")\n datasets = {\n \"train\": defaultdict(list),\n \"valid\": defaultdict(list),\n \"test\": defaultdict(list),\n }\n for dataset_name, dataset in data.items():\n for sample in dataset:\n instance = self.build_input(\n self.tokenizer, sample[\"text\"], label_encoder, sample[\"label\"]\n )\n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n\n click.secho(\"Padding inputs and building tensors.\", fg=\"yellow\")\n tensor_datasets = {\"train\": [], \"valid\": [], \"test\": []}\n for dataset_name, dataset in datasets.items():\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\n for input_name in MODEL_INPUTS:\n if input_name == \"labels\":\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\n else:\n tensor = torch.tensor(dataset[input_name])\n tensor_datasets[dataset_name].append(tensor)\n\n self.train_dataset = TensorDataset(*tensor_datasets[\"train\"])\n self.valid_dataset = TensorDataset(*tensor_datasets[\"valid\"])\n self.test_dataset = TensorDataset(*tensor_datasets[\"test\"])\n click.secho(\n \"Train dataset (Batch, Candidates, Seq length): {}\".format(\n self.train_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Valid dataset (Batch, Candidates, Seq length): {}\".format(\n self.valid_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Test dataset (Batch, Candidates, Seq length): {}\".format(\n self.test_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )","def prepare_data():\n gennet.prepare_data('Resnet50')","def prepare_train_data(self):\r\n ## Impute rlkpis\r\n print(\"Imputing rlKPI df\")\r\n self.rlkpi.add_target_labels(1)\r\n self.rlkpi.impute_rl_kpis()\r\n\r\n print(\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\")\r\n self.add_met_real_forecast_station_col_to_rlkpis()\r\n print(\"Merge 'met-real-sampled df to rl kps \")\r\n self.merge_met_real_sampled_df_to_rlkpis()\r\n\r\n ## Imputations for met-forecast\r\n print(\"Impute met-forecast\")\r\n met_forecast_obj = self.metfcast\r\n met_forecast_obj.impute_met_forecast()\r\n\r\n #Merge met forecast data to earlier merged data\r\n print(\"Merge Train data with imputed forecast df\")\r\n self.train_data = pd.merge(self.train_data,\r\n met_forecast_obj.imputed_forecast_df,\r\n on=['datetime-station_no'], indicator=True, how='inner')\r\n print(\"Check any imputation needed\", self.train_data.isna().sum().sum())\r\n self.train_data.drop(['_merge'], axis=1, inplace=True)\r\n self.perform_data_under_sampling(self.train_data)","def prepare_data():\n user_name = os.environ.get('USER')\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\n random.shuffle(traintest_corpus.resumes)\n\n for resume in traintest_corpus.resumes:\n try:\n review_text = pre_processing(resume[0])\n review_text = \" \".join(review_text)\n data_dict['data'].append(review_text)\n data_dict['label'].append(resume[1])\n except:\n pass","def prepare_data(self):","def preprocess_train_data(self):\r\n print(\"* Preprocessing training data.\", flush=True)\r\n prep.create_HDF_file(self.C.training_set, is_training_set=True)\r\n\r\n self.print_time_elapsed()","def prepare(self):\n\n # step 0: load only when not loaded yet\n if TRAINING in self.data \\\n and VALIDATION in self.data:\n return\n\n # step 1: load the file names\n file_list = sorted(glob.glob(self.location+\"*.mhd\"))\n # count the number of data points\n\n # make a stratified validation set\n # note, the seed decides the validation set, but it is deterministic in the names\n random.seed(317070)\n patient_names = [self.patient_name_from_file_name(f) for f in file_list]\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\n\n # make the static data empty\n for s in self.datasets:\n self.data[s] = []\n self.labels[s] = []\n self.names[s] = []\n\n # load the filenames and put into the right dataset\n labels_as_dict = defaultdict(list)\n\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\n next(reader) # skip the header\n for row in reader:\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\n labels_as_dict[str(row[0])].append(label)\n\n for patient_file in file_list:\n patient_name = self.patient_name_from_file_name(patient_file)\n\n if patient_name in validation_patients:\n s = VALIDATION\n else:\n s = TRAINING\n label = labels_as_dict[str(patient_name)]\n if self.only_positive and not label:\n continue\n self.data[s].append(patient_file)\n \n if self.pick_nodule:\n self.labels[s].append([random.choice(label)]) \n else:\n self.labels[s].append(label)\n \n \n self.names[s].append(patient_name)\n\n # give every patient a unique number\n last_index = -1\n for s in self.datasets:\n self.indices[s] = range(last_index+1,last_index+1+len(self.data[s]))\n if len(self.indices[s]) > 0:\n last_index = self.indices[s][-1]\n print s, len(self.indices[s]), \"samples\"","def prepare_data(self):\n if not os.path.exists(self.hparams.data_cache_dir):\n os.mkdir(self.hparams.data_cache_dir)\n for mode, filepath in zip(['train', 'val', 'test'],\n [self.hparams.train_path, self.hparams.val_path, self.hparams.test_path]):\n if mode == 'train':\n label_mode = self.hparams.label_mode\n else:\n label_mode = 'major'\n cached_features_file = self._feature_file(mode, label_mode)\n\n if not os.path.exists(cached_features_file):\n logger.info('Creating features from dataset file at %s', filepath)\n examples = read_examples_from_file(filepath, mode, label_mode)\n features = convert_examples_to_features(\n examples,\n self.labels,\n self.hparams.max_seq_length,\n self.tokenizer,\n cls_token_at_end=bool(self.hparams.model_type in ['xlnet']),\n cls_token=self.tokenizer.cls_token,\n cls_token_segment_id=2 if self.hparams.model_type in ['xlnet'] else 0,\n sep_token=self.tokenizer.sep_token,\n sep_token_extra=bool(self.hparams.model_type in ['roberta']),\n pad_on_left=bool(self.hparams.model_type in ['xlnet']),\n pad_token=self.tokenizer.convert_tokens_to_ids([self.tokenizer.pad_token])[0],\n pad_token_segment_id=4 if self.hparams.model_type in ['xlnet'] else 0,\n pad_token_label_id=self.pad_token_label_id,\n )\n logger.info('Saving features into cached file %s', cached_features_file)\n torch.save(features, cached_features_file)","def initialize(self):\n LOG.info(\"Initializing Model.\")\n self.model = self.convert(df=self.training_df)\n if self.bootstraps is not None:\n LOG.info(\"Bootstrapping Data.\")\n self.bootstrap_data()","def prepare(self):\n if self.opts['verbose']:\n print(\"Preparing dataset (one-time operation)...\")\n # Create paths files and load them back in\n self._build_ID_sets()\n self._create_ID_files()\n self._load_ID_files()\n if self.opts['verbose']:\n print(\"... done with preparing the dataset.\")","def prepare(self):\n\t\tif len(os.listdir(self.storagedir)):\n\t\t\traise Exception(\"There are already files in\", self.storagedir + \".\", \"Delete manually!\")\n\t\t\n\t\tself.worddict = {\"__pad__\": 0, \"__oov__\": 1}\n\t\tself.classdict = {}\n\t\tself.raw_documents, self.tokenized_documents = {}, {}\n\t\tself.X, self.Y = {}, {}\n\n\t\tfor dataset in self.DATASETS_TMP:\n\t\t\tself.get_raw_data(dataset)\n\t\t\tself.delete_empty_documents(dataset)\n\t\t\tself.tokenize_documents(dataset)\n\n\t\tself.make_classdict()\n\t\tself.make_worddict()\n\t\tself.make_embeddings()\n\t\tself.reverse_dicts()\n\n\t\tfor dataset in self.DATASETS_TMP:\n\t\t\tself.make_X(dataset)\n\t\t\tself.shuffle_dataset(dataset)\n\n\t\tif not \"dev\" in self.X:\n\t\t\tself.split_dev()\t\t\n\t\tself.make_hybrid()\n\t\tself.store()","def prepare_data_for_training(args):\n # Form the train/test splits and write them to disk\n dataset = data.Dataset(args)\n # get image classes and image counts in each class\n label_map = dataset.get_class_info()\n class_count = len(list(label_map.values()))\n # split the data and store it in log dir\n df_train, df_test = dataset.split_dataset()\n\n # perform dataset augmentations\n image_data = augment.Augmentation(args)\n # get the data gens for training and test images\n train_data_gen, _ = image_data.map_fn_train(df_train)\n test_data_gen, _ = image_data.map_fn_test(df_test)\n\n return train_data_gen, test_data_gen, df_train, df_test, class_count","def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n self.augment_train_data()\n if not self.assert_style_data_correct():\n self.download_style_data()\n self.unpack_rename_data()","def prepare_data(self, *args, **kwargs):\n # get paths to train and test splits\n _split_paths = [os.path.join(self.path_to_data, split)\n for split in os.listdir(self.path_to_data)]\n\n # for each split [train, test]\n for _path in _split_paths:\n _img_classes = os.listdir(_path) # get subfolders representing each class\n self.splits[os.path.basename(_path)] = []\n\n # get the images in pairs with its corresponding class\n for _class in _img_classes:\n _data = self.get_img_text_pair(os.path.join(_path, _class))\n\n if os.path.basename(_path) == 'train':\n self.weights[self.encode_label(_class)] = len(_data)\n self.splits[os.path.basename(_path)].extend(_data)","def _prepare_ml_data(X, y, to_optimize=False):\n size_test = 1\n y_test = None\n if to_optimize:\n size_test = CONFIG.OPTIMIZE_PARAMS['size'] + 1\n y_test = y.iloc[-size_test:]\n X_train = X.iloc[:-size_test]\n y_train = y.iloc[:-size_test]\n X_test = X.iloc[-size_test:]\n return X_train, y_train, X_test, y_test","def prepareData(self, *data):\n arguments = 8\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\n self.model, self.annotations, self.args) = tuple(data[:arguments])\n \n self.width = self.args.beam_width\n self.mathType = self.args.mathType\n self.io_files = {\n 'input': self.args.intermediate_input_files,\n 'output': self.args.intermediate_output_files\n }\n self.repeat_width = self.args.repeat_width\n self.cons_count = self.args.cons_count\n self.posterior_processors = self.args.posterior_processors \n\n self.positionGenerator = \\\n list(AlignmentBeamGenerator(self.alignment, self.width))\n \n for i in range(len(self.model.states)):\n self.model.states[i].computeHints(self)\n\n return data[arguments:]","def prepare_data(self, *args, **kwargs) -> None:\n if not (self.root / \"train\").exists():\n raise ValueError(\n f\"Please download and set ImageNet-1k train data under {self.root}.\"\n )\n if not (self.root / \"val\").exists():\n raise ValueError(\n f\"Please download and set ImageNet-1k val data under {self.root}.\"\n )","def prep_data(self):\n\n self.fit_tokenizer(texts=self.texts)\n sequences = self.get_sequences(self.texts)\n self.text_data = pad_sequences(sequences, maxlen=self.MAX_SEQUENCE_LENGTH)\n\n self.labels = to_categorical(np.asarray(self.labels))\n print('Shape of data tensor:', self.text_data.shape)\n print('Shape of label tensor:', self.labels.shape)\n\n # split the data into a training set and a validation set\n indices = np.arange(self.text_data.shape[0])\n np.random.shuffle(indices)\n self.text_data = self.text_data[indices]\n self.labels = self.labels[indices]\n nb_validation_samples = int(self.VALIDATION_SPLIT * self.text_data.shape[0])\n\n x_train = self.text_data[:-nb_validation_samples]\n y_train = self.labels[:-nb_validation_samples]\n x_val = self.text_data[-nb_validation_samples:]\n y_val = self.labels[-nb_validation_samples:]\n\n return x_train,y_train, x_val, y_val","def prepare_data():\n #data, label = load_ta_data(), load_ta_target()\n data, label = load_own_data(), load_own_target()\n tra_x, tst_x = split_samples(data)\n tra_y, tst_y = split_samples(label)\n return (tra_x, tst_x, tra_y, tst_y)","def prepare_data(self, context_size, model_name):\n self.context_size = context_size\n data_x = []\n data_y = []\n oob = self.word2idx['OOB']\n\n for item in self.docs:\n data = [oob] * context_size + self.doc2token(item) + [oob] * context_size #padding\n for i in range(context_size, len(data) - context_size):\n data_x.append(data[i - context_size: i] + data[i + 1: i + context_size + 1])\n data_y.append(data[i])\n \n if model_name.lower() == 'skipgram':\n data_x, data_y = data_y, data_x\n self.data_x = Variable(torch.LongTensor(data_x))\n self.data_y = Variable(torch.LongTensor(data_y))\n logging.info(f'data preprocessed, data shape: {self.data_x.shape}, {self.data_y.shape}')","def preprocess():\n # Load the data\n random.seed(77)\n X,y = make_classification(n_samples=500, n_features=30, n_informative=8, n_redundant=2, \n n_repeated=0, n_classes=3, n_clusters_per_class=2, weights=None, \n flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, \n shuffle=True, random_state=None)\n\n x_train, x_val, y_train, y_val = train_test_split(X, y, random_state=0, test_size=0.25)\n\n # Standardize the data\n scaler = StandardScaler()\n X_train = scaler.fit_transform(x_train)\n X_val = scaler.transform(x_val)\n\n \n return X_train,y_train,X_val,y_val","def set_data():\r\n #if not os.path.exists(filepath):\r\n #download_data()\r\n metadata = read(filepath + flist[-1])\r\n ndata = metadata['num_cases_per_batch']\r\n ndim = metadata['num_vis']\r\n\r\n data, train, test = {}, {}, {}\r\n data['labels'] = metadata['label_names']\r\n data['ntraindata'] = metadata['num_cases_per_batch'] * (len(flist) - 2)\r\n data['ntestdata'] = metadata['num_cases_per_batch']\r\n data['ndim'] = metadata['num_vis']\r\n\r\n train['x'], train['y'] = convert_train(data['ntraindata'], data['ndim'])\r\n\r\n testdata = read(filepath + flist[-2])\r\n test['x'] = testdata['data']\r\n test['y'] = testdata['labels']\r\n\r\n data['train'], data['test'] = train, test\r\n save_pkl(data)","def prepare_data(args):\n logger.info('Loading dataframe from %s' % args.newspath)\n df = pd.read_csv(args.newspath, encoding='gb18030')\n logger.info('Dataframe size: %d observations %d features after loaded' % (df.shape[0], df.shape[1]))\n\n # exclude rows with column source == NaN\n logger.info('Data cleansing...')\n df = df[~pd.isna(df['source'])]\n logger.info('Dataframe size: %d observations %d features after data cleansing' % (df.shape[0], df.shape[1]))\n\n # split the dataframe into training set and test set\n logger.info('Making training set & test set...')\n train_set, test_set = split_data(df)\n logger.info('Traning set size: %d' % train_set.shape[0])\n logger.info('Test set size: %d' % test_set.shape[0])\n\n # save the train set and test set to picke files\n logger.info('Save dataframes to files...')\n train_set.to_pickle(args.trainpath)\n test_set.to_pickle(args.testpath)","def data_prep(data, y, dropna=False):\n\n rand_state = 10 # Setting random state for later cv\n df = pd.read_pickle(data) # Reading in data\n if dropna is True:\n df.dropna(axis=0, inplace = True)\n else:\n pass\n X = df.drop(y, axis=1) # Assigning the feature space to X\n y = df[y] # Class labels to predict\n\n return X, y, rand_state","def prepareData(mdl, X_train, X_val, X_test, Y_train, Y_val, Y_test):\n\t\n\tX2_train = []\n\n\tX2_val = []\n\n\tX2_test = []\n\n\n\tYPs = mdl.predict(X_train)\n\n\tfor i in tqdm(range(len(X_train))):\n\n\t\tX2_train.append(np.array(YPs[i]))\n\n\n\n\tYPs = mdl.predict(X_val)\n\n\tfor i in tqdm(range(len(X_val))):\n\n\t\tX2_val.append(np.array(YPs[i]))\n\n\n\n\tYPs = mdl.predict(X_test)\n\n\tfor i in tqdm(range(len(X_test))):\n\n\t\tX2_test.append(np.array(YPs[i]))\n\n\n\tX2_train = np.array(X2_train)\n\n\tX2_val = np.array(X2_val)\n\n\tX2_test = np.array(X2_test)\n\n\treturn (X2_train, X2_val, X2_test)","def prepare(self):\n bcolz.set_nthreads(2)\n\n # step 0: load only when not loaded yet\n if TRAINING in self.data and VALIDATION in self.data: return\n\n # step 1: load the file names\n patients = sorted(glob.glob(self.location+'/*.*/'))\n print len(patients), \"patients\"\n\n # step 1: load the file names\n # make a stratified validation set\n # note, the seed decides the validation set, but it is deterministic in the names\n random.seed(317070)\n patient_names = [self.patient_name_from_file_name(f) for f in patients]\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\n\n labels_as_dict = defaultdict(list)\n\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\n next(reader) # skip the header\n for row in reader:\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\n labels_as_dict[str(row[0])].append(label)\n\n # make the static data empty\n for s in self.datasets:\n self.data[s] = []\n self.labels[s] = []\n self.names[s] = []\n self.spacings[s] = []\n self.origins[s] = []\n\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'spacings.pkl.gz') as f:\n spacings = cPickle.load(f)\n\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'origins.pkl.gz') as f:\n origins = cPickle.load(f)\n\n # load the filenames and put into the right dataset\n for i, patient_folder in enumerate(patients):\n patient_id = str(patient_folder.split(path.sep)[-2])\n if patient_id in validation_patients:\n dataset = VALIDATION\n else:\n dataset = TRAIN\n\n\n label = labels_as_dict[patient_id]\n if self.only_positive and not label:\n continue\n\n self.data[dataset].append(patient_folder)\n self.labels[dataset].append(label)\n self.names[dataset].append(patient_id)\n self.spacings[dataset].append(spacings[patient_id])\n self.origins[dataset].append(origins[patient_id])\n\n # give every patient a unique number\n last_index = -1\n for set in self.datasets:\n self.indices[set] = range(last_index+1,last_index+1+len(self.data[set]))\n if len(self.indices[set]) > 0:\n last_index = self.indices[set][-1]\n print set, len(self.indices[set]), \"samples\"","def data_preprocessing():\n lineid_content = get_lineid_content()\n print('Read movie_lines.txt file complete...')\n convos = get_convos()\n print('Read movie_conversations.txt file complete...')\n print('Building dataset')\n get_data(lineid_content, convos)","def _prepare_models(self):\n if self.freeze_layers is not None:\n self._set_freeze_layers()\n self._load_weight_if_possible()\n print(self.keras_model.summary())\n self.show_configuration()","def preprocess_valid_data(self):\r\n print(\"* Preprocessing validation data.\", flush=True)\r\n prep.create_HDF_file(self.C.validation_set)\r\n\r\n self.print_time_elapsed()","def prepare_data(self, config: TreeConfigParser) -> None:\n self.data = Data(config)\n self.data.prepare_input()\n self.data.prepare_output()","def setup():\n # change working directory to\n os.chdir(ROOT_DIR)\n # move to dataFiles\n with misc.cd('dataFiles'):\n print('Now in:', os.getcwd())\n # Load in data\n model_test = models.MlModel('rf', 'water-energy.csv', 'expt')\n # Get feature. I use rdkit2d as it is fast to generate\n df, num_feat, feat_time = features.featurize(model_test.data, model_test.algorithm, [0])\n # Split the data\n train_features, test_features, train_target, test_target, feature_list = features.targets_features(df, 'expt')\n return train_features, test_features, train_target, test_target","def pre_process(self, dataset):\n\n # np.empty creates an empty array only. You have to replace this with your code.\n X = np.empty((0,0))\n y = np.empty((0))\n\n if dataset == 0:\n # Implement for the abalone dataset\n df = pd.DataFrame(columns=['sex', 'length', 'diameter', 'height', 'whole_weight', 'shucked_weight', 'viscera_weight', 'shell_weight', 'rings'])\n count = 0\n\n with open('Dataset.data') as file: # reading data from file\n data = file.read()\n\n data = data.split('\\n') # split data into different rows\n data = data[:-1] # last one is empty\n for row in data:\n row = row.split()\n df.loc[count] = row # add in dataframe\n count += 1\n\n df['M'] = np.where(df.sex=='M', 1,0) # genders are turned to a one hot encoding\n df['F'] = np.where(df.sex=='F', 1,0)\n df['I'] = np.where(df.sex=='I', 1,0)\n df = df.drop(['sex'], axis=1)\n df = df.dropna()\n\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataframe\n\n X = df.drop(['rings'], axis=1)\n X = X.values\n X = X.astype(float)\n y = df['rings'].values\n y = y.astype(float)\n\n elif dataset == 1:\n # Implement for the video game dataset\n df = pd.read_csv('VideoGameDataset - Video_Games_Sales_as_at_22_Dec_2016.csv') # read csv directly into a dataframe\n df1 = df[['Critic_Score', 'User_Score', 'Global_Sales']]\n df1 = df1.dropna()\n df1 = df1[df1.User_Score != 'tbd']\n\n df1 = df1.sample(frac=1).reset_index(drop=True) # shuffle rows\n\n X = df1.drop(['Global_Sales'], axis=1)\n X = X.values\n X = X.astype(float)\n y = df1['Global_Sales'].values\n y = y.astype(float)\n\n elif dataset == 2:\n # Implement for the banknote authentication dataset\n df = pd.DataFrame(columns=['variance', 'skewness', 'curtosis', 'entropy', 'class'])\n count = 0\n\n with open('data_banknote_authentication.txt') as file: # reading file \n data = file.read()\n data = data.split('\\n')\n data = data[:-1]\n for row in data:\n row = row.split(',')\n df.loc[count] = [float(elt) for elt in row[:-1]] + [int(row[-1])] # last column has class so it is int rest are float\n count += 1\n\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataset\n\n X = df.drop(['class'], axis=1)\n X = X.values\n y = df['class'].values\n y = y.astype(int)\n\n return X, y","def pre_process_data(self, all_labels, all_data):\n\n # [1] Normalizes data\n all_data = self.pre_precess_manager.normalization(all_data)\n\n data_train, data_test, label_train, label_test = train_test_split(all_data, all_labels, test_size=0.1,\n shuffle=True)\n\n return data_train, data_test, label_train, label_test","def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_frequent_features()\n # self._compactness_pruning()\n # self._redundancy_pruning()\n # self._get_features()\n self._extract_opinions()","def prepare_data(self):\n import subprocess\n # Download coco data set into dir specified by config then /data/coco\n subprocess.call([f\"{get_original_cwd()}/bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\", f\"{get_original_cwd()}\"])\n # subprocess.call([f\"bin/fetch_dataset.sh\", f\"{self.dir}/data/coco\"])\n task = \"instances\" if self.instance else \"person_keypoints\"\n register_coco_instances(\"train\", {}, f\"{self.dir}/data/coco/{task}_train2014.json\",\n f\"{self.dir}/data/coco/train2014\")\n register_coco_instances(\"val\", {}, f\"{self.dir}/data/coco/{task}_minival2014.json\",\n f\"{self.dir}/data/coco/val2014\")\n register_coco_instances(\"test\", {}, f\"{self.dir}/data/coco/{task}_valminusminival2014.json\",\n f\"{self.dir}/data/coco/val2014\")","def prepareData(self):\n\t\tprint ('')\n\t\tfrom keras.preprocessing.sequence import pad_sequences\n\t\tfrom sklearn.model_selection import train_test_split\n\t\tfrom keras.utils import to_categorical\n\t\timport numpy as np\n\n\t\tfrom sklearn.preprocessing import LabelBinarizer, LabelEncoder\n\n\t\tX_snt = [[self.word2idx[w] if w in self.word2idx else self.word2idx[self.word_unk_token] for w in s] for s in self.x_document]\n\t\ty_tag = [[self.tag2idx[t]] for t in self.y_document]\n\n\t\tX_snt = pad_sequences(maxlen=self.parameters['max_doc_len'], sequences=X_snt, padding='post', value=self.word2idx[self.word_pad_token])\n\t\ty_tag = to_categorical(y_tag, self.tags_len)\n\n\t\tprint (\"\\tRandom:\\t\", self.random)\n\t\tprint (\"\\tTest size:\\t\", self.split_train_test)\n\n\t\tself.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X_snt, y_tag, test_size=self.split_train_test, random_state=self.random)\n\n\t\tself.X_train = np.array(self.X_train)\n\t\tself.X_test = np.array(self.X_test)\n\t\tself.y_train = np.array(self.y_train)\n\t\tself.y_test = np.array(self.y_test)\n\n\t\tprint ('\\n\\tWords: {}\\t{}'.format(self.X_train.shape, self.X_test.shape) )\n\t\tprint ('\\tTags: {}\\t{}\\n'.format(self.y_train.shape, self.y_test.shape))","def _make_data(self):\n pdf_datasets_all = make_pdf_datasets(self.pdf_list, self.xlims, self.ylims, self.tlims, self.dims, 9)\n self.pdf_dataset = np.concatenate(pdf_datasets_all, axis = 0)\n self.PDE_dataset = make_PDE_dataset(self.num_collocation, self.xlims, self.ylims, self.tlims, self.dims)\n self.BC_dataset = make_BC_dataset(self.num_BC, self.xlims, self.ylims, self.tlims, self.dims)","def preproc_pipeline(data):\n # Preprocess\n data = preprocess(data)\n\n # Optional --> run a technical analysis on it and add more features\n data = generate_ta(data)\n \n # Split\n train_set, validation_set, test_set = train_val_test_split(data)\n \n # Set up for Keras\n train_set = shape_for_keras(train_set)\n validation_set = shape_for_keras(validation_set)\n test_set = shape_for_keras(test_set)\n\n # We could save this to csv.\n return train_set, validation_set, test_set","def __loadPreProcessedData(self):\n le = joblib.load(self.le_filename)\n X = np.loadtxt(self.X_filename, delimiter=',').astype(int)\n raw_y = np.loadtxt(self.y_filename, delimiter=',').astype(int)\n y = le.inverse_transform(raw_y)\n ##Initialize atrtribute for this class\n self.le, self.X, self.y = le, X, y","def preprocess(self):\n \n file_name_list = os.listdir(self.image_dir)\n random.seed(1234)\n random.shuffle(file_name_list)\n \n for i,d in enumerate(self.domains):\n self.attr2idx[d]=i \n\n for i, file_name in enumerate(file_name_list):\n if (file_name.startswith('X_')):\n continue\n \n parts = file_name.split(\"-\")\n label = int(parts[0])\n if label not in self.domains:\n continue\n img_name = file_name\n\n count=self.get_sample_count(label)\n if count<self.valid_set_size:\n # create holdout set on the fly\n utils.copy_file(self.image_dir,self.valid_set_dir,img_name)\n else:\n self.dataset.append([img_name, self.attr2idx[label]])\n \n self.increment_sample_count(label)\n\n print(\"Sample count per domain: \"+str(self.sample_count)+\" (including holdout set, holdout size per domain is: \"+str(self.valid_set_size)+\")\")\n print('Finished preprocessing the dataset...')","def initialisation(self):\n self.create_variables()\n self.create_placeholders()\n self.build_model()\n self.reset_lr(None, True)\n self.build_loss()\n self.initialised = True","def preprocess(self):\n lines = [line.rstrip() for line in open(self.attr_path, 'r')]\n all_attr_names = lines[1].split()\n for i, attr_name in enumerate(all_attr_names):\n self.attr2idx[attr_name] = i\n self.idx2attr[i] = attr_name\n\n lines = lines[2:]\n random.seed(1234)\n random.shuffle(lines)\n for i, line in enumerate(lines):\n split = line.split()\n filename = split[0]\n values = split[1:]\n\n label = []\n for attr_name in self.selected_attrs:\n idx = self.attr2idx[attr_name]\n label.append(values[idx] == '1')\n\n if (i+1) < 4:\n self.test_dataset.append([filename, label])\n else:\n self.train_dataset.append([filename, label])","def _preprocess_training_model(self, data):\n def _pre_process(raw_data):\n \"\"\" Pre-process raw data. \"\"\"\n pattern = re.compile(\n r\"((?<=')\\w\\d.*?(?=')|(?<=\\\")\\w\\d.*?(?=\\\")|[\\w\\d]+)\")\n words = re.findall(pattern, raw_data)\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\n\n data_list = []\n # Preprocess the dataset with naming convention, etc.\n with Progress() as progress:\n preprocess_task = progress.add_task('Pre-processing dataset...',\n total=data.shape[0])\n for idx, row in data.iterrows():\n row_data = {}\n for column in ['text', 'key', 'value']:\n row_data[column] = _pre_process(row[column])\n data_list.append(row_data)\n progress.update(preprocess_task, advance=1)\n return pd.DataFrame(data=data_list)","def _load_data(self):\n self.mapper = Mapper()\n self.mapper.generate_vocabulary(self.review_summary_file)\n self.X_fwd, self.X_bwd, self.Y = self.mapper.get_tensor(reverseflag=True)\n # Store all the mapper values in a dict for later recovery\n self.mapper_dict = dict()\n self.mapper_dict['seq_length'] = self.mapper.get_seq_length()\n self.mapper_dict['vocab_size'] = self.mapper.get_vocabulary_size()\n self.mapper_dict['rev_map'] = self.mapper.get_reverse_map()\n # Split into test and train data\n self._split_train_tst()","def _prepare_model(model):\n\n # Ensure there is at least 1 load combination to solve if the user didn't define any\n if model.LoadCombos == {}:\n # Create and add a default load combination to the dictionary of load combinations\n model.LoadCombos['Combo 1'] = LoadCombo('Combo 1', factors={'Case 1':1.0})\n \n # Generate all meshes\n for mesh in model.Meshes.values():\n if mesh.is_generated == False:\n mesh.generate()\n\n # Activate all springs and members for all load combinations\n for spring in model.Springs.values():\n for combo_name in model.LoadCombos.keys():\n spring.active[combo_name] = True\n \n # Activate all physical members for all load combinations\n for phys_member in model.Members.values():\n for combo_name in model.LoadCombos.keys():\n phys_member.active[combo_name] = True\n \n # Assign an internal ID to all nodes and elements in the model. This number is different from the name used by the user to identify nodes and elements.\n _renumber(model)","def prepare_estimation(model_params_init_file_name, lower, upper):\n\n # Read in data and init file sources\n model_params_df = pd.read_pickle(model_params_init_file_name)\n model_params_df[\"lower\"] = lower\n model_params_df[\"upper\"] = upper\n\n return model_params_df","def _load_training_data(self):\n self._save_training_data()","def setup(self):\n # TODO check if need both dataset together\n self.train_dataset = ABSADataset(data_path=self.train_path, mode=self.in_mode, task=self.task, \n tokenizer=self.tokenizer, vocab=\"bert\")\n self.vocabulary = self.train_dataset.vocabulary\n\n self.eval_dataset = ABSADataset(data_path=self.dev_path, mode=self.in_mode, task=self.task,\n tokenizer=self.tokenizer, vocab=self.vocabulary)\n #self.train_restaurant = ABSADataset(data_path=RESTAURANT_TRAIN)\n #self.eval_restaurant = ABSADataset(data_path=RESTAURANT_DEV)","def prepare(self):\n\n inp = self.config.get('predict.input', 'X:0')\n out = self.config.get('predict.output', 'output:0')\n\n # set input placeholder\n self.input = self.graph.get_tensor_by_name(inp)\n\n # set output operation\n if isinstance(out, str) or isinstance(out, unicode):\n self.output = {out: self.graph.get_tensor_by_name(out)}\n self.output_alone = True\n elif isinstance(out, list):\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\n self.output_alone = False\n else:\n raise LoaderException('incorrect predict.output type')","def produce_init(filename):\n training_dataset = pd.read_csv(f'../Modified Data/{filename}')\n test_dataset = pd.read_csv(f'../Raw Data/test.csv')\n features = list(training_dataset.columns)\n features.remove('SalePrice')\n predict_feature = ['SalePrice']\n\n # Produce Test Data\n test_X = test_dataset.loc[:, features]\n ids_test = test_dataset.loc[:, 'Id']\n\n for column in features:\n if str(training_dataset.loc[:, column].dtype) == 'object':\n # Initialize encoder\n labelencoder = LabelEncoder()\n # Encode Train Data\n training_dataset.loc[:, column] = training_dataset.loc[:, column].fillna('Missing')\n training_dataset.loc[:, column] = pd.Series(labelencoder.fit_transform(training_dataset.loc[:, column]))\n # Encode Test Data\n test_X.loc[:, column] = test_X.loc[:, column].fillna('Missing')\n test_X.loc[:, column] = pd.Series(labelencoder.fit_transform(test_X.loc[:, column]))\n else:\n # Fix missing values for train data\n training_dataset.loc[:, column] = training_dataset.loc[:, column].fillna(int(training_dataset.loc[:, column].mean()))\n # Fix missing values for test data\n test_X.loc[:, column] = test_X.loc[:, column].fillna(int(test_X.loc[:, column].mean()))\n\n return training_dataset, test_X, ids_test","def init_data(in_arg, model_param, phase=\"train\"): \n # Firstly, set the directories\n # PRE-REQUISITES: \n # train & valid sets (1 per folder) must exist within the in_arg.data_dir (to improve if I have some time later on)\n # train folder must be \"train\", validation folwer must be \"valid\"\n # each file must be correctly classified (=within the correct id folder). file name doesn't matter\n model_param['data_dir'] = in_arg.data_dir\n train_dir = model_param['data_dir'] + '/train'\n valid_dir = model_param['data_dir'] + '/valid'\n\n model_param['save_dir'] = in_arg.save_dir\n \n # Prepare the transformations for train & validation sets\n train_transforms = transforms.Compose([transforms.RandomRotation(30),\n transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\n\n valid_transforms = transforms.Compose([transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\n\n try:\n # Load the datasets with ImageFolder\n train_dataset = datasets.ImageFolder(train_dir, transform=train_transforms)\n valid_dataset = datasets.ImageFolder(valid_dir, transform=valid_transforms)\n\n model_param['class_to_idx'] = train_dataset.class_to_idx\n \n # TODO: Using the image datasets and the trainforms, define the dataloaders\n train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=in_arg.batch_size, shuffle = True)\n valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=in_arg.batch_size, shuffle = True)\n\n # Initialize the cat_to_name catalog\n #with open(in_arg.cat_to_name, 'r') as f:\n #cat_to_name = json.load(f)\n # model_param['cat_to_name'] = json.load(f)\n\n except Exception as e:\n print(\"An exception occured: {}.\".format(e))\n sys.exit(0)\n\n print(\"Data loading completed!\")\n\n # Return all parameters we will need later on\n return train_loader, valid_loader, model_param","def preprocess_test_data(self):\r\n print(\"* Preprocessing test data.\", flush=True)\r\n prep.create_HDF_file(self.C.test_set)\r\n\r\n self.print_time_elapsed()","def prepare_learning(self):\n print 'Separating inputs and outputs...'\n self.inputs, self.outputs = extract_samples(self.matches,\n self.input_features,\n self.output_feature)\n\n print 'Normalizing data...'\n self.normalizer, self.inputs = normalize(self.inputs)\n\n print 'Separating train and test sets...'\n self.train_inputs, self.train_outputs, self.test_inputs, self.test_outputs = split_samples(self.inputs, self.outputs)\n\n print 'Building neural network...'\n self.network = buildNetwork(len(self.input_features),\n 2 * len(self.input_features),\n 1,\n outclass=SigmoidLayer,\n bias=True)\n\n print 'Building and filling pybrain train set object...'\n self.train_set = ClassificationDataSet(len(self.input_features))\n\n for i, input_line in enumerate(self.train_inputs):\n self.train_set.addSample(self.train_inputs[i],\n [self.train_outputs[i] - 1])\n\n self.trainer = BackpropTrainer(self.network, dataset=self.train_set,\n momentum=0.5, weightdecay=0.0)\n\n self.train_set.assignClasses()","def pre_process_data():\n data_list, header_list = Parser.__parse_csv_data(Parser.training_data_file)\n table = pandas.DataFrame(data_list, columns=header_list)\n table.drop(['date', 'employee id'], axis=1, inplace=True)\n unique_categories = table['category'].unique()\n unique_expense_desc = table['expense description'].unique()\n unique_tax_name = table['tax name'].unique()\n\n column_index = {\n 'input': {},\n 'output': {}\n }\n\n column_index['input']['pre-tax amount'] = {\n 'column_index': 0,\n 'type': 'int'\n }\n\n column_index['input']['tax amount'] = {\n 'column_index': 1,\n 'type': 'int'\n }\n\n index = 2\n\n for i in range(len(unique_expense_desc)):\n column_index['input'][unique_expense_desc[i]] = {\n 'column_index': i + index,\n 'type': 'str'\n }\n\n index += len(unique_expense_desc)\n\n for i in range(len(unique_tax_name)):\n column_index['input'][unique_tax_name[i]] = {\n 'column_index': i + index,\n 'type': 'str'\n }\n\n for i in range(len(unique_categories)):\n column_index['output'][unique_categories[i]] = {'value': i}\n\n Parser.__save_column_index(column_index)","def prepare_for_predict(self) -> None:\n _, self.all_labels_embed = self._create_all_labels_embed()","def prep_input_data(parameter_df):\n # Make sure the shape is 3D\n # assert len(x_shape) == 3, \"Input shape should be 3D\"\n\n # Create an empty list in which to store objects\n n_mods = len(parameter_df)\n mods_for_default = [None for _ in range(n_mods)]\n hyperopt_args = [None for _ in range(n_mods)]\n model_params = [None for _ in range(n_mods)]\n for i, (_, row) in enumerate(parameter_df.iterrows()):\n\n # Pull info needed to instantiate model\n major_model = row[\"ModelClass\"]\n specific_model = row[\"SpecificModel\"]\n\n # Define the model and training parameters\n model_params[i] = DEFAULT_MODEL_PARAMS[major_model][specific_model].copy()\n\n # Instantiate a model with default parameters\n mods_for_default[i] = MldeModel(major_model, specific_model,\n model_params=model_params[i],\n training_params=DEFAULT_TRAINING_PARAMS[major_model],\n eval_metric=mse)\n\n # Package args for hyperopt\n hyperopt_args[i] = (major_model, specific_model, row[\"NHyperopt\"])\n\n # Return the instantiated models and the hyperopt args\n return mods_for_default, hyperopt_args,model_params","def prepare_training_data(collection_of_positive_segments, collection_of_negative_segments):\n\n\n\tprint \"Preparing training data...\"\n\n\ttraining_vectors = []\n\ttraining_labels = []\n\n\n\tfor segment in collection_of_positive_segments.list_of_segments:\n\t\tvector = get_segment_feature_vector(segment)\n\n\t\ttraining_labels.append(\"Correct\")\n\t\ttraining_vectors.append(vector)\n\t\t\n\t\t\n\tfor segment in collection_of_negative_segments.list_of_segments:\n\t\tvector = get_segment_feature_vector(segment)\n\t\ttraining_labels.append(\"Incorrect\")\n\t\ttraining_vectors.append(vector)\n\t\t\n\t\n\ttraining_vectors = normalize_train_data(training_vectors)\n\t\n\t\t\n\t#data = VectorDataSet(training_vectors,L=training_labels)","def preprocess(self, train_file, validation_file, test_file):\n chardict, labeldict = self.make_dictionary(train_file, validation_file, test_file)\n print 'preparing training data'\n training = self.parse_file(train_file, chardict, labeldict)\n \n print 'preparing validation data'\n validation = self.parse_file(validation_file, chardict, labeldict)\n\n print 'preparing test data'\n test = self.parse_file(test_file, chardict, labeldict)\n\n return Data(training, validation, test, chardict, labeldict)","def load_cleaned_data(self):\n try:\n self.train = pd.read_pickle('../input/train_clean.pkl')\n self.test = pd.read_pickle('../input/test_clean.pkl')\n except FileNotFoundError:\n self.load_raw_data()","def setup(self, stage=None):\n self.data_train, self.data_val, self.data_test = [None] * 3","def generatePredictorDataTemplate(self):\n self.__pdir = Predictor.directory\n self.__predictorData = PredictorData(None)\n self.save()","def load_data_preprocess(self):\n\n print(\"Loading the dataset ...\")\n # load the data\n c_util = CarUtils()\n train_x, train_y, test_x, test_y, classes = c_util.load_data()\n\n # set the image ordering\n K.set_image_dim_ordering(\"th\")\n\n print(\"Pre-processing the dataset ...\")\n # pre-process the data\n train_x = train_x.astype('float32')\n test_x = test_x.astype('float32')\n\n train_x = train_x / 255\n test_x = test_x / 255\n\n print(train_x.shape[0], ' train samples')\n print(test_x.shape[0], ' test samples')\n\n train_y = np_utils.to_categorical(train_y, CarsClassifierModel._nb_classes)\n test_y = np_utils.to_categorical(test_y, CarsClassifierModel._nb_classes)\n\n return train_x, train_y, test_x, test_y","def prepare_model(self, **kwargs):\n pass","def build_model():","def prepare_data(dataset, train_ratio=0.8, input_dim=None, seed=10):\n # Retrieve main path of project\n dirname = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\n\n # Download and store dataset at chosen location\n if dataset == 'Cora' or dataset == 'PubMed' or dataset == 'Citeseer':\n path = os.path.join(dirname, 'data')\n data = Planetoid(path, name=dataset, split='full')[0]\n data.name = dataset\n data.num_classes = (max(data.y)+1).item()\n # data.train_mask, data.val_mask, data.test_mask = split_function(data.y.numpy())\n # data = Planetoid(path, name=dataset, split='public', transform=T.NormalizeFeatures(), num_train_per_class=20, num_val=500, num_test=1000)\n\n elif dataset == 'Amazon':\n path = os.path.join(dirname, 'data', 'Amazon')\n data = Amazon(path, 'photo')[0]\n data.name = dataset\n data.num_classes = (max(data.y)+1).item()\n data.train_mask, data.val_mask, data.test_mask = split_function(\n data.y.numpy(), seed=seed)\n # Amazon: 4896 train, 1224 val, 1530 test\n \n elif dataset in ['syn1', 'syn2', 'syn4', 'syn5']: \n data = synthetic_data(\n dataset, dirname, train_ratio, input_dim)\n \n elif dataset == 'syn6':\n data = gc_data(dataset, dirname, train_ratio)\n\n elif dataset == 'Mutagenicity':\n data = gc_data(dataset, dirname, train_ratio)\n\n return data","def prepare_data():\n if FLAGS.word_embeddings:\n # Get the dialogue data manually.\n vocab_dir = os.path.join(FLAGS.data_dir, \"word2vec\")\n train_ids = os.path.join(vocab_dir, \"train_ids%d\" % FLAGS.vocab_size)\n test_ids = os.path.join(vocab_dir, \"test_ids%d\" % FLAGS.vocab_size)\n train_data = data_utils.read_data(train_ids, buckets, FLAGS.max_read_train_data,\n FLAGS.start_read_train_data)\n test_data = data_utils.read_data(test_ids, buckets, FLAGS.max_read_test_data,\n FLAGS.start_read_test_data)\n embeddings_file = os.path.join(vocab_dir, \"vocab%d_embeddings\" % FLAGS.vocab_size)\n else:\n # Get dialogue data using the functions in data_utils.py\n print(\"Preparing dialogue data in %s\" % FLAGS.data_dir)\n train_data, test_data = data_utils.prepare_dialogue_data(\n FLAGS.words, FLAGS.data_dir, FLAGS.vocab_size, buckets,\n FLAGS.max_read_train_data, FLAGS.max_read_test_data,\n FLAGS.start_read_train_data, FLAGS.start_read_test_data,\n read_again=FLAGS.read_again, save=FLAGS.save_pickles)\n embeddings_file = None\n return train_data, test_data, embeddings_file","def main():\n df = prepro_last()\n X, y = train_build(df)\n fit_store(X, y)","def initSets(self):\n data_frame = pd.read_csv(self.train_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n if self.test_file is None:\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n else:\n data_frame = pd.read_csv(self.test_file, header=None)\n data_frame = data_frame.drop(columns=self.drop_cols)\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\n features = data_frame.iloc[:, :-1].values\n labels = data_frame.iloc[:, -1].values\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\n # kfold = KFold(n_splits=3)\n # self.train_index, self.test_index = kfold.split(features,labels)","def pre_train(self, dataset, **kwargs):\n\n pass","def _prepare_for_training(\n self,\n trackers: List[TrackerWithCachedStates],\n domain: Domain,\n precomputations: MessageContainerForCoreFeaturization,\n **kwargs: Any,\n ) -> Tuple[RasaModelData, np.ndarray]:\n training_trackers = self._get_trackers_for_training(trackers)\n # dealing with training data\n tracker_state_features, label_ids, entity_tags = self._featurize_for_training(\n training_trackers,\n domain,\n precomputations=precomputations,\n bilou_tagging=self.config[BILOU_FLAG],\n **kwargs,\n )\n\n if not tracker_state_features:\n return RasaModelData(), label_ids\n\n self._label_data, encoded_all_labels = self._create_label_data(\n domain, precomputations=precomputations\n )\n\n # extract actual training data to feed to model\n model_data = self._create_model_data(\n tracker_state_features, label_ids, entity_tags, encoded_all_labels\n )\n\n if self.config[ENTITY_RECOGNITION]:\n self._entity_tag_specs = (\n self.featurizer.state_featurizer.entity_tag_specs\n if self.featurizer.state_featurizer is not None\n else []\n )\n\n # keep one example for persisting and loading\n self.data_example = model_data.first_data_example()\n\n return model_data, label_ids","def prepare_data(vocabulary_size):\n print(\"Downloading data from \" + _DATA_DIR_ +\"..\")\n getData(_DATA_DIR_)\n print(\"Creating Vocabulary..\")\n create_vocabulary( _VOCAB_DIR_, _RAW_SENTENCES_DIR_, vocabulary_size )\n print(\"Converting sentences to sequences of ids..\")\n data_to_token_ids( _RAW_SENTENCES_DIR_ , _SENTENCES_DIR, _VOCAB_DIR_ )","def launch(self, force_prep=False):\n #TODO process upploaded csv\n assert self.ready()\n self.launch_progress = 0\n self.set_status(\"Gathering data\")\n if 'O' not in set(self.labels.dict.values()):\n self.add_labels({max(list(self.labels.dict.keys()))+1:'O'})\n\n processed_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.csv')\n bert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.bert')\n elmo_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.elmo')\n nlp_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.nlp')\n sbert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.sbert')\n if os.path.exists(processed_file_path) and not force_prep:\n df = pd.read_csv(processed_file_path)\n if 'span_label' in df.columns:\n df['span_label']=df['span_label'].apply(eval)\n # Let's say loading the file is ~half the launch time\n # (if the file already exists)\n self.total = 2\n self.update(1)\n else:\n datafiles = [os.path.join(DATASETS_PATH, self.dataset_uuid, d) \\\n for d in os.listdir(os.path.join(DATASETS_PATH, self.dataset_uuid))]\n df = concat_dataset(datafiles)\n # expand total to account for time it takes to initialize the model\n self.total = len(df)*(1.1) \n self.set_status(\"Preprocessing data\")\n df = self.process_data(df, processed_file_path)\n\n # load list of 'allennlp.data.instance's. allennlp.data.instance can store true labels and tag info internally.\n if os.path.exists(nlp_file_path) and not force_prep:\n with open(nlp_file_path, 'rb') as f:\n sentences = pickle.load(f)\n else:\n #TODO define a universal reader for certain format\n # reader = RestaurantsDatasetReader()\n # data = reader.read(processed_file_path)\n #TODO handle when aux files do not exist\n pass\n bert_emb = np.load(bert_file_path, allow_pickle=True)\n elmo_emb = np.load(elmo_file_path, allow_pickle=True)\n sbert_emb = np.load(sbert_file_path, allow_pickle=True)\n for s, b, e, sb in zip(sentences, bert_emb, elmo_emb, sbert_emb):\n s.fields['bert'] = b\n s.fields['sbert'] = sb\n s.fields['elmo'] = e\n\n df['bert'] = bert_emb\n df['sbert'] = [sb for sb in sbert_emb]\n df['elmo'] = elmo_emb\n df['text_nlp'] = sentences\n\n columns_to_drop = list(\n set(df.columns).intersection(set(['span_label','file','label'])))\n df = df.drop(columns=columns_to_drop).reset_index()\n # since df['text_nlp'] contains true label info, drop 'labels' column.\n columns_to_drop = list(set(df.columns).difference(set(['index', 'Unnamed: 0', 'text', 'labels', 'split', 'bert', 'sbert',\n 'elmo', 'text_nlp'])))\n if len(columns_to_drop) > 0:\n df = df.drop(columns=columns_to_drop)\n df_train = df[df['split']=='train']\n df_dev = df[df['split'] == 'dev']\n df_valid = df[df['split'] == 'valid']\n df_test = df[df['split'] == 'test']\n\n self.text_inv_dict = dict(\n zip(list(df['text']),list(df.index))\n )\n\n # TODO split heldout set if necessary\n # for now, passing empty df as heldout set\n df_heldout = df_test\n\n self.emb_dict = Embeddings(df)\n\n self.set_status(\"Initializing modeler\")\n self.modeler = Modeler(df_train, df_dev, df_valid, df_test, df_heldout, self.labels, emb_dict=self.emb_dict)\n\n self.launch_progress = 1.0\n self.set_status(\"Finished\")\n return self.modeler","def dataset_preparation():\r\n with open('../data/patterns_num.txt', 'r') as f:\r\n data = f.readlines()\r\n X, Y = [], []\r\n for line in data:\r\n x, y = line.split('\\t')\r\n if len(x) > 5 and x not in X: # better results are achieved excluding short query patterns\r\n X.append(x.replace(\"X\", \"\").replace(\"Y\", \"\").lower())\r\n Y.append(int(y.replace('\\n', '')))\r\n test_size = 0.2\r\n # print('Test size:', test_size, '\\nWrong classifications:\\n')\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=42, stratify=Y)\r\n return X_train, y_train, X_test, y_test","def initialize(self):\n for key in self.parameter_dict:\n self.models[key] = self._create_model(key)","def create_data_model():\r\n data = {}\r\n data['distance_matrix'] = distance_matrix.tolist()\r\n data['time_matrix'] = time_matrix.tolist()\r\n data['time_windows'] = time_windows.tolist()\r\n data['pickups_deliveries'] = pickup_deliveries.tolist()\r\n data['demands'] = demand\r\n data['num_vehicles'] = 20\r\n data['vehicle_capacities'] = [20 * i / i for i in range(1, num_vehicles+1)]\r\n data['depot'] = (2 * length) - 1\r\n return data","def _prepare_libsvm_data(self):\n logging.info('Preparing libsvm training data...')\n if self.clean or not (self.is_s3_file(self.s3_training_file) and self.is_s3_file(self.s3_validation_file)):\n logging.info('S3 libsvm files do not exist.')\n if self.clean or not (os.path.isfile(self.local_libsvm_training_file) and os.path.isfile(self.local_libsvm_validation_file)):\n logging.info('Local libsvm files do not exist.')\n logging.info('Generating local libsvm files...')\n dump_svmlight_file(X=self.training_x, y=self.training_y, f=self.local_libsvm_training_file)\n dump_svmlight_file(X=self.validation_x, y=self.validation_y, f=self.local_libsvm_validation_file)\n logging.info('Local libsvm files found. Uploading to S3...')\n upload_file_to_s3(self.local_libsvm_training_file, self.infra_s3['s3_bucket'], self.s3_training_file)\n upload_file_to_s3(self.local_libsvm_validation_file, self.infra_s3['s3_bucket'], self.s3_validation_file)\n else:\n logging.info('S3 libsvm files already exist. Skipping step.')","def prepare_data(self,d):\n train_loaders, train_iters = {}, {}\n unlabeled_loaders, unlabeled_iters = {}, {}\n for domain in opt.domains:\n #CONVERT TO FLOAT32\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\n train = data_utils.TensorDataset(features,target)\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\n train_iters[domain] = iter(train_loaders[domain])\n for domain in opt.unlabeled_domains:\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\n uset = data_utils.TensorDataset(features,target)\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\n \n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters","def prepare_evaluation(self):\n self.model = load_model(self.path_best_model)\n\n if not self.is_exist(f'{self.path_model_directory}evaluation_ready_sequences.data'):\n self.evaluation_dataframe = self.remove_catalogs(dataframe=self.load_evaluation_data())\n\n self.evaluation_dataframe.drop(['catalog_item_list', 'session_start_time', 'good_catalog_items', 'sequence_length'], axis=1, inplace=True)\n self.evaluation_dataframe['decoded_item_sequence'] = self.evaluation_dataframe['item_sequence'].copy(deep=True)\n\n sequences = self.evaluation_dataframe.values.tolist()\n joblib.dump(sequences, f'{self.path_model_directory}evaluation_ready_sequences.data')\n else:\n sequences = joblib.load(f'{self.path_model_directory}evaluation_ready_sequences.data')\n self.load_model_metadata()\n\n # Set the encode vector size to 1 since this model is not using any encoding for the features\n self.encoding_vector_size = 1\n self.evaluation_creator(sequences_to_evaluate=sequences, evaluation_class=Evaluator)","def prepare(self):\n # get data from file\n train_data, test_data = return_speechacts()\n # y are the speechacts or 'labels'\n y_train = [t.split(' ')[0] for t in train_data]\n y_test = [t.split(' ')[0] for t in test_data]\n # x are the sentences\n x_train = [\" \".join(t.split(' ')[1:]) for t in train_data]\n x_test = [\" \".join(t.split(' ')[1:]) for t in test_data]\n # use the tokenizer and padding from keras to assign arrays of integers\n # to sentences, out of vocabulary token is 1\n self.tokenizer_x = Tokenizer(oov_token=1)\n self.tokenizer_x.fit_on_texts(x_train + x_test)\n xt_train = self.tokenizer_x.texts_to_sequences(x_train)\n xt_train = pad_sequences(xt_train, maxlen=self.sentence_size,\n dtype='int32')\n xt_test = self.tokenizer_x.texts_to_sequences(x_test)\n xt_test = pad_sequences(xt_test, maxlen=self.sentence_size,\n dtype='int32')\n # vocab is the number of words in our vocabulary\n self.vocab = len(self.tokenizer_x.word_index) + 1\n # do the same for labels\n self.tokenizer_y = Tokenizer()\n self.tokenizer_y.fit_on_texts(y_train + y_test)\n yt_train = self.tokenizer_y.texts_to_sequences(y_train)\n yt_train = [t[0] for t in yt_train]\n yt_train = to_categorical(yt_train)\n yt_test = self.tokenizer_y.texts_to_sequences(y_test)\n yt_test = [t[0] for t in yt_test]\n yt_test = to_categorical(yt_test)\n self.x_train = x_train\n self.y_train = y_train\n self.x_test = x_test\n self.y_test = y_test\n self.xt_train = xt_train\n self.yt_train = yt_train\n self.xt_test = xt_test\n self.yt_test = yt_test","def _load_data(self):\n\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\n self.task_num\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\n\n read_data_x = pd.read_csv(path_data_x)\n read_data_y = pd.read_csv(path_data_y)\n read_data_meta = pd.read_csv(path_meta)\n\n # Drop columns if it only contains 1 unique element\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\n\n num_col = pd.read_csv(path_numerical_columns)\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\n col_idx = np.arange(read_data_x.shape[-1])\n non_num_col = np.setdiff1d(col_idx, num_col)\n\n # new_data_x = np.array(read_data_x).astype(np.float32)\n new_data_x = np.array(read_data_x)\n new_data_y = np.array(read_data_y).astype(np.float32)\n new_data_meta = np.array(read_data_meta).astype(np.float32)\n\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\n\n\n # Winsorize dataset\n len_feat = new_data_x.shape[-1]\n idx_list = list(num_col)\n for i in range(len_feat):\n if i in idx_list:\n cur_data = new_data_x[:, i]\n cur_data = np.array(cur_data)\n lower_p = np.percentile(cur_data, 5)\n higher_p = np.percentile(cur_data, 95)\n cur_data[cur_data < lower_p] = lower_p\n cur_data[cur_data > higher_p] = higher_p\n new_data_x[:, i] = cur_data\n\n # Make sure target data is one-hot encoded\n if new_data_y.shape[-1] == 1:\n num_class = len(np.unique(new_data_y))\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\n new_data_y = new_data_y.astype('float32')\n self.orig_column_names = read_data_x.columns\n self.data_x = new_data_x # N x F\n self.data_y = new_data_y # N x C\n self.numerical_idx = num_col # list of idx\n self.non_num_idx = non_num_col # None\n\n # Calculate adjacency matrix\n self.meta_inf = new_data_meta.astype('float32') # N x 3\n if self.args.graph_type:\n self.adj = self.get_adjacency()","def prep_data(dataset_config=None):\n \n\n data_struct = DataStruct(dataset_config)\n\n data_name = data_struct.name\n datasets_dir = data_struct.data_path\n out_dir = data_struct.save_path\n\n # If dataset already downloaded an unpacked, do nothing\n if os.path.isdir(out_dir):\n print('{} already downloaded, unpacked and processed.'.format(data_name))\n return\n\n # Check if download is required\n data_url = data_struct.url\n compressed_file_name = downloader(datasets_dir, data_url)\n\n # Unpack compressed dataset file\n unpacker(compressed_file_name, out_dir)\n\n # Custom preprocessing steps for data sets\n custom_preprocessor(out_dir)","def preprocess():\n\n # Read Training and Test Data\n train_df = pd.read_csv(configs.TRAIN_DATA_PATH)\n test_df = pd.read_csv(configs.TEST_DATA_PATH)\n\n # Data Exploration and Preprocessing\n user_ids = train_df['userId']\n movie_ids = train_df['movieId']\n ratings = train_df['rating']\n\n # Create the mapping and save it for later usage in testing\n all_users = create_mapping(pd.concat([train_df['userId'], test_df['userId']], axis = 0))\n all_movies = create_mapping(pd.concat([train_df['movieId'], test_df['movieId']], axis = 0))\n\n\n # Save the mapping arrays for users and movies\n with open(configs.USER_IDS_PATH, \"wb\") as f:\n np.save(f, all_users)\n\n with open(configs.MOVIE_IDS_PATH, \"wb\") as f:\n np.save(f, all_movies)\n\n\n # Resetting the ids of training data to [0-n]\n user_ids = map_ids(user_ids, users = True)\n movie_ids = map_ids(movie_ids, users = False)\n\n\n # Resetting the ids of test data\n test_user_ids = map_ids(test_df['userId'], users = True)\n test_movie_ids = map_ids(test_df['movieId'], users = False)\n test_ratings = test_df['rating']\n\n # Statistics of training data\n # Number of users and movies can be extracted from the array of mapped ids\n n_users = np.max(user_ids) + 1\n n_movies = np.max(movie_ids) + 1\n\n # Statistics of test data\n test_n_users = np.max(test_user_ids) + 1\n test_n_movies = np.max(test_movie_ids) + 1\n\n # Returning the indices back can be done using unmap_ids function\n # Example\n # unmap_ids(movie_ids, users = False)\n # unmap_ids(user_ids, users = True)\n\n # Define the training rating matrix as sparse matrix\n\n # Sparse rating matrix from training data\n R = sparse.coo_matrix(\n (ratings, (user_ids, movie_ids)),\n shape=(n_users, n_movies),\n dtype=np.float\n )\n\n\n\n # Save the rating matrix for training data\n sparse.save_npz(configs.R_TRAIN_MATRIX_PATH, R)\n\n # Sparse rating matrix from test data\n R2 = sparse.coo_matrix(\n (test_ratings, (test_user_ids, test_movie_ids)),\n shape=(test_n_users, test_n_movies),\n dtype=np.float\n )\n\n # Save the rating matrix for test data\n sparse.save_npz(configs.R_TEST_MATRIX_PATH, R2)\n\n # return user_ids, movie_ids, ratings, n_users, n_movies, R, R2\n return R, R2","def setup(self):\n\n module = [m for m in Rt.modules if m.name == self.module_name][0]\n\n # Take CPACS file from the optimisation\n cpacs_path = module.cpacs_in\n tixi = open_tixi(cpacs_path)\n self.Model = load_surrogate(tixi)\n tixi.save(cpacs_path)\n\n df = self.Model.df\n df.set_index(\"Name\", inplace=True)\n for name in df.index:\n if df.loc[name, \"type\"] == \"obj\":\n self.add_output(name)\n elif df.loc[name, \"type\"] == \"des\":\n self.add_input(name)\n\n self.xd = df.loc[[name for name in df.index if df.loc[name, \"type\"] == \"des\"]]\n self.yd = df.loc[[name for name in df.index if df.loc[name, \"type\"] == \"obj\"]]","def _create_data():\n tf.logging.info(\"Create records..\")\n train, val, test = util.load_data(data_dir, FLAGS[\"is_aug\"])\n tf.logging.info(\"Dataset size: Train-{} Test-{} Val-{}\".format(len(train), len(test), len(val)))\n return train, val, test","def compile(self):\n self.train = self._make_train()\n self.loss_test = self._make_loss_test()\n self.predict = self._make_predict()","def preprocess(self):","def preprocessing_pipeline(self):\n self.__multilabel_processing()\n self.__split_dataset()\n self.__save_datasets()","def preprocess(self):\n\n print('[ INFO ]: Preprocessing abalone data...')\n\n # Rename headers of data frame\n abalone_data = pd.read_csv(self.abalone_path, header=None)\n abalone_data.columns = [\n 'sex','length','diameter','height','whole_weight','shucked_weight',\n 'viscera_weight','shell_weight','rings'\n ]\n categorical_features = [\n 'sex'\n ]\n continuous_features = [\n 'length','diameter','height','whole_weight','shucked_weight',\n 'viscera_weight','shell_weight'\n ]\n predictor = 'rings'\n\n df = alg.continuous_to_discrete(self, abalone_data, continuous_features)\n\n classes = abalone_data[predictor].unique().tolist()\n\n features = [df.columns[j] for j in range(len(df.columns)) if df.columns[j] != predictor]\n\n return df, features, predictor, classes","def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\n for alpha in range(1, self.ALPHAs+1):\n if alpha != self.ALPHAs:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\n else:\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\n os.makedirs(new_cluster_dir, exist_ok=True)\n\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\n os.makedirs(new_prepared_data_dir, exist_ok=True)\n \n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\n pass\n else:\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No input datasets pre-processed for alpha of {alpha}\")\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\n\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\n print(f\"=> No rainfall datasets pre-processed for alpha of {alpha}\")\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\n \n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\n{new_prepared_data_dir}')","def __init__(self):\n self.train(positivity_files, 0)\n self.train(subjectivity_files, 1)","def preprocess(dataset):\n preped_dataset = {}\n preped_dataset['c'] = preprocess_set(dataset['c'])\n preped_dataset['r'] = preprocess_set(dataset['r'])\n preped_dataset['y'] = dataset['y']\n return preped_dataset","def prepare_data(self):\n self.empty = 'yes' if len(self.data) == 0 else 'no'\n self._keys = sorted(key for key in self.data.keys())\n\n # Validate the keys\n for key in self._keys:\n if not is_valid_matlab_field_label(key):\n msg = \"'{}' is not a valid MATLAB field label\".format(key)\n raise ValueError(msg)\n self.field_names = \" \".join(self._keys)","def prep_tree_data(self, number: int):\n filename = \"data-before-normalization-{}-out-of-7.csv\".format(number)\n path = str(DATA_PATH.joinpath(\"data-splitted\", filename))\n df = pandas.read_csv(path)\n\n df.drop(df.columns[0], axis=1, inplace=True)\n assessments = [x for x in df.columns.values if x.split(\"_\")[0] == \"assessment\"]\n df['average_score'] = df[assessments].mean(skipna=True, axis=1)\n for assessment in assessments: # somehow he doesn't want to fillna in a batch?\n df[assessment].fillna(df['average_score'], inplace=True)\n clicks = [x for x in df.columns.values if x.split(\"_\")[0] == \"vle\"]\n df['vle_click_average'] = df[clicks].mean(skipna=True, axis=1)\n for click in clicks: # somehow he doesn't want to fillna in a batch?\n df[click].fillna(df['vle_click_average'], inplace=True)\n df.dropna()\n\n self.change_oh_cat(\"gender\", df)\n self.change_oh_cat(\"highest_education\", df)\n self.change_oh_cat(\"imd_band\", df)\n self.change_oh_cat(\"age_band\", df)\n self.change_oh_cat(\"disability\", df)\n result_order = {'final_result__Fail': 0, 'final_result__Withdrawn': 2,\n 'final_result__Pass': 1, 'final_result__Distinction': 3}\n self.change_oh_cat(\"final_result\", df, result_order)\n df[\"final_result\"].replace(2, 0, inplace=True)\n df[\"final_result\"].replace(3, 1, inplace=True)\n\n target = df[\"final_result\"]\n df.drop([\"final_result\"], axis=1, inplace=True)\n\n x_train, x_test, y_train, y_test = train_test_split(df, target, test_size=0.1,\n random_state=32, shuffle=True,\n stratify=target)\n\n return x_train, x_test, y_train, y_test","def _restore_data_inputs(self):\n super()._restore_data_inputs()\n self.training_data = (\n self._data.training_data.data if self._data.training_data and self._data.training_data.data else None\n )\n self.validation_data = (\n self._data.validation_data.data if self._data.validation_data and self._data.validation_data.data else None\n )","def create_meta_data_pickle(self):\n self.user_sequences_dataframe = joblib.load(self.path_train_dataframe)\n\n self.item_dictionary = pickle.load(open(self.path_item_dictionary, 'rb'))\n self.number_of_distinct_items = len(self.item_dictionary)\n self.encoding_vector_size = 1\n\n joblib.dump(value=self.retrieve_base_info_dictionary(), filename=self.path_model_metadata)","def __initDataFromImages(self):\n #Check if the local_db exist\n initial_dirs = os.listdir(os.getcwd())\n is_db_empty = False\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\n [images_dir] = os.listdir(self.base_dir)\n is_db_empty = images_dir == cfg.local[\"IMG_DIR\"]\n if cfg.local[\"DEFAULT_IMGS_DIR\"] in initial_dirs and is_db_empty:\n default_path = os.path.join(os.getcwd(), cfg.local[\"DEFAULT_IMGS_DIR\"])\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\n self.le = LabelEncoder()\n #Nothing relate to mapping name to dir here, we don't care about\n #This data because of the user doesn't exist in the database\n self.__savePreProcessedData()","def _load_data(self):\n\n path_data_x = \\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_feature_data' \\\n '.csv'\n path_data_y = \\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_label_data' \\\n '.csv'\n path_meta = '/workspace/base-ml/data/tadpole' \\\n '/adni_one_baseline_meta_data' \\\n '.csv'\n read_data_x = pd.read_csv(path_data_x)\n read_data_y = pd.read_csv(path_data_y) # 0 NL, 1, MCI, 2 Dementia\n read_data_meta = pd.read_csv(path_meta)[['AGE', 'PTGENDER', 'APOE4']]\n\n # Replace gender to numeric\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Male', 0)\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Female', 1)\n\n new_data_x = np.array(read_data_x).astype(np.float32)\n new_data_y = np.array(read_data_y).astype(np.float32)\n new_data_meta = np.array(read_data_meta).astype(np.float32)\n\n # Concat meta-information with feature vector input\n concat_meta = pd.DataFrame(new_data_meta)\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(0, 'zero')\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(1, 'one')\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(2, 'two')\n concat_meta = concat_meta.to_numpy()\n new_data_x = np.concatenate([concat_meta, new_data_x], 1)\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\n\n self.orig_column_names = ['Age', 'Gender', 'APOE4'] + \\\n list(read_data_x.columns)\n self.data_x = new_data_x\n self.data_y = self.to_one_hot_encoding(new_data_y)\n self.numerical_idx = np.arange(new_data_x.shape[-1])\n self.numerical_idx = np.delete(self.numerical_idx, [2]) # Remove APOE column idx\n self.non_num_idx = np.array([2])\n self.all_non_numerical_idx = None\n\n # self.numerical_idx = np.arange(self.data_x.shape[-1])\n # self.non_num_idx = None\n # self.all_non_numerical_idx = None\n\n # Calculate adjacency matrix\n self.meta_inf = new_data_meta.astype('float32')\n if self.args.graph_type:\n self.adj = self.get_adjacency()"],"string":"[\n \"def _prepare_data(self):\\n #TODO hardcoded values need to change\\n print_info(\\\"Preprocessing the train data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"train\\\"),\\n self.TRAIN_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the test data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"test\\\"),\\n self.TEST_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the validation data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"val\\\"),\\n self.VAL_OUT_PATH)\",\n \"def prepare_data(self):\\n try:\\n self.train_dataset = self.datasets['train']\\n self.val_dataset = self.datasets['val']\\n try:\\n self.test_dataset = self.datasets['test']\\n except:\\n pass\\n except Exception as e:\\n print('Data was not succesfully prepared:', e)\",\n \"def prepare_data(self):\\n # Set up the path\\n self.path_target_train = os.path.join(self.data_dir, self.train_path_file_target + \\\".pkl\\\")\\n self.path_target_test = os.path.join(self.data_dir, self.test_path_file_target + \\\".pkl\\\")\\n\\n if not os.path.exists(self.path_target_train) or not os.path.exists(self.path_target_test):\\n # Create vocabularies of the appropriate sizes.\\n self.create_vocabulary(self.train_path_file)\\n\\n # Create token ids for the training data.\\n input_train_path = self.train_path_file\\n target_train_path = self.train_path_file_target\\n train_input, train_input_length, train_labels = self.data_to_token_ids(input_train_path, target_train_path)\\n\\n # Create token ids for the validation data.\\n input_test_path = self.test_path_file\\n target_test_path = self.test_path_file_target\\n test_input, test_input_length, _ = self.data_to_token_ids(input_test_path, target_test_path, train=False)\\n\\n # Collect data into a list\\n training_data = [train_input, train_input_length, train_labels]\\n test_data = [test_input, test_input_length]\\n\\n # Save all the data\\n with open(self.path_target_train, 'wb') as f:\\n pickle.dump(training_data,f)\\n with open(self.path_target_test, 'wb') as f:\\n pickle.dump(test_data, f)\\n else:\\n # Load data\\n with open(self.path_target_train, 'rb') as f:\\n training_data = pickle.load(f)\\n with open(self.path_target_test, 'rb') as f:\\n test_data = pickle.load(f)\\n\\n # Initialize vocabulary\\n self.initialize_vocabulary()\\n\\n # Convert list into a numpy array - train data\\n train_input = pd.DataFrame(training_data[0]).fillna(value=0).astype(int).values\\n train_length_input = np.array(training_data[1], dtype=int)\\n train_labels = np.array(training_data[2], dtype=int)\\n\\n # Convert list into a numpy array - test data\\n test_input = pd.DataFrame(test_data[0]).fillna(value=0).astype(int).values\\n test_length_input = pd.DataFrame(test_data[1]).fillna(value=0).astype(int).values\\n\\n # Printing maximum length\\n print(\\\"Shape of the input training matrix {}\\\".format(str(train_input.shape)))\\n print(\\\"Shape of the input test matrix {}\\\".format(str(test_input.shape)))\\n\\n # Copy the files\\n self.copy_files()\\n\\n # Return output\\n return train_input, train_length_input, train_labels, test_input, test_length_input\",\n \"def preprocess_data(self):\\n\\n self._preprocess_train_data()\\n self._preprocess_test_data()\",\n \"def prepare_data(self):\\n data = self._get_dataset(self.hparams.dataset_path)\\n label_encoder = data[\\\"label_encoder\\\"]\\n del data[\\\"label_encoder\\\"]\\n\\n click.secho(\\\"Building inputs and labels.\\\", fg=\\\"yellow\\\")\\n datasets = {\\n \\\"train\\\": defaultdict(list),\\n \\\"valid\\\": defaultdict(list),\\n \\\"test\\\": defaultdict(list),\\n }\\n for dataset_name, dataset in data.items():\\n for sample in dataset:\\n instance = self.build_input(\\n self.tokenizer, sample[\\\"text\\\"], label_encoder, sample[\\\"label\\\"]\\n )\\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n\\n click.secho(\\\"Padding inputs and building tensors.\\\", fg=\\\"yellow\\\")\\n tensor_datasets = {\\\"train\\\": [], \\\"valid\\\": [], \\\"test\\\": []}\\n for dataset_name, dataset in datasets.items():\\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\\n for input_name in MODEL_INPUTS:\\n if input_name == \\\"labels\\\":\\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\\n else:\\n tensor = torch.tensor(dataset[input_name])\\n tensor_datasets[dataset_name].append(tensor)\\n\\n self.train_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"])\\n self.valid_dataset = TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n self.test_dataset = TensorDataset(*tensor_datasets[\\\"test\\\"])\\n click.secho(\\n \\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.train_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.valid_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Test dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.test_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\",\n \"def prepare_data():\\n gennet.prepare_data('Resnet50')\",\n \"def prepare_train_data(self):\\r\\n ## Impute rlkpis\\r\\n print(\\\"Imputing rlKPI df\\\")\\r\\n self.rlkpi.add_target_labels(1)\\r\\n self.rlkpi.impute_rl_kpis()\\r\\n\\r\\n print(\\\"Add 'met-real-station_no' & met-forecast-station_no to rl_kpis_df\\\")\\r\\n self.add_met_real_forecast_station_col_to_rlkpis()\\r\\n print(\\\"Merge 'met-real-sampled df to rl kps \\\")\\r\\n self.merge_met_real_sampled_df_to_rlkpis()\\r\\n\\r\\n ## Imputations for met-forecast\\r\\n print(\\\"Impute met-forecast\\\")\\r\\n met_forecast_obj = self.metfcast\\r\\n met_forecast_obj.impute_met_forecast()\\r\\n\\r\\n #Merge met forecast data to earlier merged data\\r\\n print(\\\"Merge Train data with imputed forecast df\\\")\\r\\n self.train_data = pd.merge(self.train_data,\\r\\n met_forecast_obj.imputed_forecast_df,\\r\\n on=['datetime-station_no'], indicator=True, how='inner')\\r\\n print(\\\"Check any imputation needed\\\", self.train_data.isna().sum().sum())\\r\\n self.train_data.drop(['_merge'], axis=1, inplace=True)\\r\\n self.perform_data_under_sampling(self.train_data)\",\n \"def prepare_data():\\n user_name = os.environ.get('USER')\\n traintest_corpus = ResumeCorpus('/Users/' + user_name + '/Documents/Data')\\n random.shuffle(traintest_corpus.resumes)\\n\\n for resume in traintest_corpus.resumes:\\n try:\\n review_text = pre_processing(resume[0])\\n review_text = \\\" \\\".join(review_text)\\n data_dict['data'].append(review_text)\\n data_dict['label'].append(resume[1])\\n except:\\n pass\",\n \"def prepare_data(self):\",\n \"def preprocess_train_data(self):\\r\\n print(\\\"* Preprocessing training data.\\\", flush=True)\\r\\n prep.create_HDF_file(self.C.training_set, is_training_set=True)\\r\\n\\r\\n self.print_time_elapsed()\",\n \"def prepare(self):\\n\\n # step 0: load only when not loaded yet\\n if TRAINING in self.data \\\\\\n and VALIDATION in self.data:\\n return\\n\\n # step 1: load the file names\\n file_list = sorted(glob.glob(self.location+\\\"*.mhd\\\"))\\n # count the number of data points\\n\\n # make a stratified validation set\\n # note, the seed decides the validation set, but it is deterministic in the names\\n random.seed(317070)\\n patient_names = [self.patient_name_from_file_name(f) for f in file_list]\\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\\n\\n # make the static data empty\\n for s in self.datasets:\\n self.data[s] = []\\n self.labels[s] = []\\n self.names[s] = []\\n\\n # load the filenames and put into the right dataset\\n labels_as_dict = defaultdict(list)\\n\\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\\n next(reader) # skip the header\\n for row in reader:\\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\\n labels_as_dict[str(row[0])].append(label)\\n\\n for patient_file in file_list:\\n patient_name = self.patient_name_from_file_name(patient_file)\\n\\n if patient_name in validation_patients:\\n s = VALIDATION\\n else:\\n s = TRAINING\\n label = labels_as_dict[str(patient_name)]\\n if self.only_positive and not label:\\n continue\\n self.data[s].append(patient_file)\\n \\n if self.pick_nodule:\\n self.labels[s].append([random.choice(label)]) \\n else:\\n self.labels[s].append(label)\\n \\n \\n self.names[s].append(patient_name)\\n\\n # give every patient a unique number\\n last_index = -1\\n for s in self.datasets:\\n self.indices[s] = range(last_index+1,last_index+1+len(self.data[s]))\\n if len(self.indices[s]) > 0:\\n last_index = self.indices[s][-1]\\n print s, len(self.indices[s]), \\\"samples\\\"\",\n \"def prepare_data(self):\\n if not os.path.exists(self.hparams.data_cache_dir):\\n os.mkdir(self.hparams.data_cache_dir)\\n for mode, filepath in zip(['train', 'val', 'test'],\\n [self.hparams.train_path, self.hparams.val_path, self.hparams.test_path]):\\n if mode == 'train':\\n label_mode = self.hparams.label_mode\\n else:\\n label_mode = 'major'\\n cached_features_file = self._feature_file(mode, label_mode)\\n\\n if not os.path.exists(cached_features_file):\\n logger.info('Creating features from dataset file at %s', filepath)\\n examples = read_examples_from_file(filepath, mode, label_mode)\\n features = convert_examples_to_features(\\n examples,\\n self.labels,\\n self.hparams.max_seq_length,\\n self.tokenizer,\\n cls_token_at_end=bool(self.hparams.model_type in ['xlnet']),\\n cls_token=self.tokenizer.cls_token,\\n cls_token_segment_id=2 if self.hparams.model_type in ['xlnet'] else 0,\\n sep_token=self.tokenizer.sep_token,\\n sep_token_extra=bool(self.hparams.model_type in ['roberta']),\\n pad_on_left=bool(self.hparams.model_type in ['xlnet']),\\n pad_token=self.tokenizer.convert_tokens_to_ids([self.tokenizer.pad_token])[0],\\n pad_token_segment_id=4 if self.hparams.model_type in ['xlnet'] else 0,\\n pad_token_label_id=self.pad_token_label_id,\\n )\\n logger.info('Saving features into cached file %s', cached_features_file)\\n torch.save(features, cached_features_file)\",\n \"def initialize(self):\\n LOG.info(\\\"Initializing Model.\\\")\\n self.model = self.convert(df=self.training_df)\\n if self.bootstraps is not None:\\n LOG.info(\\\"Bootstrapping Data.\\\")\\n self.bootstrap_data()\",\n \"def prepare(self):\\n if self.opts['verbose']:\\n print(\\\"Preparing dataset (one-time operation)...\\\")\\n # Create paths files and load them back in\\n self._build_ID_sets()\\n self._create_ID_files()\\n self._load_ID_files()\\n if self.opts['verbose']:\\n print(\\\"... done with preparing the dataset.\\\")\",\n \"def prepare(self):\\n\\t\\tif len(os.listdir(self.storagedir)):\\n\\t\\t\\traise Exception(\\\"There are already files in\\\", self.storagedir + \\\".\\\", \\\"Delete manually!\\\")\\n\\t\\t\\n\\t\\tself.worddict = {\\\"__pad__\\\": 0, \\\"__oov__\\\": 1}\\n\\t\\tself.classdict = {}\\n\\t\\tself.raw_documents, self.tokenized_documents = {}, {}\\n\\t\\tself.X, self.Y = {}, {}\\n\\n\\t\\tfor dataset in self.DATASETS_TMP:\\n\\t\\t\\tself.get_raw_data(dataset)\\n\\t\\t\\tself.delete_empty_documents(dataset)\\n\\t\\t\\tself.tokenize_documents(dataset)\\n\\n\\t\\tself.make_classdict()\\n\\t\\tself.make_worddict()\\n\\t\\tself.make_embeddings()\\n\\t\\tself.reverse_dicts()\\n\\n\\t\\tfor dataset in self.DATASETS_TMP:\\n\\t\\t\\tself.make_X(dataset)\\n\\t\\t\\tself.shuffle_dataset(dataset)\\n\\n\\t\\tif not \\\"dev\\\" in self.X:\\n\\t\\t\\tself.split_dev()\\t\\t\\n\\t\\tself.make_hybrid()\\n\\t\\tself.store()\",\n \"def prepare_data_for_training(args):\\n # Form the train/test splits and write them to disk\\n dataset = data.Dataset(args)\\n # get image classes and image counts in each class\\n label_map = dataset.get_class_info()\\n class_count = len(list(label_map.values()))\\n # split the data and store it in log dir\\n df_train, df_test = dataset.split_dataset()\\n\\n # perform dataset augmentations\\n image_data = augment.Augmentation(args)\\n # get the data gens for training and test images\\n train_data_gen, _ = image_data.map_fn_train(df_train)\\n test_data_gen, _ = image_data.map_fn_test(df_test)\\n\\n return train_data_gen, test_data_gen, df_train, df_test, class_count\",\n \"def build_data_set(self):\\n if not self.assert_data_correct():\\n self.download_all_data()\\n self.unpack_rename_data()\\n self.split_data_characters()\\n self.clean_data_fragments()\\n self.create_font_data()\\n if not self.assert_train_augmented():\\n self.augment_train_data()\\n if not self.assert_style_data_correct():\\n self.download_style_data()\\n self.unpack_rename_data()\",\n \"def prepare_data(self, *args, **kwargs):\\n # get paths to train and test splits\\n _split_paths = [os.path.join(self.path_to_data, split)\\n for split in os.listdir(self.path_to_data)]\\n\\n # for each split [train, test]\\n for _path in _split_paths:\\n _img_classes = os.listdir(_path) # get subfolders representing each class\\n self.splits[os.path.basename(_path)] = []\\n\\n # get the images in pairs with its corresponding class\\n for _class in _img_classes:\\n _data = self.get_img_text_pair(os.path.join(_path, _class))\\n\\n if os.path.basename(_path) == 'train':\\n self.weights[self.encode_label(_class)] = len(_data)\\n self.splits[os.path.basename(_path)].extend(_data)\",\n \"def _prepare_ml_data(X, y, to_optimize=False):\\n size_test = 1\\n y_test = None\\n if to_optimize:\\n size_test = CONFIG.OPTIMIZE_PARAMS['size'] + 1\\n y_test = y.iloc[-size_test:]\\n X_train = X.iloc[:-size_test]\\n y_train = y.iloc[:-size_test]\\n X_test = X.iloc[-size_test:]\\n return X_train, y_train, X_test, y_test\",\n \"def prepareData(self, *data):\\n arguments = 8\\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\\n self.model, self.annotations, self.args) = tuple(data[:arguments])\\n \\n self.width = self.args.beam_width\\n self.mathType = self.args.mathType\\n self.io_files = {\\n 'input': self.args.intermediate_input_files,\\n 'output': self.args.intermediate_output_files\\n }\\n self.repeat_width = self.args.repeat_width\\n self.cons_count = self.args.cons_count\\n self.posterior_processors = self.args.posterior_processors \\n\\n self.positionGenerator = \\\\\\n list(AlignmentBeamGenerator(self.alignment, self.width))\\n \\n for i in range(len(self.model.states)):\\n self.model.states[i].computeHints(self)\\n\\n return data[arguments:]\",\n \"def prepare_data(self, *args, **kwargs) -> None:\\n if not (self.root / \\\"train\\\").exists():\\n raise ValueError(\\n f\\\"Please download and set ImageNet-1k train data under {self.root}.\\\"\\n )\\n if not (self.root / \\\"val\\\").exists():\\n raise ValueError(\\n f\\\"Please download and set ImageNet-1k val data under {self.root}.\\\"\\n )\",\n \"def prep_data(self):\\n\\n self.fit_tokenizer(texts=self.texts)\\n sequences = self.get_sequences(self.texts)\\n self.text_data = pad_sequences(sequences, maxlen=self.MAX_SEQUENCE_LENGTH)\\n\\n self.labels = to_categorical(np.asarray(self.labels))\\n print('Shape of data tensor:', self.text_data.shape)\\n print('Shape of label tensor:', self.labels.shape)\\n\\n # split the data into a training set and a validation set\\n indices = np.arange(self.text_data.shape[0])\\n np.random.shuffle(indices)\\n self.text_data = self.text_data[indices]\\n self.labels = self.labels[indices]\\n nb_validation_samples = int(self.VALIDATION_SPLIT * self.text_data.shape[0])\\n\\n x_train = self.text_data[:-nb_validation_samples]\\n y_train = self.labels[:-nb_validation_samples]\\n x_val = self.text_data[-nb_validation_samples:]\\n y_val = self.labels[-nb_validation_samples:]\\n\\n return x_train,y_train, x_val, y_val\",\n \"def prepare_data():\\n #data, label = load_ta_data(), load_ta_target()\\n data, label = load_own_data(), load_own_target()\\n tra_x, tst_x = split_samples(data)\\n tra_y, tst_y = split_samples(label)\\n return (tra_x, tst_x, tra_y, tst_y)\",\n \"def prepare_data(self, context_size, model_name):\\n self.context_size = context_size\\n data_x = []\\n data_y = []\\n oob = self.word2idx['OOB']\\n\\n for item in self.docs:\\n data = [oob] * context_size + self.doc2token(item) + [oob] * context_size #padding\\n for i in range(context_size, len(data) - context_size):\\n data_x.append(data[i - context_size: i] + data[i + 1: i + context_size + 1])\\n data_y.append(data[i])\\n \\n if model_name.lower() == 'skipgram':\\n data_x, data_y = data_y, data_x\\n self.data_x = Variable(torch.LongTensor(data_x))\\n self.data_y = Variable(torch.LongTensor(data_y))\\n logging.info(f'data preprocessed, data shape: {self.data_x.shape}, {self.data_y.shape}')\",\n \"def preprocess():\\n # Load the data\\n random.seed(77)\\n X,y = make_classification(n_samples=500, n_features=30, n_informative=8, n_redundant=2, \\n n_repeated=0, n_classes=3, n_clusters_per_class=2, weights=None, \\n flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, \\n shuffle=True, random_state=None)\\n\\n x_train, x_val, y_train, y_val = train_test_split(X, y, random_state=0, test_size=0.25)\\n\\n # Standardize the data\\n scaler = StandardScaler()\\n X_train = scaler.fit_transform(x_train)\\n X_val = scaler.transform(x_val)\\n\\n \\n return X_train,y_train,X_val,y_val\",\n \"def set_data():\\r\\n #if not os.path.exists(filepath):\\r\\n #download_data()\\r\\n metadata = read(filepath + flist[-1])\\r\\n ndata = metadata['num_cases_per_batch']\\r\\n ndim = metadata['num_vis']\\r\\n\\r\\n data, train, test = {}, {}, {}\\r\\n data['labels'] = metadata['label_names']\\r\\n data['ntraindata'] = metadata['num_cases_per_batch'] * (len(flist) - 2)\\r\\n data['ntestdata'] = metadata['num_cases_per_batch']\\r\\n data['ndim'] = metadata['num_vis']\\r\\n\\r\\n train['x'], train['y'] = convert_train(data['ntraindata'], data['ndim'])\\r\\n\\r\\n testdata = read(filepath + flist[-2])\\r\\n test['x'] = testdata['data']\\r\\n test['y'] = testdata['labels']\\r\\n\\r\\n data['train'], data['test'] = train, test\\r\\n save_pkl(data)\",\n \"def prepare_data(args):\\n logger.info('Loading dataframe from %s' % args.newspath)\\n df = pd.read_csv(args.newspath, encoding='gb18030')\\n logger.info('Dataframe size: %d observations %d features after loaded' % (df.shape[0], df.shape[1]))\\n\\n # exclude rows with column source == NaN\\n logger.info('Data cleansing...')\\n df = df[~pd.isna(df['source'])]\\n logger.info('Dataframe size: %d observations %d features after data cleansing' % (df.shape[0], df.shape[1]))\\n\\n # split the dataframe into training set and test set\\n logger.info('Making training set & test set...')\\n train_set, test_set = split_data(df)\\n logger.info('Traning set size: %d' % train_set.shape[0])\\n logger.info('Test set size: %d' % test_set.shape[0])\\n\\n # save the train set and test set to picke files\\n logger.info('Save dataframes to files...')\\n train_set.to_pickle(args.trainpath)\\n test_set.to_pickle(args.testpath)\",\n \"def data_prep(data, y, dropna=False):\\n\\n rand_state = 10 # Setting random state for later cv\\n df = pd.read_pickle(data) # Reading in data\\n if dropna is True:\\n df.dropna(axis=0, inplace = True)\\n else:\\n pass\\n X = df.drop(y, axis=1) # Assigning the feature space to X\\n y = df[y] # Class labels to predict\\n\\n return X, y, rand_state\",\n \"def prepareData(mdl, X_train, X_val, X_test, Y_train, Y_val, Y_test):\\n\\t\\n\\tX2_train = []\\n\\n\\tX2_val = []\\n\\n\\tX2_test = []\\n\\n\\n\\tYPs = mdl.predict(X_train)\\n\\n\\tfor i in tqdm(range(len(X_train))):\\n\\n\\t\\tX2_train.append(np.array(YPs[i]))\\n\\n\\n\\n\\tYPs = mdl.predict(X_val)\\n\\n\\tfor i in tqdm(range(len(X_val))):\\n\\n\\t\\tX2_val.append(np.array(YPs[i]))\\n\\n\\n\\n\\tYPs = mdl.predict(X_test)\\n\\n\\tfor i in tqdm(range(len(X_test))):\\n\\n\\t\\tX2_test.append(np.array(YPs[i]))\\n\\n\\n\\tX2_train = np.array(X2_train)\\n\\n\\tX2_val = np.array(X2_val)\\n\\n\\tX2_test = np.array(X2_test)\\n\\n\\treturn (X2_train, X2_val, X2_test)\",\n \"def prepare(self):\\n bcolz.set_nthreads(2)\\n\\n # step 0: load only when not loaded yet\\n if TRAINING in self.data and VALIDATION in self.data: return\\n\\n # step 1: load the file names\\n patients = sorted(glob.glob(self.location+'/*.*/'))\\n print len(patients), \\\"patients\\\"\\n\\n # step 1: load the file names\\n # make a stratified validation set\\n # note, the seed decides the validation set, but it is deterministic in the names\\n random.seed(317070)\\n patient_names = [self.patient_name_from_file_name(f) for f in patients]\\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\\n\\n labels_as_dict = defaultdict(list)\\n\\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\\n next(reader) # skip the header\\n for row in reader:\\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\\n labels_as_dict[str(row[0])].append(label)\\n\\n # make the static data empty\\n for s in self.datasets:\\n self.data[s] = []\\n self.labels[s] = []\\n self.names[s] = []\\n self.spacings[s] = []\\n self.origins[s] = []\\n\\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'spacings.pkl.gz') as f:\\n spacings = cPickle.load(f)\\n\\n with gzip.open(paths.INTERMEDIATE_DATA_PATH + 'origins.pkl.gz') as f:\\n origins = cPickle.load(f)\\n\\n # load the filenames and put into the right dataset\\n for i, patient_folder in enumerate(patients):\\n patient_id = str(patient_folder.split(path.sep)[-2])\\n if patient_id in validation_patients:\\n dataset = VALIDATION\\n else:\\n dataset = TRAIN\\n\\n\\n label = labels_as_dict[patient_id]\\n if self.only_positive and not label:\\n continue\\n\\n self.data[dataset].append(patient_folder)\\n self.labels[dataset].append(label)\\n self.names[dataset].append(patient_id)\\n self.spacings[dataset].append(spacings[patient_id])\\n self.origins[dataset].append(origins[patient_id])\\n\\n # give every patient a unique number\\n last_index = -1\\n for set in self.datasets:\\n self.indices[set] = range(last_index+1,last_index+1+len(self.data[set]))\\n if len(self.indices[set]) > 0:\\n last_index = self.indices[set][-1]\\n print set, len(self.indices[set]), \\\"samples\\\"\",\n \"def data_preprocessing():\\n lineid_content = get_lineid_content()\\n print('Read movie_lines.txt file complete...')\\n convos = get_convos()\\n print('Read movie_conversations.txt file complete...')\\n print('Building dataset')\\n get_data(lineid_content, convos)\",\n \"def _prepare_models(self):\\n if self.freeze_layers is not None:\\n self._set_freeze_layers()\\n self._load_weight_if_possible()\\n print(self.keras_model.summary())\\n self.show_configuration()\",\n \"def preprocess_valid_data(self):\\r\\n print(\\\"* Preprocessing validation data.\\\", flush=True)\\r\\n prep.create_HDF_file(self.C.validation_set)\\r\\n\\r\\n self.print_time_elapsed()\",\n \"def prepare_data(self, config: TreeConfigParser) -> None:\\n self.data = Data(config)\\n self.data.prepare_input()\\n self.data.prepare_output()\",\n \"def setup():\\n # change working directory to\\n os.chdir(ROOT_DIR)\\n # move to dataFiles\\n with misc.cd('dataFiles'):\\n print('Now in:', os.getcwd())\\n # Load in data\\n model_test = models.MlModel('rf', 'water-energy.csv', 'expt')\\n # Get feature. I use rdkit2d as it is fast to generate\\n df, num_feat, feat_time = features.featurize(model_test.data, model_test.algorithm, [0])\\n # Split the data\\n train_features, test_features, train_target, test_target, feature_list = features.targets_features(df, 'expt')\\n return train_features, test_features, train_target, test_target\",\n \"def pre_process(self, dataset):\\n\\n # np.empty creates an empty array only. You have to replace this with your code.\\n X = np.empty((0,0))\\n y = np.empty((0))\\n\\n if dataset == 0:\\n # Implement for the abalone dataset\\n df = pd.DataFrame(columns=['sex', 'length', 'diameter', 'height', 'whole_weight', 'shucked_weight', 'viscera_weight', 'shell_weight', 'rings'])\\n count = 0\\n\\n with open('Dataset.data') as file: # reading data from file\\n data = file.read()\\n\\n data = data.split('\\\\n') # split data into different rows\\n data = data[:-1] # last one is empty\\n for row in data:\\n row = row.split()\\n df.loc[count] = row # add in dataframe\\n count += 1\\n\\n df['M'] = np.where(df.sex=='M', 1,0) # genders are turned to a one hot encoding\\n df['F'] = np.where(df.sex=='F', 1,0)\\n df['I'] = np.where(df.sex=='I', 1,0)\\n df = df.drop(['sex'], axis=1)\\n df = df.dropna()\\n\\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataframe\\n\\n X = df.drop(['rings'], axis=1)\\n X = X.values\\n X = X.astype(float)\\n y = df['rings'].values\\n y = y.astype(float)\\n\\n elif dataset == 1:\\n # Implement for the video game dataset\\n df = pd.read_csv('VideoGameDataset - Video_Games_Sales_as_at_22_Dec_2016.csv') # read csv directly into a dataframe\\n df1 = df[['Critic_Score', 'User_Score', 'Global_Sales']]\\n df1 = df1.dropna()\\n df1 = df1[df1.User_Score != 'tbd']\\n\\n df1 = df1.sample(frac=1).reset_index(drop=True) # shuffle rows\\n\\n X = df1.drop(['Global_Sales'], axis=1)\\n X = X.values\\n X = X.astype(float)\\n y = df1['Global_Sales'].values\\n y = y.astype(float)\\n\\n elif dataset == 2:\\n # Implement for the banknote authentication dataset\\n df = pd.DataFrame(columns=['variance', 'skewness', 'curtosis', 'entropy', 'class'])\\n count = 0\\n\\n with open('data_banknote_authentication.txt') as file: # reading file \\n data = file.read()\\n data = data.split('\\\\n')\\n data = data[:-1]\\n for row in data:\\n row = row.split(',')\\n df.loc[count] = [float(elt) for elt in row[:-1]] + [int(row[-1])] # last column has class so it is int rest are float\\n count += 1\\n\\n df = df.sample(frac=1).reset_index(drop=True) # shuffle dataset\\n\\n X = df.drop(['class'], axis=1)\\n X = X.values\\n y = df['class'].values\\n y = y.astype(int)\\n\\n return X, y\",\n \"def pre_process_data(self, all_labels, all_data):\\n\\n # [1] Normalizes data\\n all_data = self.pre_precess_manager.normalization(all_data)\\n\\n data_train, data_test, label_train, label_test = train_test_split(all_data, all_labels, test_size=0.1,\\n shuffle=True)\\n\\n return data_train, data_test, label_train, label_test\",\n \"def _preprocess(self):\\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\\n # self._get_frequent_features()\\n # self._compactness_pruning()\\n # self._redundancy_pruning()\\n # self._get_features()\\n self._extract_opinions()\",\n \"def prepare_data(self):\\n import subprocess\\n # Download coco data set into dir specified by config then /data/coco\\n subprocess.call([f\\\"{get_original_cwd()}/bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\", f\\\"{get_original_cwd()}\\\"])\\n # subprocess.call([f\\\"bin/fetch_dataset.sh\\\", f\\\"{self.dir}/data/coco\\\"])\\n task = \\\"instances\\\" if self.instance else \\\"person_keypoints\\\"\\n register_coco_instances(\\\"train\\\", {}, f\\\"{self.dir}/data/coco/{task}_train2014.json\\\",\\n f\\\"{self.dir}/data/coco/train2014\\\")\\n register_coco_instances(\\\"val\\\", {}, f\\\"{self.dir}/data/coco/{task}_minival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\\n register_coco_instances(\\\"test\\\", {}, f\\\"{self.dir}/data/coco/{task}_valminusminival2014.json\\\",\\n f\\\"{self.dir}/data/coco/val2014\\\")\",\n \"def prepareData(self):\\n\\t\\tprint ('')\\n\\t\\tfrom keras.preprocessing.sequence import pad_sequences\\n\\t\\tfrom sklearn.model_selection import train_test_split\\n\\t\\tfrom keras.utils import to_categorical\\n\\t\\timport numpy as np\\n\\n\\t\\tfrom sklearn.preprocessing import LabelBinarizer, LabelEncoder\\n\\n\\t\\tX_snt = [[self.word2idx[w] if w in self.word2idx else self.word2idx[self.word_unk_token] for w in s] for s in self.x_document]\\n\\t\\ty_tag = [[self.tag2idx[t]] for t in self.y_document]\\n\\n\\t\\tX_snt = pad_sequences(maxlen=self.parameters['max_doc_len'], sequences=X_snt, padding='post', value=self.word2idx[self.word_pad_token])\\n\\t\\ty_tag = to_categorical(y_tag, self.tags_len)\\n\\n\\t\\tprint (\\\"\\\\tRandom:\\\\t\\\", self.random)\\n\\t\\tprint (\\\"\\\\tTest size:\\\\t\\\", self.split_train_test)\\n\\n\\t\\tself.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X_snt, y_tag, test_size=self.split_train_test, random_state=self.random)\\n\\n\\t\\tself.X_train = np.array(self.X_train)\\n\\t\\tself.X_test = np.array(self.X_test)\\n\\t\\tself.y_train = np.array(self.y_train)\\n\\t\\tself.y_test = np.array(self.y_test)\\n\\n\\t\\tprint ('\\\\n\\\\tWords: {}\\\\t{}'.format(self.X_train.shape, self.X_test.shape) )\\n\\t\\tprint ('\\\\tTags: {}\\\\t{}\\\\n'.format(self.y_train.shape, self.y_test.shape))\",\n \"def _make_data(self):\\n pdf_datasets_all = make_pdf_datasets(self.pdf_list, self.xlims, self.ylims, self.tlims, self.dims, 9)\\n self.pdf_dataset = np.concatenate(pdf_datasets_all, axis = 0)\\n self.PDE_dataset = make_PDE_dataset(self.num_collocation, self.xlims, self.ylims, self.tlims, self.dims)\\n self.BC_dataset = make_BC_dataset(self.num_BC, self.xlims, self.ylims, self.tlims, self.dims)\",\n \"def preproc_pipeline(data):\\n # Preprocess\\n data = preprocess(data)\\n\\n # Optional --> run a technical analysis on it and add more features\\n data = generate_ta(data)\\n \\n # Split\\n train_set, validation_set, test_set = train_val_test_split(data)\\n \\n # Set up for Keras\\n train_set = shape_for_keras(train_set)\\n validation_set = shape_for_keras(validation_set)\\n test_set = shape_for_keras(test_set)\\n\\n # We could save this to csv.\\n return train_set, validation_set, test_set\",\n \"def __loadPreProcessedData(self):\\n le = joblib.load(self.le_filename)\\n X = np.loadtxt(self.X_filename, delimiter=',').astype(int)\\n raw_y = np.loadtxt(self.y_filename, delimiter=',').astype(int)\\n y = le.inverse_transform(raw_y)\\n ##Initialize atrtribute for this class\\n self.le, self.X, self.y = le, X, y\",\n \"def preprocess(self):\\n \\n file_name_list = os.listdir(self.image_dir)\\n random.seed(1234)\\n random.shuffle(file_name_list)\\n \\n for i,d in enumerate(self.domains):\\n self.attr2idx[d]=i \\n\\n for i, file_name in enumerate(file_name_list):\\n if (file_name.startswith('X_')):\\n continue\\n \\n parts = file_name.split(\\\"-\\\")\\n label = int(parts[0])\\n if label not in self.domains:\\n continue\\n img_name = file_name\\n\\n count=self.get_sample_count(label)\\n if count<self.valid_set_size:\\n # create holdout set on the fly\\n utils.copy_file(self.image_dir,self.valid_set_dir,img_name)\\n else:\\n self.dataset.append([img_name, self.attr2idx[label]])\\n \\n self.increment_sample_count(label)\\n\\n print(\\\"Sample count per domain: \\\"+str(self.sample_count)+\\\" (including holdout set, holdout size per domain is: \\\"+str(self.valid_set_size)+\\\")\\\")\\n print('Finished preprocessing the dataset...')\",\n \"def initialisation(self):\\n self.create_variables()\\n self.create_placeholders()\\n self.build_model()\\n self.reset_lr(None, True)\\n self.build_loss()\\n self.initialised = True\",\n \"def preprocess(self):\\n lines = [line.rstrip() for line in open(self.attr_path, 'r')]\\n all_attr_names = lines[1].split()\\n for i, attr_name in enumerate(all_attr_names):\\n self.attr2idx[attr_name] = i\\n self.idx2attr[i] = attr_name\\n\\n lines = lines[2:]\\n random.seed(1234)\\n random.shuffle(lines)\\n for i, line in enumerate(lines):\\n split = line.split()\\n filename = split[0]\\n values = split[1:]\\n\\n label = []\\n for attr_name in self.selected_attrs:\\n idx = self.attr2idx[attr_name]\\n label.append(values[idx] == '1')\\n\\n if (i+1) < 4:\\n self.test_dataset.append([filename, label])\\n else:\\n self.train_dataset.append([filename, label])\",\n \"def _preprocess_training_model(self, data):\\n def _pre_process(raw_data):\\n \\\"\\\"\\\" Pre-process raw data. \\\"\\\"\\\"\\n pattern = re.compile(\\n r\\\"((?<=')\\\\w\\\\d.*?(?=')|(?<=\\\\\\\")\\\\w\\\\d.*?(?=\\\\\\\")|[\\\\w\\\\d]+)\\\")\\n words = re.findall(pattern, raw_data)\\n return ' '.join(list(map(string_utils.snake_case_to_camel, words)))\\n\\n data_list = []\\n # Preprocess the dataset with naming convention, etc.\\n with Progress() as progress:\\n preprocess_task = progress.add_task('Pre-processing dataset...',\\n total=data.shape[0])\\n for idx, row in data.iterrows():\\n row_data = {}\\n for column in ['text', 'key', 'value']:\\n row_data[column] = _pre_process(row[column])\\n data_list.append(row_data)\\n progress.update(preprocess_task, advance=1)\\n return pd.DataFrame(data=data_list)\",\n \"def _load_data(self):\\n self.mapper = Mapper()\\n self.mapper.generate_vocabulary(self.review_summary_file)\\n self.X_fwd, self.X_bwd, self.Y = self.mapper.get_tensor(reverseflag=True)\\n # Store all the mapper values in a dict for later recovery\\n self.mapper_dict = dict()\\n self.mapper_dict['seq_length'] = self.mapper.get_seq_length()\\n self.mapper_dict['vocab_size'] = self.mapper.get_vocabulary_size()\\n self.mapper_dict['rev_map'] = self.mapper.get_reverse_map()\\n # Split into test and train data\\n self._split_train_tst()\",\n \"def _prepare_model(model):\\n\\n # Ensure there is at least 1 load combination to solve if the user didn't define any\\n if model.LoadCombos == {}:\\n # Create and add a default load combination to the dictionary of load combinations\\n model.LoadCombos['Combo 1'] = LoadCombo('Combo 1', factors={'Case 1':1.0})\\n \\n # Generate all meshes\\n for mesh in model.Meshes.values():\\n if mesh.is_generated == False:\\n mesh.generate()\\n\\n # Activate all springs and members for all load combinations\\n for spring in model.Springs.values():\\n for combo_name in model.LoadCombos.keys():\\n spring.active[combo_name] = True\\n \\n # Activate all physical members for all load combinations\\n for phys_member in model.Members.values():\\n for combo_name in model.LoadCombos.keys():\\n phys_member.active[combo_name] = True\\n \\n # Assign an internal ID to all nodes and elements in the model. This number is different from the name used by the user to identify nodes and elements.\\n _renumber(model)\",\n \"def prepare_estimation(model_params_init_file_name, lower, upper):\\n\\n # Read in data and init file sources\\n model_params_df = pd.read_pickle(model_params_init_file_name)\\n model_params_df[\\\"lower\\\"] = lower\\n model_params_df[\\\"upper\\\"] = upper\\n\\n return model_params_df\",\n \"def _load_training_data(self):\\n self._save_training_data()\",\n \"def setup(self):\\n # TODO check if need both dataset together\\n self.train_dataset = ABSADataset(data_path=self.train_path, mode=self.in_mode, task=self.task, \\n tokenizer=self.tokenizer, vocab=\\\"bert\\\")\\n self.vocabulary = self.train_dataset.vocabulary\\n\\n self.eval_dataset = ABSADataset(data_path=self.dev_path, mode=self.in_mode, task=self.task,\\n tokenizer=self.tokenizer, vocab=self.vocabulary)\\n #self.train_restaurant = ABSADataset(data_path=RESTAURANT_TRAIN)\\n #self.eval_restaurant = ABSADataset(data_path=RESTAURANT_DEV)\",\n \"def prepare(self):\\n\\n inp = self.config.get('predict.input', 'X:0')\\n out = self.config.get('predict.output', 'output:0')\\n\\n # set input placeholder\\n self.input = self.graph.get_tensor_by_name(inp)\\n\\n # set output operation\\n if isinstance(out, str) or isinstance(out, unicode):\\n self.output = {out: self.graph.get_tensor_by_name(out)}\\n self.output_alone = True\\n elif isinstance(out, list):\\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\\n self.output_alone = False\\n else:\\n raise LoaderException('incorrect predict.output type')\",\n \"def produce_init(filename):\\n training_dataset = pd.read_csv(f'../Modified Data/{filename}')\\n test_dataset = pd.read_csv(f'../Raw Data/test.csv')\\n features = list(training_dataset.columns)\\n features.remove('SalePrice')\\n predict_feature = ['SalePrice']\\n\\n # Produce Test Data\\n test_X = test_dataset.loc[:, features]\\n ids_test = test_dataset.loc[:, 'Id']\\n\\n for column in features:\\n if str(training_dataset.loc[:, column].dtype) == 'object':\\n # Initialize encoder\\n labelencoder = LabelEncoder()\\n # Encode Train Data\\n training_dataset.loc[:, column] = training_dataset.loc[:, column].fillna('Missing')\\n training_dataset.loc[:, column] = pd.Series(labelencoder.fit_transform(training_dataset.loc[:, column]))\\n # Encode Test Data\\n test_X.loc[:, column] = test_X.loc[:, column].fillna('Missing')\\n test_X.loc[:, column] = pd.Series(labelencoder.fit_transform(test_X.loc[:, column]))\\n else:\\n # Fix missing values for train data\\n training_dataset.loc[:, column] = training_dataset.loc[:, column].fillna(int(training_dataset.loc[:, column].mean()))\\n # Fix missing values for test data\\n test_X.loc[:, column] = test_X.loc[:, column].fillna(int(test_X.loc[:, column].mean()))\\n\\n return training_dataset, test_X, ids_test\",\n \"def init_data(in_arg, model_param, phase=\\\"train\\\"): \\n # Firstly, set the directories\\n # PRE-REQUISITES: \\n # train & valid sets (1 per folder) must exist within the in_arg.data_dir (to improve if I have some time later on)\\n # train folder must be \\\"train\\\", validation folwer must be \\\"valid\\\"\\n # each file must be correctly classified (=within the correct id folder). file name doesn't matter\\n model_param['data_dir'] = in_arg.data_dir\\n train_dir = model_param['data_dir'] + '/train'\\n valid_dir = model_param['data_dir'] + '/valid'\\n\\n model_param['save_dir'] = in_arg.save_dir\\n \\n # Prepare the transformations for train & validation sets\\n train_transforms = transforms.Compose([transforms.RandomRotation(30),\\n transforms.RandomResizedCrop(224),\\n transforms.RandomHorizontalFlip(),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\\n\\n valid_transforms = transforms.Compose([transforms.Resize(256),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\\n\\n try:\\n # Load the datasets with ImageFolder\\n train_dataset = datasets.ImageFolder(train_dir, transform=train_transforms)\\n valid_dataset = datasets.ImageFolder(valid_dir, transform=valid_transforms)\\n\\n model_param['class_to_idx'] = train_dataset.class_to_idx\\n \\n # TODO: Using the image datasets and the trainforms, define the dataloaders\\n train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=in_arg.batch_size, shuffle = True)\\n valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=in_arg.batch_size, shuffle = True)\\n\\n # Initialize the cat_to_name catalog\\n #with open(in_arg.cat_to_name, 'r') as f:\\n #cat_to_name = json.load(f)\\n # model_param['cat_to_name'] = json.load(f)\\n\\n except Exception as e:\\n print(\\\"An exception occured: {}.\\\".format(e))\\n sys.exit(0)\\n\\n print(\\\"Data loading completed!\\\")\\n\\n # Return all parameters we will need later on\\n return train_loader, valid_loader, model_param\",\n \"def preprocess_test_data(self):\\r\\n print(\\\"* Preprocessing test data.\\\", flush=True)\\r\\n prep.create_HDF_file(self.C.test_set)\\r\\n\\r\\n self.print_time_elapsed()\",\n \"def prepare_learning(self):\\n print 'Separating inputs and outputs...'\\n self.inputs, self.outputs = extract_samples(self.matches,\\n self.input_features,\\n self.output_feature)\\n\\n print 'Normalizing data...'\\n self.normalizer, self.inputs = normalize(self.inputs)\\n\\n print 'Separating train and test sets...'\\n self.train_inputs, self.train_outputs, self.test_inputs, self.test_outputs = split_samples(self.inputs, self.outputs)\\n\\n print 'Building neural network...'\\n self.network = buildNetwork(len(self.input_features),\\n 2 * len(self.input_features),\\n 1,\\n outclass=SigmoidLayer,\\n bias=True)\\n\\n print 'Building and filling pybrain train set object...'\\n self.train_set = ClassificationDataSet(len(self.input_features))\\n\\n for i, input_line in enumerate(self.train_inputs):\\n self.train_set.addSample(self.train_inputs[i],\\n [self.train_outputs[i] - 1])\\n\\n self.trainer = BackpropTrainer(self.network, dataset=self.train_set,\\n momentum=0.5, weightdecay=0.0)\\n\\n self.train_set.assignClasses()\",\n \"def pre_process_data():\\n data_list, header_list = Parser.__parse_csv_data(Parser.training_data_file)\\n table = pandas.DataFrame(data_list, columns=header_list)\\n table.drop(['date', 'employee id'], axis=1, inplace=True)\\n unique_categories = table['category'].unique()\\n unique_expense_desc = table['expense description'].unique()\\n unique_tax_name = table['tax name'].unique()\\n\\n column_index = {\\n 'input': {},\\n 'output': {}\\n }\\n\\n column_index['input']['pre-tax amount'] = {\\n 'column_index': 0,\\n 'type': 'int'\\n }\\n\\n column_index['input']['tax amount'] = {\\n 'column_index': 1,\\n 'type': 'int'\\n }\\n\\n index = 2\\n\\n for i in range(len(unique_expense_desc)):\\n column_index['input'][unique_expense_desc[i]] = {\\n 'column_index': i + index,\\n 'type': 'str'\\n }\\n\\n index += len(unique_expense_desc)\\n\\n for i in range(len(unique_tax_name)):\\n column_index['input'][unique_tax_name[i]] = {\\n 'column_index': i + index,\\n 'type': 'str'\\n }\\n\\n for i in range(len(unique_categories)):\\n column_index['output'][unique_categories[i]] = {'value': i}\\n\\n Parser.__save_column_index(column_index)\",\n \"def prepare_for_predict(self) -> None:\\n _, self.all_labels_embed = self._create_all_labels_embed()\",\n \"def prep_input_data(parameter_df):\\n # Make sure the shape is 3D\\n # assert len(x_shape) == 3, \\\"Input shape should be 3D\\\"\\n\\n # Create an empty list in which to store objects\\n n_mods = len(parameter_df)\\n mods_for_default = [None for _ in range(n_mods)]\\n hyperopt_args = [None for _ in range(n_mods)]\\n model_params = [None for _ in range(n_mods)]\\n for i, (_, row) in enumerate(parameter_df.iterrows()):\\n\\n # Pull info needed to instantiate model\\n major_model = row[\\\"ModelClass\\\"]\\n specific_model = row[\\\"SpecificModel\\\"]\\n\\n # Define the model and training parameters\\n model_params[i] = DEFAULT_MODEL_PARAMS[major_model][specific_model].copy()\\n\\n # Instantiate a model with default parameters\\n mods_for_default[i] = MldeModel(major_model, specific_model,\\n model_params=model_params[i],\\n training_params=DEFAULT_TRAINING_PARAMS[major_model],\\n eval_metric=mse)\\n\\n # Package args for hyperopt\\n hyperopt_args[i] = (major_model, specific_model, row[\\\"NHyperopt\\\"])\\n\\n # Return the instantiated models and the hyperopt args\\n return mods_for_default, hyperopt_args,model_params\",\n \"def prepare_training_data(collection_of_positive_segments, collection_of_negative_segments):\\n\\n\\n\\tprint \\\"Preparing training data...\\\"\\n\\n\\ttraining_vectors = []\\n\\ttraining_labels = []\\n\\n\\n\\tfor segment in collection_of_positive_segments.list_of_segments:\\n\\t\\tvector = get_segment_feature_vector(segment)\\n\\n\\t\\ttraining_labels.append(\\\"Correct\\\")\\n\\t\\ttraining_vectors.append(vector)\\n\\t\\t\\n\\t\\t\\n\\tfor segment in collection_of_negative_segments.list_of_segments:\\n\\t\\tvector = get_segment_feature_vector(segment)\\n\\t\\ttraining_labels.append(\\\"Incorrect\\\")\\n\\t\\ttraining_vectors.append(vector)\\n\\t\\t\\n\\t\\n\\ttraining_vectors = normalize_train_data(training_vectors)\\n\\t\\n\\t\\t\\n\\t#data = VectorDataSet(training_vectors,L=training_labels)\",\n \"def preprocess(self, train_file, validation_file, test_file):\\n chardict, labeldict = self.make_dictionary(train_file, validation_file, test_file)\\n print 'preparing training data'\\n training = self.parse_file(train_file, chardict, labeldict)\\n \\n print 'preparing validation data'\\n validation = self.parse_file(validation_file, chardict, labeldict)\\n\\n print 'preparing test data'\\n test = self.parse_file(test_file, chardict, labeldict)\\n\\n return Data(training, validation, test, chardict, labeldict)\",\n \"def load_cleaned_data(self):\\n try:\\n self.train = pd.read_pickle('../input/train_clean.pkl')\\n self.test = pd.read_pickle('../input/test_clean.pkl')\\n except FileNotFoundError:\\n self.load_raw_data()\",\n \"def setup(self, stage=None):\\n self.data_train, self.data_val, self.data_test = [None] * 3\",\n \"def generatePredictorDataTemplate(self):\\n self.__pdir = Predictor.directory\\n self.__predictorData = PredictorData(None)\\n self.save()\",\n \"def load_data_preprocess(self):\\n\\n print(\\\"Loading the dataset ...\\\")\\n # load the data\\n c_util = CarUtils()\\n train_x, train_y, test_x, test_y, classes = c_util.load_data()\\n\\n # set the image ordering\\n K.set_image_dim_ordering(\\\"th\\\")\\n\\n print(\\\"Pre-processing the dataset ...\\\")\\n # pre-process the data\\n train_x = train_x.astype('float32')\\n test_x = test_x.astype('float32')\\n\\n train_x = train_x / 255\\n test_x = test_x / 255\\n\\n print(train_x.shape[0], ' train samples')\\n print(test_x.shape[0], ' test samples')\\n\\n train_y = np_utils.to_categorical(train_y, CarsClassifierModel._nb_classes)\\n test_y = np_utils.to_categorical(test_y, CarsClassifierModel._nb_classes)\\n\\n return train_x, train_y, test_x, test_y\",\n \"def prepare_model(self, **kwargs):\\n pass\",\n \"def build_model():\",\n \"def prepare_data(dataset, train_ratio=0.8, input_dim=None, seed=10):\\n # Retrieve main path of project\\n dirname = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))\\n\\n # Download and store dataset at chosen location\\n if dataset == 'Cora' or dataset == 'PubMed' or dataset == 'Citeseer':\\n path = os.path.join(dirname, 'data')\\n data = Planetoid(path, name=dataset, split='full')[0]\\n data.name = dataset\\n data.num_classes = (max(data.y)+1).item()\\n # data.train_mask, data.val_mask, data.test_mask = split_function(data.y.numpy())\\n # data = Planetoid(path, name=dataset, split='public', transform=T.NormalizeFeatures(), num_train_per_class=20, num_val=500, num_test=1000)\\n\\n elif dataset == 'Amazon':\\n path = os.path.join(dirname, 'data', 'Amazon')\\n data = Amazon(path, 'photo')[0]\\n data.name = dataset\\n data.num_classes = (max(data.y)+1).item()\\n data.train_mask, data.val_mask, data.test_mask = split_function(\\n data.y.numpy(), seed=seed)\\n # Amazon: 4896 train, 1224 val, 1530 test\\n \\n elif dataset in ['syn1', 'syn2', 'syn4', 'syn5']: \\n data = synthetic_data(\\n dataset, dirname, train_ratio, input_dim)\\n \\n elif dataset == 'syn6':\\n data = gc_data(dataset, dirname, train_ratio)\\n\\n elif dataset == 'Mutagenicity':\\n data = gc_data(dataset, dirname, train_ratio)\\n\\n return data\",\n \"def prepare_data():\\n if FLAGS.word_embeddings:\\n # Get the dialogue data manually.\\n vocab_dir = os.path.join(FLAGS.data_dir, \\\"word2vec\\\")\\n train_ids = os.path.join(vocab_dir, \\\"train_ids%d\\\" % FLAGS.vocab_size)\\n test_ids = os.path.join(vocab_dir, \\\"test_ids%d\\\" % FLAGS.vocab_size)\\n train_data = data_utils.read_data(train_ids, buckets, FLAGS.max_read_train_data,\\n FLAGS.start_read_train_data)\\n test_data = data_utils.read_data(test_ids, buckets, FLAGS.max_read_test_data,\\n FLAGS.start_read_test_data)\\n embeddings_file = os.path.join(vocab_dir, \\\"vocab%d_embeddings\\\" % FLAGS.vocab_size)\\n else:\\n # Get dialogue data using the functions in data_utils.py\\n print(\\\"Preparing dialogue data in %s\\\" % FLAGS.data_dir)\\n train_data, test_data = data_utils.prepare_dialogue_data(\\n FLAGS.words, FLAGS.data_dir, FLAGS.vocab_size, buckets,\\n FLAGS.max_read_train_data, FLAGS.max_read_test_data,\\n FLAGS.start_read_train_data, FLAGS.start_read_test_data,\\n read_again=FLAGS.read_again, save=FLAGS.save_pickles)\\n embeddings_file = None\\n return train_data, test_data, embeddings_file\",\n \"def main():\\n df = prepro_last()\\n X, y = train_build(df)\\n fit_store(X, y)\",\n \"def initSets(self):\\n data_frame = pd.read_csv(self.train_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n if self.test_file is None:\\n self.train_feat, self.test_feat, self.train_labl, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n else:\\n data_frame = pd.read_csv(self.test_file, header=None)\\n data_frame = data_frame.drop(columns=self.drop_cols)\\n self.train_feat, _, self.train_labl, _ = train_test_split(features, labels, test_size=self.test_size)\\n features = data_frame.iloc[:, :-1].values\\n labels = data_frame.iloc[:, -1].values\\n _, self.test_feat, _, self.test_labl = train_test_split(features, labels, test_size=self.test_size)\\n # kfold = KFold(n_splits=3)\\n # self.train_index, self.test_index = kfold.split(features,labels)\",\n \"def pre_train(self, dataset, **kwargs):\\n\\n pass\",\n \"def _prepare_for_training(\\n self,\\n trackers: List[TrackerWithCachedStates],\\n domain: Domain,\\n precomputations: MessageContainerForCoreFeaturization,\\n **kwargs: Any,\\n ) -> Tuple[RasaModelData, np.ndarray]:\\n training_trackers = self._get_trackers_for_training(trackers)\\n # dealing with training data\\n tracker_state_features, label_ids, entity_tags = self._featurize_for_training(\\n training_trackers,\\n domain,\\n precomputations=precomputations,\\n bilou_tagging=self.config[BILOU_FLAG],\\n **kwargs,\\n )\\n\\n if not tracker_state_features:\\n return RasaModelData(), label_ids\\n\\n self._label_data, encoded_all_labels = self._create_label_data(\\n domain, precomputations=precomputations\\n )\\n\\n # extract actual training data to feed to model\\n model_data = self._create_model_data(\\n tracker_state_features, label_ids, entity_tags, encoded_all_labels\\n )\\n\\n if self.config[ENTITY_RECOGNITION]:\\n self._entity_tag_specs = (\\n self.featurizer.state_featurizer.entity_tag_specs\\n if self.featurizer.state_featurizer is not None\\n else []\\n )\\n\\n # keep one example for persisting and loading\\n self.data_example = model_data.first_data_example()\\n\\n return model_data, label_ids\",\n \"def prepare_data(vocabulary_size):\\n print(\\\"Downloading data from \\\" + _DATA_DIR_ +\\\"..\\\")\\n getData(_DATA_DIR_)\\n print(\\\"Creating Vocabulary..\\\")\\n create_vocabulary( _VOCAB_DIR_, _RAW_SENTENCES_DIR_, vocabulary_size )\\n print(\\\"Converting sentences to sequences of ids..\\\")\\n data_to_token_ids( _RAW_SENTENCES_DIR_ , _SENTENCES_DIR, _VOCAB_DIR_ )\",\n \"def launch(self, force_prep=False):\\n #TODO process upploaded csv\\n assert self.ready()\\n self.launch_progress = 0\\n self.set_status(\\\"Gathering data\\\")\\n if 'O' not in set(self.labels.dict.values()):\\n self.add_labels({max(list(self.labels.dict.keys()))+1:'O'})\\n\\n processed_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.csv')\\n bert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.bert')\\n elmo_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.elmo')\\n nlp_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.nlp')\\n sbert_file_path = os.path.join(DATASETS_PATH, self.dataset_uuid, 'processed.sbert')\\n if os.path.exists(processed_file_path) and not force_prep:\\n df = pd.read_csv(processed_file_path)\\n if 'span_label' in df.columns:\\n df['span_label']=df['span_label'].apply(eval)\\n # Let's say loading the file is ~half the launch time\\n # (if the file already exists)\\n self.total = 2\\n self.update(1)\\n else:\\n datafiles = [os.path.join(DATASETS_PATH, self.dataset_uuid, d) \\\\\\n for d in os.listdir(os.path.join(DATASETS_PATH, self.dataset_uuid))]\\n df = concat_dataset(datafiles)\\n # expand total to account for time it takes to initialize the model\\n self.total = len(df)*(1.1) \\n self.set_status(\\\"Preprocessing data\\\")\\n df = self.process_data(df, processed_file_path)\\n\\n # load list of 'allennlp.data.instance's. allennlp.data.instance can store true labels and tag info internally.\\n if os.path.exists(nlp_file_path) and not force_prep:\\n with open(nlp_file_path, 'rb') as f:\\n sentences = pickle.load(f)\\n else:\\n #TODO define a universal reader for certain format\\n # reader = RestaurantsDatasetReader()\\n # data = reader.read(processed_file_path)\\n #TODO handle when aux files do not exist\\n pass\\n bert_emb = np.load(bert_file_path, allow_pickle=True)\\n elmo_emb = np.load(elmo_file_path, allow_pickle=True)\\n sbert_emb = np.load(sbert_file_path, allow_pickle=True)\\n for s, b, e, sb in zip(sentences, bert_emb, elmo_emb, sbert_emb):\\n s.fields['bert'] = b\\n s.fields['sbert'] = sb\\n s.fields['elmo'] = e\\n\\n df['bert'] = bert_emb\\n df['sbert'] = [sb for sb in sbert_emb]\\n df['elmo'] = elmo_emb\\n df['text_nlp'] = sentences\\n\\n columns_to_drop = list(\\n set(df.columns).intersection(set(['span_label','file','label'])))\\n df = df.drop(columns=columns_to_drop).reset_index()\\n # since df['text_nlp'] contains true label info, drop 'labels' column.\\n columns_to_drop = list(set(df.columns).difference(set(['index', 'Unnamed: 0', 'text', 'labels', 'split', 'bert', 'sbert',\\n 'elmo', 'text_nlp'])))\\n if len(columns_to_drop) > 0:\\n df = df.drop(columns=columns_to_drop)\\n df_train = df[df['split']=='train']\\n df_dev = df[df['split'] == 'dev']\\n df_valid = df[df['split'] == 'valid']\\n df_test = df[df['split'] == 'test']\\n\\n self.text_inv_dict = dict(\\n zip(list(df['text']),list(df.index))\\n )\\n\\n # TODO split heldout set if necessary\\n # for now, passing empty df as heldout set\\n df_heldout = df_test\\n\\n self.emb_dict = Embeddings(df)\\n\\n self.set_status(\\\"Initializing modeler\\\")\\n self.modeler = Modeler(df_train, df_dev, df_valid, df_test, df_heldout, self.labels, emb_dict=self.emb_dict)\\n\\n self.launch_progress = 1.0\\n self.set_status(\\\"Finished\\\")\\n return self.modeler\",\n \"def dataset_preparation():\\r\\n with open('../data/patterns_num.txt', 'r') as f:\\r\\n data = f.readlines()\\r\\n X, Y = [], []\\r\\n for line in data:\\r\\n x, y = line.split('\\\\t')\\r\\n if len(x) > 5 and x not in X: # better results are achieved excluding short query patterns\\r\\n X.append(x.replace(\\\"X\\\", \\\"\\\").replace(\\\"Y\\\", \\\"\\\").lower())\\r\\n Y.append(int(y.replace('\\\\n', '')))\\r\\n test_size = 0.2\\r\\n # print('Test size:', test_size, '\\\\nWrong classifications:\\\\n')\\r\\n\\r\\n X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=test_size, random_state=42, stratify=Y)\\r\\n return X_train, y_train, X_test, y_test\",\n \"def initialize(self):\\n for key in self.parameter_dict:\\n self.models[key] = self._create_model(key)\",\n \"def create_data_model():\\r\\n data = {}\\r\\n data['distance_matrix'] = distance_matrix.tolist()\\r\\n data['time_matrix'] = time_matrix.tolist()\\r\\n data['time_windows'] = time_windows.tolist()\\r\\n data['pickups_deliveries'] = pickup_deliveries.tolist()\\r\\n data['demands'] = demand\\r\\n data['num_vehicles'] = 20\\r\\n data['vehicle_capacities'] = [20 * i / i for i in range(1, num_vehicles+1)]\\r\\n data['depot'] = (2 * length) - 1\\r\\n return data\",\n \"def _prepare_libsvm_data(self):\\n logging.info('Preparing libsvm training data...')\\n if self.clean or not (self.is_s3_file(self.s3_training_file) and self.is_s3_file(self.s3_validation_file)):\\n logging.info('S3 libsvm files do not exist.')\\n if self.clean or not (os.path.isfile(self.local_libsvm_training_file) and os.path.isfile(self.local_libsvm_validation_file)):\\n logging.info('Local libsvm files do not exist.')\\n logging.info('Generating local libsvm files...')\\n dump_svmlight_file(X=self.training_x, y=self.training_y, f=self.local_libsvm_training_file)\\n dump_svmlight_file(X=self.validation_x, y=self.validation_y, f=self.local_libsvm_validation_file)\\n logging.info('Local libsvm files found. Uploading to S3...')\\n upload_file_to_s3(self.local_libsvm_training_file, self.infra_s3['s3_bucket'], self.s3_training_file)\\n upload_file_to_s3(self.local_libsvm_validation_file, self.infra_s3['s3_bucket'], self.s3_validation_file)\\n else:\\n logging.info('S3 libsvm files already exist. Skipping step.')\",\n \"def prepare_data(self,d):\\n train_loaders, train_iters = {}, {}\\n unlabeled_loaders, unlabeled_iters = {}, {}\\n for domain in opt.domains:\\n #CONVERT TO FLOAT32\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape((-1,1))\\n train = data_utils.TensorDataset(features,target)\\n train_loaders[domain] = DataLoader(train, opt.batch_size, shuffle = True)\\n train_iters[domain] = iter(train_loaders[domain])\\n for domain in opt.unlabeled_domains:\\n features, target = torch.from_numpy(d[domain].X.todense().astype('float32')), torch.from_numpy(d[domain].y)#.reshape(-1,1))\\n uset = data_utils.TensorDataset(features,target)\\n unlabeled_loaders[domain] = DataLoader(uset,opt.batch_size, shuffle = True)\\n unlabeled_iters[domain] = iter(unlabeled_loaders[domain])\\n \\n return train_loaders, train_iters, unlabeled_loaders, unlabeled_iters\",\n \"def prepare_evaluation(self):\\n self.model = load_model(self.path_best_model)\\n\\n if not self.is_exist(f'{self.path_model_directory}evaluation_ready_sequences.data'):\\n self.evaluation_dataframe = self.remove_catalogs(dataframe=self.load_evaluation_data())\\n\\n self.evaluation_dataframe.drop(['catalog_item_list', 'session_start_time', 'good_catalog_items', 'sequence_length'], axis=1, inplace=True)\\n self.evaluation_dataframe['decoded_item_sequence'] = self.evaluation_dataframe['item_sequence'].copy(deep=True)\\n\\n sequences = self.evaluation_dataframe.values.tolist()\\n joblib.dump(sequences, f'{self.path_model_directory}evaluation_ready_sequences.data')\\n else:\\n sequences = joblib.load(f'{self.path_model_directory}evaluation_ready_sequences.data')\\n self.load_model_metadata()\\n\\n # Set the encode vector size to 1 since this model is not using any encoding for the features\\n self.encoding_vector_size = 1\\n self.evaluation_creator(sequences_to_evaluate=sequences, evaluation_class=Evaluator)\",\n \"def prepare(self):\\n # get data from file\\n train_data, test_data = return_speechacts()\\n # y are the speechacts or 'labels'\\n y_train = [t.split(' ')[0] for t in train_data]\\n y_test = [t.split(' ')[0] for t in test_data]\\n # x are the sentences\\n x_train = [\\\" \\\".join(t.split(' ')[1:]) for t in train_data]\\n x_test = [\\\" \\\".join(t.split(' ')[1:]) for t in test_data]\\n # use the tokenizer and padding from keras to assign arrays of integers\\n # to sentences, out of vocabulary token is 1\\n self.tokenizer_x = Tokenizer(oov_token=1)\\n self.tokenizer_x.fit_on_texts(x_train + x_test)\\n xt_train = self.tokenizer_x.texts_to_sequences(x_train)\\n xt_train = pad_sequences(xt_train, maxlen=self.sentence_size,\\n dtype='int32')\\n xt_test = self.tokenizer_x.texts_to_sequences(x_test)\\n xt_test = pad_sequences(xt_test, maxlen=self.sentence_size,\\n dtype='int32')\\n # vocab is the number of words in our vocabulary\\n self.vocab = len(self.tokenizer_x.word_index) + 1\\n # do the same for labels\\n self.tokenizer_y = Tokenizer()\\n self.tokenizer_y.fit_on_texts(y_train + y_test)\\n yt_train = self.tokenizer_y.texts_to_sequences(y_train)\\n yt_train = [t[0] for t in yt_train]\\n yt_train = to_categorical(yt_train)\\n yt_test = self.tokenizer_y.texts_to_sequences(y_test)\\n yt_test = [t[0] for t in yt_test]\\n yt_test = to_categorical(yt_test)\\n self.x_train = x_train\\n self.y_train = y_train\\n self.x_test = x_test\\n self.y_test = y_test\\n self.xt_train = xt_train\\n self.yt_train = yt_train\\n self.xt_test = xt_test\\n self.yt_test = yt_test\",\n \"def _load_data(self):\\n\\n path_data_x = '/workspace/base-ml/data/dizzyreg/t%s_df.csv' % \\\\\\n self.task_num\\n path_data_y = '/workspace/base-ml/data/dizzyreg/label_df_t%s.csv' % self.task_num\\n path_meta = '/workspace/base-ml/data/dizzyreg/meta_df_t%s.csv' % self.task_num\\n path_numerical_columns = '/workspace/base-ml/data/dizzyreg/num_columns_v2.csv'\\n path_nonnumerical_columns = '/workspace/base-ml/data/dizzyreg/non_num_columns_v2.csv'\\n\\n read_data_x = pd.read_csv(path_data_x)\\n read_data_y = pd.read_csv(path_data_y)\\n read_data_meta = pd.read_csv(path_meta)\\n\\n # Drop columns if it only contains 1 unique element\\n read_data_x = pd.DataFrame(self.drop_one_elem_columns(read_data_x))\\n\\n num_col = pd.read_csv(path_numerical_columns)\\n num_col = read_data_x.columns.isin(num_col['0'].values).nonzero()[0]\\n col_idx = np.arange(read_data_x.shape[-1])\\n non_num_col = np.setdiff1d(col_idx, num_col)\\n\\n # new_data_x = np.array(read_data_x).astype(np.float32)\\n new_data_x = np.array(read_data_x)\\n new_data_y = np.array(read_data_y).astype(np.float32)\\n new_data_meta = np.array(read_data_meta).astype(np.float32)\\n\\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\\n\\n\\n # Winsorize dataset\\n len_feat = new_data_x.shape[-1]\\n idx_list = list(num_col)\\n for i in range(len_feat):\\n if i in idx_list:\\n cur_data = new_data_x[:, i]\\n cur_data = np.array(cur_data)\\n lower_p = np.percentile(cur_data, 5)\\n higher_p = np.percentile(cur_data, 95)\\n cur_data[cur_data < lower_p] = lower_p\\n cur_data[cur_data > higher_p] = higher_p\\n new_data_x[:, i] = cur_data\\n\\n # Make sure target data is one-hot encoded\\n if new_data_y.shape[-1] == 1:\\n num_class = len(np.unique(new_data_y))\\n new_data_y = np.eye(num_class)[new_data_y.astype(int).reshape(-1)]\\n new_data_y = new_data_y.astype('float32')\\n self.orig_column_names = read_data_x.columns\\n self.data_x = new_data_x # N x F\\n self.data_y = new_data_y # N x C\\n self.numerical_idx = num_col # list of idx\\n self.non_num_idx = non_num_col # None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = new_data_meta.astype('float32') # N x 3\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\",\n \"def prep_data(dataset_config=None):\\n \\n\\n data_struct = DataStruct(dataset_config)\\n\\n data_name = data_struct.name\\n datasets_dir = data_struct.data_path\\n out_dir = data_struct.save_path\\n\\n # If dataset already downloaded an unpacked, do nothing\\n if os.path.isdir(out_dir):\\n print('{} already downloaded, unpacked and processed.'.format(data_name))\\n return\\n\\n # Check if download is required\\n data_url = data_struct.url\\n compressed_file_name = downloader(datasets_dir, data_url)\\n\\n # Unpack compressed dataset file\\n unpacker(compressed_file_name, out_dir)\\n\\n # Custom preprocessing steps for data sets\\n custom_preprocessor(out_dir)\",\n \"def preprocess():\\n\\n # Read Training and Test Data\\n train_df = pd.read_csv(configs.TRAIN_DATA_PATH)\\n test_df = pd.read_csv(configs.TEST_DATA_PATH)\\n\\n # Data Exploration and Preprocessing\\n user_ids = train_df['userId']\\n movie_ids = train_df['movieId']\\n ratings = train_df['rating']\\n\\n # Create the mapping and save it for later usage in testing\\n all_users = create_mapping(pd.concat([train_df['userId'], test_df['userId']], axis = 0))\\n all_movies = create_mapping(pd.concat([train_df['movieId'], test_df['movieId']], axis = 0))\\n\\n\\n # Save the mapping arrays for users and movies\\n with open(configs.USER_IDS_PATH, \\\"wb\\\") as f:\\n np.save(f, all_users)\\n\\n with open(configs.MOVIE_IDS_PATH, \\\"wb\\\") as f:\\n np.save(f, all_movies)\\n\\n\\n # Resetting the ids of training data to [0-n]\\n user_ids = map_ids(user_ids, users = True)\\n movie_ids = map_ids(movie_ids, users = False)\\n\\n\\n # Resetting the ids of test data\\n test_user_ids = map_ids(test_df['userId'], users = True)\\n test_movie_ids = map_ids(test_df['movieId'], users = False)\\n test_ratings = test_df['rating']\\n\\n # Statistics of training data\\n # Number of users and movies can be extracted from the array of mapped ids\\n n_users = np.max(user_ids) + 1\\n n_movies = np.max(movie_ids) + 1\\n\\n # Statistics of test data\\n test_n_users = np.max(test_user_ids) + 1\\n test_n_movies = np.max(test_movie_ids) + 1\\n\\n # Returning the indices back can be done using unmap_ids function\\n # Example\\n # unmap_ids(movie_ids, users = False)\\n # unmap_ids(user_ids, users = True)\\n\\n # Define the training rating matrix as sparse matrix\\n\\n # Sparse rating matrix from training data\\n R = sparse.coo_matrix(\\n (ratings, (user_ids, movie_ids)),\\n shape=(n_users, n_movies),\\n dtype=np.float\\n )\\n\\n\\n\\n # Save the rating matrix for training data\\n sparse.save_npz(configs.R_TRAIN_MATRIX_PATH, R)\\n\\n # Sparse rating matrix from test data\\n R2 = sparse.coo_matrix(\\n (test_ratings, (test_user_ids, test_movie_ids)),\\n shape=(test_n_users, test_n_movies),\\n dtype=np.float\\n )\\n\\n # Save the rating matrix for test data\\n sparse.save_npz(configs.R_TEST_MATRIX_PATH, R2)\\n\\n # return user_ids, movie_ids, ratings, n_users, n_movies, R, R2\\n return R, R2\",\n \"def setup(self):\\n\\n module = [m for m in Rt.modules if m.name == self.module_name][0]\\n\\n # Take CPACS file from the optimisation\\n cpacs_path = module.cpacs_in\\n tixi = open_tixi(cpacs_path)\\n self.Model = load_surrogate(tixi)\\n tixi.save(cpacs_path)\\n\\n df = self.Model.df\\n df.set_index(\\\"Name\\\", inplace=True)\\n for name in df.index:\\n if df.loc[name, \\\"type\\\"] == \\\"obj\\\":\\n self.add_output(name)\\n elif df.loc[name, \\\"type\\\"] == \\\"des\\\":\\n self.add_input(name)\\n\\n self.xd = df.loc[[name for name in df.index if df.loc[name, \\\"type\\\"] == \\\"des\\\"]]\\n self.yd = df.loc[[name for name in df.index if df.loc[name, \\\"type\\\"] == \\\"obj\\\"]]\",\n \"def _create_data():\\n tf.logging.info(\\\"Create records..\\\")\\n train, val, test = util.load_data(data_dir, FLAGS[\\\"is_aug\\\"])\\n tf.logging.info(\\\"Dataset size: Train-{} Test-{} Val-{}\\\".format(len(train), len(test), len(val)))\\n return train, val, test\",\n \"def compile(self):\\n self.train = self._make_train()\\n self.loss_test = self._make_loss_test()\\n self.predict = self._make_predict()\",\n \"def preprocess(self):\",\n \"def preprocessing_pipeline(self):\\n self.__multilabel_processing()\\n self.__split_dataset()\\n self.__save_datasets()\",\n \"def preprocess(self):\\n\\n print('[ INFO ]: Preprocessing abalone data...')\\n\\n # Rename headers of data frame\\n abalone_data = pd.read_csv(self.abalone_path, header=None)\\n abalone_data.columns = [\\n 'sex','length','diameter','height','whole_weight','shucked_weight',\\n 'viscera_weight','shell_weight','rings'\\n ]\\n categorical_features = [\\n 'sex'\\n ]\\n continuous_features = [\\n 'length','diameter','height','whole_weight','shucked_weight',\\n 'viscera_weight','shell_weight'\\n ]\\n predictor = 'rings'\\n\\n df = alg.continuous_to_discrete(self, abalone_data, continuous_features)\\n\\n classes = abalone_data[predictor].unique().tolist()\\n\\n features = [df.columns[j] for j in range(len(df.columns)) if df.columns[j] != predictor]\\n\\n return df, features, predictor, classes\",\n \"def prepare_nfold_datasets(self): # i.e. split into different train/ground-truth(test) dataset\\n for alpha in range(1, self.ALPHAs+1):\\n if alpha != self.ALPHAs:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI], separator='-')\\n else:\\n gt_years = np.array2string(self.tl_model.years[(alpha-1)*self.PSI : alpha*self.PSI+self.runoff_years], separator='-')\\n new_cluster_dir = str(Path(self.tl_model.cluster_dir) / f'alpha_{alpha}_GT-{gt_years}')\\n os.makedirs(new_cluster_dir, exist_ok=True)\\n\\n new_prepared_data_dir = str(Path(self.tl_model.prepared_data_dir) / f'alpha_{alpha}')\\n os.makedirs(new_prepared_data_dir, exist_ok=True)\\n \\n if utils.find(f'*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir) and utils.find(f'*alpha_{alpha}_standardized_stacked_arr.pkl', new_prepared_data_dir):\\n pass\\n else:\\n if not utils.find(f'*target*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No input datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_target_dataset(self, alpha, new_prepared_data_dir)\\n\\n if not utils.find(f'*rf*alpha_{alpha}_preprocessed.pkl', new_prepared_data_dir):\\n print(f\\\"=> No rainfall datasets pre-processed for alpha of {alpha}\\\")\\n prepare.cut_rf_dataset(self, alpha, new_prepared_data_dir)\\n \\n print(f'Preprocessed pickles for alpha split {alpha} can be found @:\\\\n{new_prepared_data_dir}')\",\n \"def __init__(self):\\n self.train(positivity_files, 0)\\n self.train(subjectivity_files, 1)\",\n \"def preprocess(dataset):\\n preped_dataset = {}\\n preped_dataset['c'] = preprocess_set(dataset['c'])\\n preped_dataset['r'] = preprocess_set(dataset['r'])\\n preped_dataset['y'] = dataset['y']\\n return preped_dataset\",\n \"def prepare_data(self):\\n self.empty = 'yes' if len(self.data) == 0 else 'no'\\n self._keys = sorted(key for key in self.data.keys())\\n\\n # Validate the keys\\n for key in self._keys:\\n if not is_valid_matlab_field_label(key):\\n msg = \\\"'{}' is not a valid MATLAB field label\\\".format(key)\\n raise ValueError(msg)\\n self.field_names = \\\" \\\".join(self._keys)\",\n \"def prep_tree_data(self, number: int):\\n filename = \\\"data-before-normalization-{}-out-of-7.csv\\\".format(number)\\n path = str(DATA_PATH.joinpath(\\\"data-splitted\\\", filename))\\n df = pandas.read_csv(path)\\n\\n df.drop(df.columns[0], axis=1, inplace=True)\\n assessments = [x for x in df.columns.values if x.split(\\\"_\\\")[0] == \\\"assessment\\\"]\\n df['average_score'] = df[assessments].mean(skipna=True, axis=1)\\n for assessment in assessments: # somehow he doesn't want to fillna in a batch?\\n df[assessment].fillna(df['average_score'], inplace=True)\\n clicks = [x for x in df.columns.values if x.split(\\\"_\\\")[0] == \\\"vle\\\"]\\n df['vle_click_average'] = df[clicks].mean(skipna=True, axis=1)\\n for click in clicks: # somehow he doesn't want to fillna in a batch?\\n df[click].fillna(df['vle_click_average'], inplace=True)\\n df.dropna()\\n\\n self.change_oh_cat(\\\"gender\\\", df)\\n self.change_oh_cat(\\\"highest_education\\\", df)\\n self.change_oh_cat(\\\"imd_band\\\", df)\\n self.change_oh_cat(\\\"age_band\\\", df)\\n self.change_oh_cat(\\\"disability\\\", df)\\n result_order = {'final_result__Fail': 0, 'final_result__Withdrawn': 2,\\n 'final_result__Pass': 1, 'final_result__Distinction': 3}\\n self.change_oh_cat(\\\"final_result\\\", df, result_order)\\n df[\\\"final_result\\\"].replace(2, 0, inplace=True)\\n df[\\\"final_result\\\"].replace(3, 1, inplace=True)\\n\\n target = df[\\\"final_result\\\"]\\n df.drop([\\\"final_result\\\"], axis=1, inplace=True)\\n\\n x_train, x_test, y_train, y_test = train_test_split(df, target, test_size=0.1,\\n random_state=32, shuffle=True,\\n stratify=target)\\n\\n return x_train, x_test, y_train, y_test\",\n \"def _restore_data_inputs(self):\\n super()._restore_data_inputs()\\n self.training_data = (\\n self._data.training_data.data if self._data.training_data and self._data.training_data.data else None\\n )\\n self.validation_data = (\\n self._data.validation_data.data if self._data.validation_data and self._data.validation_data.data else None\\n )\",\n \"def create_meta_data_pickle(self):\\n self.user_sequences_dataframe = joblib.load(self.path_train_dataframe)\\n\\n self.item_dictionary = pickle.load(open(self.path_item_dictionary, 'rb'))\\n self.number_of_distinct_items = len(self.item_dictionary)\\n self.encoding_vector_size = 1\\n\\n joblib.dump(value=self.retrieve_base_info_dictionary(), filename=self.path_model_metadata)\",\n \"def __initDataFromImages(self):\\n #Check if the local_db exist\\n initial_dirs = os.listdir(os.getcwd())\\n is_db_empty = False\\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\\n [images_dir] = os.listdir(self.base_dir)\\n is_db_empty = images_dir == cfg.local[\\\"IMG_DIR\\\"]\\n if cfg.local[\\\"DEFAULT_IMGS_DIR\\\"] in initial_dirs and is_db_empty:\\n default_path = os.path.join(os.getcwd(), cfg.local[\\\"DEFAULT_IMGS_DIR\\\"])\\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\\n self.le = LabelEncoder()\\n #Nothing relate to mapping name to dir here, we don't care about\\n #This data because of the user doesn't exist in the database\\n self.__savePreProcessedData()\",\n \"def _load_data(self):\\n\\n path_data_x = \\\\\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_feature_data' \\\\\\n '.csv'\\n path_data_y = \\\\\\n '/workspace/base-ml/data/tadpole/adni_one_baseline_label_data' \\\\\\n '.csv'\\n path_meta = '/workspace/base-ml/data/tadpole' \\\\\\n '/adni_one_baseline_meta_data' \\\\\\n '.csv'\\n read_data_x = pd.read_csv(path_data_x)\\n read_data_y = pd.read_csv(path_data_y) # 0 NL, 1, MCI, 2 Dementia\\n read_data_meta = pd.read_csv(path_meta)[['AGE', 'PTGENDER', 'APOE4']]\\n\\n # Replace gender to numeric\\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Male', 0)\\n read_data_meta.PTGENDER = read_data_meta.PTGENDER.replace('Female', 1)\\n\\n new_data_x = np.array(read_data_x).astype(np.float32)\\n new_data_y = np.array(read_data_y).astype(np.float32)\\n new_data_meta = np.array(read_data_meta).astype(np.float32)\\n\\n # Concat meta-information with feature vector input\\n concat_meta = pd.DataFrame(new_data_meta)\\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(0, 'zero')\\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(1, 'one')\\n concat_meta.iloc[:, 2] = concat_meta.iloc[:, 2].replace(2, 'two')\\n concat_meta = concat_meta.to_numpy()\\n new_data_x = np.concatenate([concat_meta, new_data_x], 1)\\n print(new_data_x.shape, new_data_y.shape, new_data_meta.shape)\\n\\n self.orig_column_names = ['Age', 'Gender', 'APOE4'] + \\\\\\n list(read_data_x.columns)\\n self.data_x = new_data_x\\n self.data_y = self.to_one_hot_encoding(new_data_y)\\n self.numerical_idx = np.arange(new_data_x.shape[-1])\\n self.numerical_idx = np.delete(self.numerical_idx, [2]) # Remove APOE column idx\\n self.non_num_idx = np.array([2])\\n self.all_non_numerical_idx = None\\n\\n # self.numerical_idx = np.arange(self.data_x.shape[-1])\\n # self.non_num_idx = None\\n # self.all_non_numerical_idx = None\\n\\n # Calculate adjacency matrix\\n self.meta_inf = new_data_meta.astype('float32')\\n if self.args.graph_type:\\n self.adj = self.get_adjacency()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80092263","0.74358416","0.7237138","0.7234688","0.71888596","0.715646","0.7066007","0.7044061","0.7012535","0.69576716","0.69042885","0.6898071","0.6874291","0.67918086","0.6788373","0.6775429","0.67715067","0.67438567","0.6699872","0.6649036","0.66283435","0.66270053","0.6611262","0.6608981","0.6599886","0.6589759","0.65527296","0.6519839","0.6513511","0.6453457","0.64336956","0.6423949","0.64234674","0.64154714","0.64153","0.64089215","0.64021724","0.63960594","0.63951033","0.6386221","0.6379298","0.63724506","0.6362962","0.6361534","0.63571525","0.63549465","0.63534176","0.6344261","0.6338538","0.6335449","0.63348585","0.6331458","0.63133687","0.6308534","0.630296","0.6301753","0.6296315","0.62963104","0.62672603","0.6252088","0.6242143","0.6239119","0.6236983","0.6219645","0.6215453","0.6192894","0.61922216","0.6191553","0.61894697","0.61883944","0.6181475","0.6172897","0.61720407","0.6167368","0.6154172","0.6153169","0.61516136","0.6148648","0.61438584","0.6142042","0.61411554","0.6140963","0.6130656","0.6127503","0.61272955","0.6124487","0.61189646","0.6117462","0.6109258","0.6108978","0.61046517","0.6102002","0.6100879","0.609938","0.6097824","0.6092678","0.60917294","0.60863864","0.6084489","0.607698","0.6073505"],"string":"[\n \"0.80092263\",\n \"0.74358416\",\n \"0.7237138\",\n \"0.7234688\",\n \"0.71888596\",\n \"0.715646\",\n \"0.7066007\",\n \"0.7044061\",\n \"0.7012535\",\n \"0.69576716\",\n \"0.69042885\",\n \"0.6898071\",\n \"0.6874291\",\n \"0.67918086\",\n \"0.6788373\",\n \"0.6775429\",\n \"0.67715067\",\n \"0.67438567\",\n \"0.6699872\",\n \"0.6649036\",\n \"0.66283435\",\n \"0.66270053\",\n \"0.6611262\",\n \"0.6608981\",\n \"0.6599886\",\n \"0.6589759\",\n \"0.65527296\",\n \"0.6519839\",\n \"0.6513511\",\n \"0.6453457\",\n \"0.64336956\",\n \"0.6423949\",\n \"0.64234674\",\n \"0.64154714\",\n \"0.64153\",\n \"0.64089215\",\n \"0.64021724\",\n \"0.63960594\",\n \"0.63951033\",\n \"0.6386221\",\n \"0.6379298\",\n \"0.63724506\",\n \"0.6362962\",\n \"0.6361534\",\n \"0.63571525\",\n \"0.63549465\",\n \"0.63534176\",\n \"0.6344261\",\n \"0.6338538\",\n \"0.6335449\",\n \"0.63348585\",\n \"0.6331458\",\n \"0.63133687\",\n \"0.6308534\",\n \"0.630296\",\n \"0.6301753\",\n \"0.6296315\",\n \"0.62963104\",\n \"0.62672603\",\n \"0.6252088\",\n \"0.6242143\",\n \"0.6239119\",\n \"0.6236983\",\n \"0.6219645\",\n \"0.6215453\",\n \"0.6192894\",\n \"0.61922216\",\n \"0.6191553\",\n \"0.61894697\",\n \"0.61883944\",\n \"0.6181475\",\n \"0.6172897\",\n \"0.61720407\",\n \"0.6167368\",\n \"0.6154172\",\n \"0.6153169\",\n \"0.61516136\",\n \"0.6148648\",\n \"0.61438584\",\n \"0.6142042\",\n \"0.61411554\",\n \"0.6140963\",\n \"0.6130656\",\n \"0.6127503\",\n \"0.61272955\",\n \"0.6124487\",\n \"0.61189646\",\n \"0.6117462\",\n \"0.6109258\",\n \"0.6108978\",\n \"0.61046517\",\n \"0.6102002\",\n \"0.6100879\",\n \"0.609938\",\n \"0.6097824\",\n \"0.6092678\",\n \"0.60917294\",\n \"0.60863864\",\n \"0.6084489\",\n \"0.607698\",\n \"0.6073505\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88987,"cells":{"query":{"kind":"string","value":"Checks if _any_ robot enters the provided regions"},"document":{"kind":"string","value":"def get_validation_status(self, world) -> ValidationStatus:\n for region in self.regions:\n for robot in world.friendly_team.team_robots:\n if tbots.contains(\n region, tbots.createPoint(robot.current_state.global_position)\n ):\n return ValidationStatus.PASSING\n\n return ValidationStatus.FAILING"},"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 checkRegions(self, iPlayer, regionList, bVassal=False):\n\t\tfor regionID in regionList:\n\t\t\tif not utils.checkRegionControl(iPlayer, regionID, bVassal):\n\t\t\t\treturn False\n\t\treturn True","def is_in_state(location, state_regions):\n flag=0\n for each in state_regions:\n if is_in_region(location,each)==True:\n flag=1\n if flag==1:\n return True\n else:\n return False","def test_bad_region():\n ref_file = pkg_resources.resource_filename('m260b.test_data', 'ref_practice_W_1_chr_1.fasta')\n read_file = pkg_resources.resource_filename('m260b.test_data', 'practice_w_1.std.bad_region1.bam')\n ref_hdr, reference = read_basic_fasta(ref_file) \n read_iter = pysam.Samfile(read_file)\n chr = ref_hdr[1:].strip()\n areg = list(active_regions(read_iter, reference, chr, start_offset=0, flank=30, dfrac=1.0))\n found = False\n for region, reads in areg:\n found |= region.start <= 5769 <= region.stop\n if not found:\n raise ValueError('Window did not open around variant')","def is_in_region(location, region):\n c= count_hits_region(location, region)\n if c%2==1:\n return True\n else:\n return False","def inRegion(self, pulsar):\n # check if l, b are outside region first of all\n if pulsar.gl>180.:\n pulsar.gl -= 360.\n if pulsar.gl > self.GLmax or pulsar.gl < self.GLmin:\n return False\n if math.fabs(pulsar.gb) > self.GBmax or math.fabs(pulsar.gb) < self.GBmin:\n return False\n\n # need to compute ra/dec of pulsar from the l and b (galtfeq)\n ra, dec = go.lb_to_radec(pulsar.gl, pulsar.gb)\n\n # are ra, dec outside region?\n if ra > self.RAmax or ra < self.RAmin:\n return False\n if dec > self.DECmax or dec < self.DECmin:\n return False\n \n # randomly decide if pulsar is in completed area of survey\n if random.random() > self.coverage:\n return False\n \n return True","def check_regions(self, timestamp, bid, ofr, signal, allow=True):\n if self.regions:\n mutated = False\n\n # one ore many region, have to pass at least one test\n for region in self.regions:\n if region.can_delete(timestamp, bid, ofr):\n mutated |= True\n\n elif region.test_region(timestamp, signal):\n # match with at least one region\n return True\n\n if mutated:\n self.cleanup_regions(timestamp, bid, ofr)\n\n return False\n else:\n # no region always pass\n return allow","def checkRegionControl(self, iPlayer, regionID, bVassal = False):\n\t\t\n\t\tbFound = False\n\t\tplotList = self.getRegionPlotList([regionID])\n\t\tfor tPlot in plotList:\n\t\t\t\tpCurrent = gc.getMap().plot(tPlot[0], tPlot[1])\n\t\t\t\tif pCurrent.isCity():\n\t\t\t\t\tiOwner = pCurrent.getPlotCity().getOwner()\n\t\t\t\t\tif iOwner != iPlayer:\n\t\t\t\t\t\tif bVassal:\n\t\t\t\t\t\t\tif gc.getTeam(gc.getPlayer(iOwner).getTeam()).isVassal(iPlayer):\n\t\t\t\t\t\t\t\tbFound = True\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\treturn False\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\treturn False\n\t\t\t\t\telse:\n\t\t\t\t\t\tbFound = True\n\t\tif bFound:\n\t\t\treturn True\n\t\telse:\n\t\t\tfor tPlot in plotList:\n\t\t\t\tpCurrent = gc.getMap().plot(tPlot[0], tPlot[1])\n\t\t\t\tiOwner = pCurrent.getOwner()\n\t\t\t\tif iOwner != iPlayer:\n\t\t\t\t\tbFound = False\n\t\t\t\t\tbreak\n\t\t\t\telse:\n\t\t\t\t\tbFound = True\n\t\t\tif bFound:\n\t\t\t\treturn True\n\t\t\telse:\n\t\t\t\treturn False","def detect_enemies_by_region(self, obs):\n position = self.get_current_location(obs)\n enemy_y, enemy_x = (\n obs.observation.feature_screen.player_relative == _PLAYER_ENEMY).nonzero()\n enemies = list(zip(enemy_x, enemy_y))\n\n # top-left of map is (0,0) and bottom-right is (map_width-1, map_height-1)\n def detect_enemies(region_direction):\n for enemy in enemies:\n if region_direction == \"NORTH_WEST\":\n if enemy[0] < position[0] and enemy[1] < position[1]:\n return 1\n elif region_direction == \"NORTH_EAST\":\n if enemy[0] >= position[0] and enemy[1] < position[1]:\n return 1\n elif region_direction == \"SOUTH_WEST\":\n if enemy[0] < position[0] and enemy[1] >= position[1]:\n return 1\n elif region_direction == \"SOUTH_EAST\":\n if enemy[0] >= position[0] and enemy[1] >= position[1]:\n return 1\n return 0\n\n presences = {}\n regions = [\"NORTH_WEST\", \"NORTH_EAST\", \"SOUTH_WEST\", \"SOUTH_EAST\"]\n for region in regions:\n presences[region] = detect_enemies(region)\n\n return presences[\"NORTH_WEST\"], presences[\"NORTH_EAST\"], presences[\"SOUTH_WEST\"], presences[\"SOUTH_EAST\"]","def is_overlapping(self, region):\n if self.x2 < region.x1:\n return False # this box is left the other\n if self.x1 > region.x2:\n return False # this box is right the other\n if self.y2 < region.y1:\n return False # this box is above the other\n if self.y1 > region.y2:\n return False # this box is below the other\n return True","def all_regions_present(self, gene_list, skipped_gene_matches, query_name, second_query_name=None):\n for region in utils.regions:\n if 'IGH' + region.upper() not in ':'.join(gene_list):\n print ' no %s genes in %s for %s %s' % (region, ':'.join(gene_list), query_name, '' if (second_query_name == None) else second_query_name)\n print ' skipped %s' % (':'.join(skipped_gene_matches))\n print 'giving up on query'\n return False\n\n return True","def get_valid_regions(self):\n pass","def check_region(self, region):\n region_slugs = [x.slug for x in self.manager.get_all_regions()]\n return region in region_slugs","def test_signal_regions(i07_nexus: I07Nexus, regions):\n # Note: this should probably always be a for loop with just 1 iteration.\n for i, _ in enumerate(regions):\n assert i07_nexus.signal_regions[i] == regions[i]","def select_proper_region(self):\n # Click the desired region\n region = self.driver.find_element_by_css_selector(web_map[self.region][button_path])\n region.click()\n time.sleep(1)\n\n try:\n search = self.driver.find_element_by_css_selector(go_to_search)\n search.click()\n time.sleep(1)\n return True\n except NoSuchElementException:\n # This means that the information of this autonomous community is not available\n # at this version\n return False","def treasure_condition(locations):\n return not len(locations) == 0","def in_region(point, plotregion):\n\n if ((point[0] >= plotregion[0]) and\n (point[0] < plotregion[1]) and\n (point[1] >= plotregion[2]) and\n (point[1] < plotregion[3])):\n return True\n else:\n return False","def contains(self, region):\n region = as_region(region)\n\n if region.chromosome != self.chromosome:\n return False\n\n if region.start >= self.start and region.end <= self.end:\n return True\n return False","def in_zone(self, bottom_left, top_right):\n return (bottom_left.x <= self.pos.x and self.pos.x <= bottom_left.x and\n top_right.y <= self.pos.y and self.pos.y <= top_right.y)","def check_has_regions(seq):\n for j in range(len(seq)):\n seq[j]['has_entries'] = 0\n if int(seq[j]['entry_count']) != 0 and int(seq[j]['is_country']) != 1:\n seq[j]['has_entries'] = 1\n\n if int(seq[j]['entry_count']) != 0 and ('regions' not in seq[j] or 'children' not in seq[j]) :\n seq[j]['has_entries'] = 1\n if 'children' in seq[j]:\n seq[j]['has_children'] = 1\n else:\n seq[j]['has_children'] = 0\n return seq","def inside_limits(self, point):\n if not self.regions:\n # Use rectangle check\n lat, lon = point.latitude, point.longitude\n if (lon > self.limits[0] and lat > self.limits[1] and\n lon < self.limits[2] and lat < self.limits[3]):\n return True\n else:\n return False\n else:\n # Check inside all possible regions\n p = Point((point.longitude, point.latitude))\n print(p, point)\n # import IPython; IPython.embed()\n for name, poly in self.regions.items():\n # if poly.contains(p):\n if p.intersects(poly):\n return name\n return False","def contains(self, loc):\n if loc.isLeft(self.topLeft): return False\n if loc.isRight(self.botRight): return False\n if loc.isAbove(self.topLeft): return False\n if loc.isBelow(self.botRight): return False\n return True","def overlaps(self, region):\n region = as_region(region)\n\n if region.chromosome != self.chromosome:\n return False\n\n if self.end is None or region.start is None or region.start <= self.end:\n if self.start is None or region.end is None or region.end >= self.start:\n return True\n return False","def test_signal_regions_len(i07_nexus, regions):\n assert len(i07_nexus.signal_regions) == len(regions)","def test_boundary_boxes(gt_detection_combo):\n found = False\n overlap_threshold = 0.7\n\n for found_box in gt_detection_combo.detected_boxes:\n if overlap_between(gt_detection_combo.gt_box, found_box) > overlap_threshold:\n found = True\n break\n\n assert found is True","def is_in_box_rt(self, rt):\n regions = self.boxes_rt.at(rt)\n if len(regions) > 0:\n return True\n else:\n return False","def detect_enemies_by_region(self, obs, for_subgroup=False):\n if for_subgroup:\n position = self.get_avg_location_of_self_subgroup(obs)\n else:\n position = self.get_current_location(obs)\n enemy_y, enemy_x = (\n obs.observation.feature_screen.player_relative == _PLAYER_ENEMY).nonzero()\n enemies = list(zip(enemy_x, enemy_y))\n\n # top-left of map is (0,0) and bottom-right is (map_width-1, map_height-1)\n def detect_enemies(region_direction):\n for enemy in enemies:\n if region_direction == \"NORTH_WEST\":\n if enemy[0] < position[0] and enemy[1] < position[1]:\n return 1\n elif region_direction == \"NORTH_EAST\":\n if enemy[0] >= position[0] and enemy[1] < position[1]:\n return 1\n elif region_direction == \"SOUTH_WEST\":\n if enemy[0] < position[0] and enemy[1] >= position[1]:\n return 1\n elif region_direction == \"SOUTH_EAST\":\n if enemy[0] >= position[0] and enemy[1] >= position[1]:\n return 1\n return 0\n\n presences = {}\n regions = [\"NORTH_WEST\", \"NORTH_EAST\", \"SOUTH_WEST\", \"SOUTH_EAST\"]\n for region in regions:\n presences[region] = detect_enemies(region)\n\n return presences[\"NORTH_WEST\"], presences[\"NORTH_EAST\"], presences[\"SOUTH_WEST\"], presences[\"SOUTH_EAST\"]","def test_is_mountain_in_range(self):\n self.assertTrue(self.user_location.is_mountain_in_range(self.mountain_one))\n self.assertFalse(self.user_location.is_mountain_in_range(self.mountain_two))","def check_robot_selection(number_of_robots=None):\n # Check if any robots are selected\n robots = get_robot_roots()\n if not robots:\n return False\n # Check against number of robots\n if number_of_robots:\n if len(robots) > number_of_robots:\n return False\n return True","def check_region(self, region_id, action=\"check\"):\n self.init_structures()\n con = SimConnection()\n con.connect(self.gridinfo._url)\n scenedata = con._con.ogrescene_list({\"RegionID\":region_id})\n total = 0\n total_yes = 0\n for groupid, scenegroup in scenedata['res'].items():\n if getattr(self, action+\"_group\")(groupid, scenegroup):\n total_yes += 1\n total += 1\n report = []\n report.append(\"--. \\n\")\n report.append(\"total objects %s. \\n\"%(total,))\n for key in self._found.keys():\n report.append(\"total \"+key+\" %s. \\n\"%(self._total_server[key],))\n report.append(key+\" in blend %s\\n\"%(self._found[key],))\n return report","def is_robot_in_canvas(self, robot):\n return robot in self.__robots","def check_region(self, number):\n return (not self.whitelist_regions or\n number.country_code in self._country_code_whitelist)","def whitelist_regions(self):\n return getattr(self, '_do_whitelist_regions', False)","def check_surroundings(x_coord, y_coord, value):\n\t\tfor i in range(3):\n\t\t\tfor j in range(3):\n\t\t\t\texamining = world[x_coord - 1 + i][y_coord - 1 + j]\n\t\t\t\tif examining.name == value:\n\t\t\t\t\treturn True\n\t\t\t\telse:\n\t\t\t\t\tpass\n\t\treturn False","def check_for_obstacles(self):\n obs = False\n obs_p = []\n for point in self.obstacles:\n if -0.15 <= point[1] <= 0.15: # robot is 178mm wide\n # Obstacles should be less than or equal to 0.2 m away before being detected\n if 0 <= point[0] <= .2:\n obs_p.append(point)\n obs = True\n if obs:\n pos = self.determine_pos_of_obstacle(obs_p)\n data = Obstacle()\n data.x = pos[0]\n data.y = pos[1]\n data.obstacle = True\n self.obs_pub.publish(data)","def test_bkg_regions(i07_nexus: I07Nexus, regions):\n for i, _ in enumerate(regions):\n assert i07_nexus.background_regions[i] == regions[i]","def is_inside_home_ring(self, detections):\n YAW_THRESHOLD = 1.3 # radians\n see_home_tag = False\n good_orientations = 0\n bad_orientations = 0\n\n for detection in detections:\n if detection.id == 256:\n see_home_tag = True\n home_detection = self._transform_to_base_link(detection)\n\n quat = [home_detection.pose.orientation.x,\n home_detection.pose.orientation.y,\n home_detection.pose.orientation.z,\n home_detection.pose.orientation.w]\n _r, _p, y = tf.transformations.euler_from_quaternion(quat)\n y -= math.pi / 2\n y = angles.normalize_angle(y)\n\n if abs(y) < YAW_THRESHOLD:\n bad_orientations += 1\n else:\n good_orientations += 1\n\n if not see_home_tag:\n return False\n\n return bad_orientations >= good_orientations","def check_region(deepconsensus_input: deepconsensus_pb2.DeepConsensusInput,\n species: str,\n contig_chrom: Dict[str, str]) -> Tuple[bool, bool, bool]:\n\n # Eval set contains only molecules that start and end within the bounds.\n # Train set contains only molecules that are entirely outside of the bounds.\n # Based on this logic, molecules that span the training and eval regions\n # will be thrown out entirely.\n\n if species == 'ecoli':\n assert 'ecoli' in deepconsensus_input.chrom_name\n in_train_region = between(deepconsensus_input.chrom_start, *\n dc_constants.ECOLI_REGIONS['TRAIN']) and between(\n deepconsensus_input.chrom_end, *\n dc_constants.ECOLI_REGIONS['TRAIN'])\n in_eval_region = between(deepconsensus_input.chrom_start, *\n dc_constants.ECOLI_REGIONS['EVAL']) and between(\n deepconsensus_input.chrom_end, *\n dc_constants.ECOLI_REGIONS['EVAL'])\n in_test_region = between(deepconsensus_input.chrom_start, *\n dc_constants.ECOLI_REGIONS['TEST']) and between(\n deepconsensus_input.chrom_end, *\n dc_constants.ECOLI_REGIONS['TEST'])\n\n elif species == 'human':\n assert 'ecoli' not in deepconsensus_input.chrom_name\n # Resolve the chrom name for each contig\n chrom_name = contig_chrom.get(deepconsensus_input.chrom_name,\n deepconsensus_input.chrom_name)\n in_train_region = chrom_name in dc_constants.HUMAN_TRAIN_REGIONS\n in_eval_region = chrom_name in dc_constants.HUMAN_EVAL_REGIONS\n in_test_region = chrom_name in dc_constants.HUMAN_TEST_REGIONS\n\n else:\n raise ValueError(\n f\"Invalid species: {species}. Must be either 'human' or 'ecoli.'\")\n\n return in_train_region, in_eval_region, in_test_region","def test_api_regions(self):\n # load api base\n r = requests.get('{server}/api/0.1/'.format(\n server=self.get_server_url())).json()\n # load regions from url specified in api base\n r = requests.get(r['regions']).json()\n self.assertIn('count', r)\n self.assertIn('next', r)\n self.assertIn('prev', r)\n self.assertIn('regions', r)","def doesArmTouchObstacles(armPos, obstacles):\n for i in range(len(armPos)):\n cur_arm = armPos[i]\n arm_x = [cur_arm[0][0],cur_arm[1][0]]\n arm_y = [cur_arm[0][1],cur_arm[1][1]]\n if (arm_x[0] != arm_x[1]):\n arm_a = (arm_y[1]-arm_y[0])/(arm_x[1]-arm_x[0])\n arm_b = arm_y[1]-arm_a*arm_x[1]\n for i in range(len(obstacles)):\n cur_obs = obstacles[i]\n x_range = np.linspace(arm_x[0],arm_x[1],1000)\n y_range = arm_a * x_range + arm_b\n for j in range(1000):\n cur_x = x_range[j]\n cur_y = y_range[j]\n if(((cur_y-cur_obs[1])**2 +(cur_x-cur_obs[0])**2) <= cur_obs[2]**2):\n return True\n if (arm_x[0] == arm_x[1]):\n for i in range(len(obstacles)):\n cur_obs = obstacles[i]\n y_range = np.linspace(arm_y[0],arm_y[1],1000)\n cur_x = arm_x[0]\n for j in range(1000):\n cur_y = y_range[j]\n if(((cur_y-cur_obs[1])**2 +(cur_x-cur_obs[0])**2) <= cur_obs[2]**2):\n return True\n\n\n #print(obstacles)\n\n return False","def check_boundaries(self):\n # Checks if the enemy bar has gone of the net\n if self.rect.left <= self.settings.WINDOW_WIDTH / 2:\n self.rect.left = self.settings.WINDOW_WIDTH / 2\n self.isMovingUp = False\n\n # Checks if the enemy bar has gone out of bound to the right\n if self.rect.right >= self.settings.WINDOW_WIDTH:\n self.rect.right = self.settings.WINDOW_WIDTH\n self.isMovingUp = True","def isRegionHasBuilding(self, regionID, iBuilding):\n\t\tplotList = utils.getRegionPlotList([regionID])\n\t\tfor tCoords in plotList:\n\t\t\tif self.isCityHasBuilding(tCoords, iBuilding):\n\t\t\t\treturn True\n\t\treturn False","def verify(self):\n if \"robot\" not in self.keys():\n raise Exception(\"No Section 'robot' in RobotConfig\")\n# if \"name\" not in self[\"robot\"]:\n# raise Exception(\"No robot.name specified in RobotConfig\")\n if \"controller_file\" not in self['robot']:\n raise Exception(\"No robot.controller_file specified in RobotConfig\")\n# if \"ros_master_uri\" not in self['robot']:\n# raise Exception(\"No robot.ros_master_uri specified in RobotConfig\")\n# if \"bluegigga_dev\" not in self['robot']:\n# raise Exception(\"No robot.bluegigga_dev specified in RobotConfig\")\n if \"robot_dev\" not in self['robot']:\n raise Exception(\"No robot.robot_dev specified in RobotConfig\")","def check_obstructed(r1,r2): \n \n if r1==r2:\n return False\n \n #Densely sample line connecting r1 and r2.\n #If any of those sampled points is inside the rectangle, then the \n #line of sight intersects the rectangle and the tower's view is\n #obstructed.\n NP = 1000\n sampled_x = np.linspace(r1[0],r2[0],NP)\n sampled_y = np.linspace(r1[1],r2[1],NP)\n for x,y,w,h in self.coordinates__obstacles:\n for pt in xrange(NP):\n if (sampled_x[pt] > x) and (sampled_x[pt] < x+w) and \\\n (sampled_y[pt] > y) and (sampled_y[pt] < y+h):\n return True\n return False","def _check_all_systems_ready(self):\n for r in self.robots:\n r.joints = None\n while r.joints is None and not rospy.is_shutdown():\n try:\n r.joints = rospy.wait_for_message(\n r.ns + '/joint_states', JointState, timeout=3.0)\n except:\n rospy.logerr(\"Current /joint_states not ready yet.\\n\\\n Do you spawn the robot and launch ros_control?\")\n try:\n r.model_index = rospy.wait_for_message('/gazebo/model_states', ModelStates, 3).name.index(r.ns[1:])\n except rospy.exceptions.ROSException:\n rospy.logerr(\"Robot model does not exist.\")\n\n # rospy.logdebug(\"ALL SYSTEMS READY\")\n return True","def validate_det1_region(regfile):\n err=-1\n import regions\n# from regions.io.ds9.read import DS9Parser\n from regions import Regions\n assert os.path.isfile(regfile), f'{regfile} does not exist!'\n \n# with open(regfile) as fh: \n# region_string = fh.read()\n# parser = DS9Parser(region_string)\n# assert parser.coordsys == 'image', \\\n# f'Region coordinate system is {parser.coordsys}, not image!'\n\n reg = Regions.read(regfile)\n\n\n # Check and make sure this is a \"pixel\" region and not a \"sky\" region\n\n assert 'Pixel' in f'{type(reg[0])}', \\\n f'Region coordinate system is not image coordinates for {regfile}\\n'\n\n # Check to make sure tha the first region in the file is an \"include\" region\n for ri in reg:\n assert ri.meta['include'] is True, \\\n f'\\n {regfile} has an exclusion region first! \\n Put the source region first instead!'\n break","def test_region_check(self):\n reference = {'region': 'reference'}\n target = {'region': 'target'}\n\n # Check that IOError is raised for nonmatching regions\n self.assertRaises(IOError, librad_drift.RadiometricDrift.check_fields, reference, target)\n\n # Check no error raised if regions match\n librad_drift.RadiometricDrift.check_fields(reference, reference)","def maybe_rectal(self):\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))","def check_obstacle_ahead(distances, angles, save_index = None, length_to_check = 250, half_robot_width = 180, threshold_low = 12, threshold_high = 100):\n distances = np.array(distances)\n angles = np.array(angles)\n # compute angle to differentiate regions\n delta = np.arctan(half_robot_width / length_to_check) * 57.3\n\n # compute the indices for the 2 regions of interest\n idcs1 = np.logical_or(np.logical_and(angles <= 90, angles >= delta), np.logical_and(angles >= 270, angles <= (360 - delta)))\n idcs2 = np.logical_or(np.logical_and(angles >= 0, angles <= delta), np.logical_and(angles <= 360, angles >= (360 - delta)))\n\n # compute the critical ditance for those regions (set of angles)\n critical_distance_1 = half_robot_width / np.abs(np.sin(angles[idcs1] / 57.3))\n critical_distance_2 = length_to_check / np.abs(np.cos(angles[idcs2] / 57.3))\n\n # compare actual distances with critical distances\n obstacles1 = distances[idcs1] < critical_distance_1\n obstacles2 = distances[idcs2] < critical_distance_2\n \n # save for debug\n if save_index is not None:\n np.save(\"/home/arthur/dev/ros/data/lidar/angles_{}.npy\".format(save_index), angles)\n np.save(\"/home/arthur/dev/ros/data/lidar/distances_{}.npy\".format(save_index), distances)\n \n # return true depending on the obstacle detection\n count = (np.count_nonzero(obstacles1) + np.count_nonzero(obstacles2))\n return count >= threshold_low and count <= threshold_high","def is_legal(self, start, end) -> bool:\n return self.board(end) == 0 \\\n and self.board(start) > 0 \\\n and self._check_zone_locks(start, end) \\\n and self.exists_path(start, end)","def test_build_genomic_regions(self):\n\n CDS = pybedtools.BedTool(\"\"\"chr1\\t7700\\t7900\\tfoo\\t0\\t+\\n\n chr1\\t7999\\t8500\\tfoo\\t0\\t+\\n\"\"\", from_string = True)\n UTR5 = pybedtools.BedTool(\"\"\"chr1\\t7499\\t7700\\tfoo\\t0\\t+\\n\"\"\", from_string = True)\n UTR3 = pybedtools.BedTool(\"\"\"chr1\\t8500\\t9000\\tfoo\\t0\\t+\\n\"\"\", from_string = True)\n proxintron = pybedtools.BedTool(\"\"\"chr1\\t100\\t300\\tfoo\\t0\\t+\\n\n chr1\\t798\\t998\\tfoo\\t0\\t+\\n\n chr1\\t2000\\t2200\\tfoo\\t0\\t+\\n\n chr1\\t2798\\t2998\\tfoo\\t0\\t+\\n\n chr1\\t6000\\t6200\\tfoo\\t0\\t+\\n\n chr1\\t6798\\t6998\\tfoo\\t0\\t+\\n\n chr1\\t7900\\t7998\\tfoo\\t0\\t+\\n\"\"\", from_string = True\n )\n distintron = pybedtools.BedTool(\"\"\"chr1\\t301\\t797\\tfoo\\t0\\t+\\n\n chr1\\t2201\\t2797\\tfoo\\t0\\t+\\n\n chr1\\t6201\\t6797\\tfoo\\t0\\t+\\n\"\"\", from_string = True)\n \n regions = build_genomic_regions(pybedtools.BedTool(clipper.test_file(\"test.gtf\")), prox_distance=200) \n \n #print UTR3\n\n #print regions['UTR3']\n print proxintron\n print regions['proxintron']\n #print regions['distintron']\n \n self.assertEqual(len(CDS.intersect(regions['CDS'], f= 1.0, r = True)), 2)\n self.assertEqual(len(UTR5.intersect(regions['UTR5'], f= 1.0, r = True)), 1)\n self.assertEqual(len(UTR3.intersect(regions['UTR3'], f= 1.0, r = True)), 1)\n self.assertEqual(len(proxintron.intersect(regions['proxintron'], f= 1.0, r = True)), 7)\n self.assertEqual(len(distintron.intersect(regions['distintron'], f= 1.0, r = True)), 3)","def test_areas_locked_ok(self):","def satifiesWinConditions(self, coordinates):\n if self.treasureCaptured and (self.x, self.y) in coordinates:\n return True\n else:\n return False","def test_regions(self):\n for i, item in enumerate(self._letters_proto.item):\n for code in item.region:\n # Region codes should be alpha-2 (where possible) or alpha-3 codes as\n # defined by ISO 3166 standard.\n self.assertLess(1, len(code))\n self.assertGreater(4, len(code))\n self.assertTrue(code.isupper(), f'Letter {i}: Region code `{code}` '\n 'should be upper-case')\n if len(code) == 3:\n country = pycountry.countries.get(alpha_3=code)\n self.assertTrue(country, f'Failed to find country for code `{code}`')\n if hasattr(country, 'alpha_2'):\n self.fail(f'Letter {i}: Please use two-letter code '\n f'`{country.alpha_2}` instead of `{country.alpha_3}` '\n f'for {country.name}')\n else:\n country = pycountry.countries.get(alpha_2=code)\n self.assertTrue(country, f'Failed to find country for code {code}')","def robotCanOccupy(self, (xIndex, yIndex)):\n for dx in range(0, self.growRadiusInCells + 1):\n for dy in range(0, self.growRadiusInCells + 1):\n xPlus = util.clip(xIndex+dx, 0, self.xN-1)\n xMinus = util.clip(xIndex-dx, 0, self.xN-1)\n yPlus = util.clip(yIndex+dy, 0, self.yN-1)\n yMinus = util.clip(yIndex-dy, 0, self.yN-1)\n if self.occupied((xPlus, yPlus)) or \\\n self.occupied((xPlus,yMinus)) or \\\n self.occupied((xMinus, yPlus)) or \\\n self.occupied((xMinus, yMinus)):\n return False\n return True","def is_valid_region(region):\n return re.match(r'^[a-z0-9\\-]+$', region)","def test_bkg_regions_len(i07_nexus: I07Nexus, regions):\n assert len(i07_nexus.background_regions) == len(regions)","def test_build__set_regions(self, valid_service: fixture) -> None:\n service: Service = valid_service\n\n assert service.regions == set_service_regions()","def find_valid_region(self, spat_rel):\n # The top-down view is transposed.\n if spat_rel == \"above\":\n is_valid = np.vectorize(lambda x: (x > 157.5) or (x <= -157.5))\n elif spat_rel == \"above-right\":\n is_valid = np.vectorize(lambda x: (x > -157.5) and (x <= -112.5))\n elif spat_rel == \"right\":\n is_valid = np.vectorize(lambda x: (x > -112.5 and x <= -67.5))\n elif spat_rel == \"below-right\":\n is_valid = np.vectorize(lambda x: (x > -67.5) and (x <= -22.5))\n elif spat_rel == \"below\":\n is_valid = np.vectorize(lambda x: (x > -22.5) and (x <= 22.5))\n elif spat_rel == \"below-left\":\n is_valid = np.vectorize(lambda x: (x > 22.5) and (x <= 67.5))\n elif spat_rel == \"left\":\n is_valid = np.vectorize(lambda x: (x > 67.5) and (x <= 112.5))\n elif spat_rel == \"above-left\":\n is_valid = np.vectorize(lambda x: (x > 112.5) and (x <= 157.5))\n return is_valid","def count_hits_region(location, region):\n l=len(region)\n c=0\n for i in range(0,l-1):\n if hits_border(location,region[i],region[i+1])==True:\n c=c+1\n return c","def _is_occupied(\n grid: List[List[str]], row: int, col: int, dx: int, dy: int) -> bool:\n while 0 <= (row + dy) < len(grid) and 0 <= (col + dx) < len(grid[0]):\n row += dy\n col += dx\n if grid[row][col] == 'L':\n return False\n if grid[row][col] == '#':\n return True\n return False","def test_occupied1(self):\n array = np.array(['A'])\n self.assertFalse(self.tt.occupied(array, 0, 0))","def check_inside(self, person):\n p_top_x = person[0] + self.padding\n p_left_y = person[1] + self.padding\n p_bottom_x = person[2] - self.padding\n p_right_y = person[3] - self.padding\n\n return p_top_x >= self.top_x and p_left_y >= self.left_y and p_bottom_x <= self.bottom_x \\\n and p_right_y <= self.right_y","def check_confidence_regions(sigma1, sigma2, sigma3, samples, mean):\n\tsigma1_count = 0\n\tsigma2_count = 0\n\tsigma3_count = 0\n\t\n\tfor sample in samples[1000:,:]:\n\t\ttest1 = ellipse_boundary(sigma1, sample, mean)\n\t\ttest2 = ellipse_boundary(sigma2, sample, mean)\n\t\ttest3 = ellipse_boundary(sigma3, sample, mean)\n\n\t\tif test1 < 1:\n\t\t\tsigma1_count += 1\n\t\t\tsigma2_count += 1\n\t\t\tsigma3_count += 1\n\t\telif test2 < 1:\n\t\t\tsigma2_count += 1\n\t\t\tsigma3_count += 1\n\t\telif test3 < 1:\n\t\t\tsigma3_count += 1\n\t\n\tregion_count = {'1': sigma1_count, '2': sigma2_count, '3': sigma3_count}\n\tprint('region count')\n\tprint(region_count)\n\tprint('sigma1')\n\tprint(sigma1)\n\tprint('sigma2')\n\tprint(sigma2)\n\tprint('sigma3')\n\tprint(sigma3)\n\t\n\treturn region_count","def maze_guard():\n cell_guard = all([1 <= len(row) <= 100 for row in maze])\n row_guard = 1 <= len(maze) <= 100\n return cell_guard and row_guard","def test_avalanche_warning_by_region_obs(self):\n pass","def isFreeOfIslam(self, regionList):\n\t\tbSuccess = True\n\t\tfor regionID in regionList:\n\t\t\tplotList = utils.getRegionPlotList([regionID])\n\t\t\tfor tPlot in plotList:\n\t\t\t\tpCurrent = gc.getMap().plot(tPlot[0], tPlot[1])\n\t\t\t\tif pCurrent.isCity():\n\t\t\t\t\tif pCurrent.getPlotCity().isHasReligion(con.iSunni) or pCurrent.getPlotCity().isHasReligion(con.iShia):\n\t\t\t\t\t\tbSuccess = False\n\t\t\t\t\t\tbreak\n\t\treturn bSuccess","def check_region_components(region, is_level0, base_path):\n if is_level0:\n region = \"_\".join([region, Util.LEVEL0_FLAG])\n # 1.load config file\n with open(region_component_conf, 'r') as f:\n region_component_dic = json.load(f)\n # 2.get all check components of this region\n region_check_function_str = region_component_dic.get(region.upper())\n if not region_check_function_str:\n Util.print_error(\"config file did not contain this region[%s] check function. check please\" % region)\n return False\n region_check_function_list = region_check_function_str.split(\"|\")\n\n region_check_component_dic = {}\n for region_check_function in region_check_function_list:\n function_name = region_check_function.strip()\n if function_name:\n function_full_name = function_name + CHECK_FUNCTION_NAME_SUFFIX\n region_check_component_dic[function_name] = getattr(CheckFunctions, function_full_name)(base_path, region)\n # 3.check each component of this region\n failed_components_check_info_dic = OrderedDict({})\n success_components_check_info_dic = OrderedDict({})\n for name, check_component in region_check_component_dic.iteritems():\n try:\n if check_component.check():\n success_components_check_info_dic[name] = \"\"\n else:\n failed_components_check_info_dic[name] = \"Failed\"\n\n except CheckException, e:\n failed_components_check_info_dic[name] = e.message\n\n return success_components_check_info_dic, failed_components_check_info_dic","def argoverlappingregions(input_region, region_array):\n overlap_i = np.where(np.all([input_region[0] == region_array[:,0],\n input_region[1] <= region_array[:,2],\n input_region[2] >= region_array[:,1]],axis=0))\n return overlap_i[0]","def ContainsRect(*args, **kwargs):\n return _gdi_.Region_ContainsRect(*args, **kwargs)","def ejscreen_areas_of_concern_data_exists(cls):\n return cls.EJSCREEN_AREAS_OF_CONCERN_SOURCE.is_file()","def _is_valid_land(x, y, grid):\n return (x >= 0) and (x < len(grid)) and (y >= 0) and (y < len(grid[0])) and grid[x][y]","def goal_occupied(self, view):\n for line in view.obstacles:\n if linesegdist2(line.p1, line.p2, self.goal) < self.radius ** 2:\n return True\n\n for p in view.pedestrians:\n if p.velocity.length2() == 0.0:\n if p.position.distance_to2(self.goal) < p.radius:\n return True\n\n return False","def input_check(self):\n\n if self.species == 'He': assert self.line_model == 'voigt'\n n_upper_range, e_dens_range, temp_range, b_field_range = get_param_ranges(self.line_model)\n\n if np.isnan(n_upper_range).sum() <= 1:\n assert (self.n_upper in range(n_upper_range[0], n_upper_range[1]))\n if np.isnan(e_dens_range).sum() <= 1:\n assert (e_dens_range[0] <= self.e_dens <= e_dens_range[1])\n if np.isnan(temp_range).sum() <= 1:\n assert (temp_range[0] <= self.temp <= temp_range[1])\n if np.isnan(b_field_range).sum() <= 1:\n assert (b_field_range[0] <= self.b_field <= b_field_range[1])","def Contains(*args, **kwargs):\n return _gdi_.Region_Contains(*args, **kwargs)","def detect_in_bounds(self):\n creature_x, creature_y = self.creature.current_location\n if creature_x < 0 or creature_x >= self.world_width\\\n or creature_y < 0 or creature_y >= self.world_height:\n print('The creature is out of bounds!')\n return False\n return True","def test_if_not_fires_for_enter_on_zone_leave(self):\n self.hass.states.set('geo_location.entity', 'hello', {\n 'latitude': 32.880586,\n 'longitude': -117.237564,\n 'source': 'test_source'\n })\n self.hass.block_till_done()\n\n assert setup_component(self.hass, automation.DOMAIN, {\n automation.DOMAIN: {\n 'trigger': {\n 'platform': 'geo_location',\n 'source': 'test_source',\n 'zone': 'zone.test',\n 'event': 'enter',\n },\n 'action': {\n 'service': 'test.automation',\n }\n }\n })\n\n self.hass.states.set('geo_location.entity', 'hello', {\n 'latitude': 32.881011,\n 'longitude': -117.234758\n })\n self.hass.block_till_done()\n\n self.assertEqual(0, len(self.calls))","def test_occupied2(self):\n array = np.array(['O'])\n self.assertTrue(self.tt.occupied(array, 0, 0))","def test_avalanche_warning_by_region_simple(self):\n pass","def test_topo_current_occupants_positive():\n instance = topo.Topography()\n assert instance.current_occupants()[\"Herbivores\"] >= 0\\\n and instance.current_occupants()[\"Carnivores\"] >= 0","def validarea(state, area):\n if area > len(state) - MEMORY:\n state[HEAD][STATUS] = OOB\n return False\n else:\n return True","def _check_occupied(self, col, row):\n if self.board[row - 1][col - 1] == EMPTY:\n return False\n else:\n return True","def _check_sonar_obstacles(self):\n # TODO: what's a good number?\n BLOCKED_THRESHOLD = 0.7\n\n rate = rospy.Rate(10) # 10 hz\n count = 10\n left = 0\n center = 0\n right = 0\n\n for i in range(count):\n obstacle = self.swarmie.get_obstacle_condition()\n\n if obstacle & Obstacle.SONAR_LEFT == Obstacle.SONAR_LEFT:\n left += 1\n if (obstacle & Obstacle.SONAR_CENTER ==\n Obstacle.SONAR_CENTER):\n center += 1\n if obstacle & Obstacle.SONAR_RIGHT == Obstacle.SONAR_RIGHT:\n right += 1\n\n rate.sleep()\n\n left_blocked = left / count > BLOCKED_THRESHOLD\n center_blocked = center / count > BLOCKED_THRESHOLD\n right_blocked = right / count > BLOCKED_THRESHOLD\n\n return left_blocked, center_blocked, right_blocked","def test_api_region(self):\n # load api base\n r = requests.get('{server}/api/0.1/'.format(\n server=self.get_server_url())).json()\n # load samples from url specified in api base\n r = requests.get(r['regions']).json()\n r = requests.get(r['regions'][0]['url']).json()\n self.assertIn('html', r)\n self.assertIn('id', r)\n self.assertIn('name', r)\n self.assertIn('url', r)\n self.assertIn('rivers', r)\n self.assertIn('sections', r)\n self.assertIn('gages', r)","def check_win(game, pokemon_locations):\n #traverse game\n for i in range(len(game)):\n if game[i] == FLAG:#flagged\n if i not in pokemon_locations:\n return False\n elif game[i] == '~':\n return False\n return True","def _sample_regions(region_rois, gt_regions, voc_sign):\n # overlaps: (rois x gt_regions)\n overlaps_gt = bbox_overlaps(\n np.ascontiguousarray(region_rois[:, 1:5], dtype=np.float),\n np.ascontiguousarray(gt_regions[:, :4], dtype=np.float))\n # gt_assignment = overlaps_gt.argmax(axis=1)\n max_overlaps_gt = overlaps_gt.max(axis=1)\n # labels = gt_regions[gt_assignment, 4:]\n fg_inds = np.where(max_overlaps_gt >= cfg.TRAIN.FG_THRESH_REGION)[0]\n bg_inds = np.where(\n (max_overlaps_gt < cfg.TRAIN.BG_THRESH_HI_REGION) & (max_overlaps_gt >= cfg.TRAIN.BG_THRESH_LO_REGION))[0]\n\n # ## Debug Codes\n # print('fg: {} v.s. bg:{}'.format(len(fg_inds), len(bg_inds)))\n # gt_hit_overlap = overlaps_gt.max(axis=0)\n # hit_ids = np.unique(np.where(gt_hit_overlap >= cfg.TRAIN.FG_THRESH_REGION)[0])\n # print('Recall: {} ({}/{})'.format(\n # float(len(hit_ids)) / len(gt_regions), len(hit_ids), len(gt_regions)))\n # The indices that we're selecting (both fg and bg)\n keep_inds = np.append(fg_inds, bg_inds)\n # Select sampled values from various arrays:\n labels = np.ones((len(keep_inds), gt_regions.shape[1] - 4), dtype=np.int64) * voc_sign['end']\n # Here we randomly select regions overlapped with proposed ROI more than 0.7\n gt_assignment = np.zeros(len(fg_inds), dtype=np.int64)\n for i in range(len(fg_inds)):\n gt_assignment[i] = npr.choice(np.where(overlaps_gt[fg_inds[i]] > cfg.TRAIN.FG_THRESH_REGION)[0], size=1)\n labels[i] = gt_regions[gt_assignment[i], 4:]\n\n # add start label to background and padding them with <end> sign\n labels[len(fg_inds):, 0] = voc_sign['start']\n rois = region_rois[keep_inds]\n\n targets_fg = bbox_transform(rois[:len(fg_inds), 1:5], gt_regions[gt_assignment, :4])\n bbox_inside_weights_fg = np.ones(targets_fg.shape, dtype=np.float32) * cfg.TRAIN.BBOX_INSIDE_WEIGHTS\n targets_bg = np.zeros((bg_inds.size, targets_fg.shape[1]), dtype=np.float32)\n bbox_inside_weight_bg = np.zeros(targets_bg.shape, dtype=np.float32)\n bbox_targets = np.vstack([targets_fg, targets_bg])\n bbox_inside_weight = np.vstack([bbox_inside_weights_fg, bbox_inside_weight_bg])\n\n return labels, bbox_targets, bbox_inside_weight, keep_inds","def is_map_obstacle_in_screen_range(self):\n raise NotImplementedError","def has_guardian(self):\n return self.tiles.count(3) > 0","def check(self, parameters):\n if np.any(parameters < self._lower):\n return False\n if np.any(parameters > self._upper):\n return False\n return True","def _detect_obstacles(self):\n def _distance(point, line_point1, line_point2):\n \"\"\"calcuate the distance between a point and a line\"\"\"\n vec1 = line_point1 - point\n vec2 = line_point2 - point\n distance = np.abs(np.cross(vec1,vec2)) / np.linalg.norm(line_point1-line_point2)\n return distance\n\n def _acute_angle(point, line_point1, line_point2):\n \"\"\"detetrmine if the point is whithin the boundary of the line through law of cosines\"\"\"\n base_line = np.linalg.norm(line_point1-line_point2)\n assert base_line > 0, \"check the library useage\"\n line1 = np.linalg.norm(point - line_point1)\n line2 = np.linalg.norm(point - line_point2)\n cos_angle_1 = (base_line**2 + line1**2 - line2**2)/(2*base_line*line1)\n cos_angle_2 = (base_line**2 + line2**2 - line1**2)/(2*base_line*line2)\n if cos_angle_1 * cos_angle_2 > 0:\n return True\n else:\n return False\n\n if self.obstacles != \"None\": # if user assigned some obstacles\n for line in self.env_config: \n line_point1, line_point2 = np.array(line[0]), np.array(line[1])\n point = np.array(self.state[:2])\n distance = _distance(point, line_point1, line_point2)\n acute_angle = _acute_angle(point, line_point1, line_point2)\n if distance <= 0.02 and acute_angle:\n self.adsorption = True\n break\n else:\n self.adsorption = False","def in_node(self, coord):\n for axis in range(3):\n if coord[axis] < self.mins[axis] or coord[axis] > self.maxs[axis]:\n return False\n\n return True","def test_outside_plus_inside(self):\n for region, bounds in load_region_bounds_dict().items():\n lon_bounds, lat_bounds = bounds\n for key in ['data01', 'ds_shift_lon', 'ds_rev_both', 'ds_irr_both']:\n outside_data = climapy.xr_mask_bounds(data_dict[key],\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\n select_how='outside')['PRECL']\n inside_data = climapy.xr_mask_bounds(data_dict[key],\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\n select_how='inside')['PRECL']\n outside_plus_inside = (np.nan_to_num(outside_data.values) +\n np.nan_to_num(inside_data.values))\n diff_from_input = outside_plus_inside - data_dict[key]['PRECL'].values\n assert np.abs(diff_from_input).max() == 0","def _check_market_place_in_range(self):\n\t\tfor building in self.get_buildings_in_range():\n\t\t\tif building.id == BUILDINGS.MARKET_PLACE_CLASS:\n\t\t\t\tif StaticPather.get_path_on_roads(self.island, self, building) is not None:\n\t\t\t\t\t# a market place is in range\n\t\t\t\t\treturn\n\t\t# no market place found\n\t\tself.session.ingame_gui.message_widget.add(self.position.origin.x, self.position.origin.y, \\\n\t\t 'NO_MARKET_PLACE_IN_RANGE')","def is_within(\r\n self,\r\n y: Tuple[int, int],\r\n x: Tuple[int, int],\r\n expansion: int = 0,\r\n ) -> Tuple[bool, bool, Dict[str, bool]]:\r\n if expansion != 0:\r\n # expand tile boundaries\r\n y = (min(0, y[0] - expansion), y[1] + expansion)\r\n x = (min(0, x[0] - expansion), x[1] + expansion)\r\n\r\n if self.anatomical_structure is None:\r\n # do not proceed without anatomical structure\r\n return True, True, {\"any\": True}\r\n points = list(product(x, y))\r\n paths = {}\r\n for i, region in enumerate(self.anatomical_structure):\r\n region_name = region[\"properties\"][\"classification\"][\"name\"]\r\n for j, coords in enumerate(region[\"geometry\"][\"coordinates\"]):\r\n coords = np.array(coords, dtype=np.int32).squeeze()\r\n paths[f\"{region_name}_{i}_{j}\"] = mpath.Path(coords)\r\n # if any corner is within the structure, consider the whole tile within\r\n within_region = {\r\n region: np.any(path.contains_points(points))\r\n for region, path in paths.items()\r\n }\r\n within_any = np.any(list(within_region.values()))\r\n within_cortex = np.any(\r\n [\r\n \"cortex\" in region.lower() and within\r\n for region, within in within_region.items()\r\n ]\r\n )\r\n return within_any, within_cortex, within_region","def violations(robot, q):\n ub = np.array(variable_dict_to_list(robot.ub))\n lb = np.array(variable_dict_to_list(robot.lb))\n ja_violations = (q > ub) | (q < lb)\n return any(ja_violations)","def is_inside(point, region):\n points = region.vertices\n extrame = Point(x=1000000, y=point.y)\n\n points = points + [points[0]]\n intersect_count = 0\n for i in range(len(points) - 1):\n if is_intersect(Line(point, extrame),\n Line(points[i], points[i+1])):\n intersect_count += 1\n return intersect_count % 2 == 1","def is_inside(self, coordinates: tuple) -> bool:\n if len(coordinates) != 2:\n raise IndexError(\"Coordinates consist of x and y\")\n x, y = coordinates\n if (self.MIN_X <= x <= self.MAX_X) and (self.MIN_Y <= y <= self.MAX_Y):\n return True\n else:\n return False","def is_rectal(self):\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\n or bool(self.depth and 4 <= self.depth <= 16)","def check_for_residue_existance(self):\n if not self.pose.total_residue():\n print \"No pose Loaded.\"\n return False\n\n if not self.current_chain.get() or not self.current_residue.get():\n print \"Chain or residue not set\"\n return False\n\n current_region = self.current_residue.get().split(\":\")\n if len(current_region)>1:\n ResStart = int(current_region[0]); ResEnd = int(self.current_region[1])\n\n\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResStart)==0 or self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResEnd)==0:\n print \"Region not found in pose\"\n return False\n else:\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), int(self.current_residue.get())) ==0:\n\n print \"Residue not found in pose\"\n return False\n\n #If everythig is good then:\n return True","def in_bounds(self, location: tuple) -> bool:\n return 0 <= min(location) and max(location) <= 7","def Check(self):\n cleared = False\n while not cleared:\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\n x1 = i[0][0]\n y1 = i[0][1]\n r1 = i[0][2] / 2\n idx1 = i[0][3]\n x2 = i[1][0]\n y2 = i[1][1]\n r2 = i[1][2] / 2\n idx1 = i[0][3]\n idx2 = i[1][3]\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\n radii = (r1 + r2) * (r1 + r2)\n if distance == radii:\n cleared = True\n elif distance > radii:\n cleared = True\n else:\n if x1 > x2 and y1 > y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n elif x1 > x2 and y1 < y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n elif x1 < x2 and y1 > y2:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n else:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n _logger.debug(\n f\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\"\n )\n cleared = False\n return","def regionstomask(in_regions, genome_len):\n out_mask = np.zeros((2,genome_len)).astype(bool)\n for region in in_regions:\n out_mask[region[0],region[1]:region[2]+1] = True\n return out_mask"],"string":"[\n \"def checkRegions(self, iPlayer, regionList, bVassal=False):\\n\\t\\tfor regionID in regionList:\\n\\t\\t\\tif not utils.checkRegionControl(iPlayer, regionID, bVassal):\\n\\t\\t\\t\\treturn False\\n\\t\\treturn True\",\n \"def is_in_state(location, state_regions):\\n flag=0\\n for each in state_regions:\\n if is_in_region(location,each)==True:\\n flag=1\\n if flag==1:\\n return True\\n else:\\n return False\",\n \"def test_bad_region():\\n ref_file = pkg_resources.resource_filename('m260b.test_data', 'ref_practice_W_1_chr_1.fasta')\\n read_file = pkg_resources.resource_filename('m260b.test_data', 'practice_w_1.std.bad_region1.bam')\\n ref_hdr, reference = read_basic_fasta(ref_file) \\n read_iter = pysam.Samfile(read_file)\\n chr = ref_hdr[1:].strip()\\n areg = list(active_regions(read_iter, reference, chr, start_offset=0, flank=30, dfrac=1.0))\\n found = False\\n for region, reads in areg:\\n found |= region.start <= 5769 <= region.stop\\n if not found:\\n raise ValueError('Window did not open around variant')\",\n \"def is_in_region(location, region):\\n c= count_hits_region(location, region)\\n if c%2==1:\\n return True\\n else:\\n return False\",\n \"def inRegion(self, pulsar):\\n # check if l, b are outside region first of all\\n if pulsar.gl>180.:\\n pulsar.gl -= 360.\\n if pulsar.gl > self.GLmax or pulsar.gl < self.GLmin:\\n return False\\n if math.fabs(pulsar.gb) > self.GBmax or math.fabs(pulsar.gb) < self.GBmin:\\n return False\\n\\n # need to compute ra/dec of pulsar from the l and b (galtfeq)\\n ra, dec = go.lb_to_radec(pulsar.gl, pulsar.gb)\\n\\n # are ra, dec outside region?\\n if ra > self.RAmax or ra < self.RAmin:\\n return False\\n if dec > self.DECmax or dec < self.DECmin:\\n return False\\n \\n # randomly decide if pulsar is in completed area of survey\\n if random.random() > self.coverage:\\n return False\\n \\n return True\",\n \"def check_regions(self, timestamp, bid, ofr, signal, allow=True):\\n if self.regions:\\n mutated = False\\n\\n # one ore many region, have to pass at least one test\\n for region in self.regions:\\n if region.can_delete(timestamp, bid, ofr):\\n mutated |= True\\n\\n elif region.test_region(timestamp, signal):\\n # match with at least one region\\n return True\\n\\n if mutated:\\n self.cleanup_regions(timestamp, bid, ofr)\\n\\n return False\\n else:\\n # no region always pass\\n return allow\",\n \"def checkRegionControl(self, iPlayer, regionID, bVassal = False):\\n\\t\\t\\n\\t\\tbFound = False\\n\\t\\tplotList = self.getRegionPlotList([regionID])\\n\\t\\tfor tPlot in plotList:\\n\\t\\t\\t\\tpCurrent = gc.getMap().plot(tPlot[0], tPlot[1])\\n\\t\\t\\t\\tif pCurrent.isCity():\\n\\t\\t\\t\\t\\tiOwner = pCurrent.getPlotCity().getOwner()\\n\\t\\t\\t\\t\\tif iOwner != iPlayer:\\n\\t\\t\\t\\t\\t\\tif bVassal:\\n\\t\\t\\t\\t\\t\\t\\tif gc.getTeam(gc.getPlayer(iOwner).getTeam()).isVassal(iPlayer):\\n\\t\\t\\t\\t\\t\\t\\t\\tbFound = True\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\treturn False\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\treturn False\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tbFound = True\\n\\t\\tif bFound:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\tfor tPlot in plotList:\\n\\t\\t\\t\\tpCurrent = gc.getMap().plot(tPlot[0], tPlot[1])\\n\\t\\t\\t\\tiOwner = pCurrent.getOwner()\\n\\t\\t\\t\\tif iOwner != iPlayer:\\n\\t\\t\\t\\t\\tbFound = False\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tbFound = True\\n\\t\\t\\tif bFound:\\n\\t\\t\\t\\treturn True\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn False\",\n \"def detect_enemies_by_region(self, obs):\\n position = self.get_current_location(obs)\\n enemy_y, enemy_x = (\\n obs.observation.feature_screen.player_relative == _PLAYER_ENEMY).nonzero()\\n enemies = list(zip(enemy_x, enemy_y))\\n\\n # top-left of map is (0,0) and bottom-right is (map_width-1, map_height-1)\\n def detect_enemies(region_direction):\\n for enemy in enemies:\\n if region_direction == \\\"NORTH_WEST\\\":\\n if enemy[0] < position[0] and enemy[1] < position[1]:\\n return 1\\n elif region_direction == \\\"NORTH_EAST\\\":\\n if enemy[0] >= position[0] and enemy[1] < position[1]:\\n return 1\\n elif region_direction == \\\"SOUTH_WEST\\\":\\n if enemy[0] < position[0] and enemy[1] >= position[1]:\\n return 1\\n elif region_direction == \\\"SOUTH_EAST\\\":\\n if enemy[0] >= position[0] and enemy[1] >= position[1]:\\n return 1\\n return 0\\n\\n presences = {}\\n regions = [\\\"NORTH_WEST\\\", \\\"NORTH_EAST\\\", \\\"SOUTH_WEST\\\", \\\"SOUTH_EAST\\\"]\\n for region in regions:\\n presences[region] = detect_enemies(region)\\n\\n return presences[\\\"NORTH_WEST\\\"], presences[\\\"NORTH_EAST\\\"], presences[\\\"SOUTH_WEST\\\"], presences[\\\"SOUTH_EAST\\\"]\",\n \"def is_overlapping(self, region):\\n if self.x2 < region.x1:\\n return False # this box is left the other\\n if self.x1 > region.x2:\\n return False # this box is right the other\\n if self.y2 < region.y1:\\n return False # this box is above the other\\n if self.y1 > region.y2:\\n return False # this box is below the other\\n return True\",\n \"def all_regions_present(self, gene_list, skipped_gene_matches, query_name, second_query_name=None):\\n for region in utils.regions:\\n if 'IGH' + region.upper() not in ':'.join(gene_list):\\n print ' no %s genes in %s for %s %s' % (region, ':'.join(gene_list), query_name, '' if (second_query_name == None) else second_query_name)\\n print ' skipped %s' % (':'.join(skipped_gene_matches))\\n print 'giving up on query'\\n return False\\n\\n return True\",\n \"def get_valid_regions(self):\\n pass\",\n \"def check_region(self, region):\\n region_slugs = [x.slug for x in self.manager.get_all_regions()]\\n return region in region_slugs\",\n \"def test_signal_regions(i07_nexus: I07Nexus, regions):\\n # Note: this should probably always be a for loop with just 1 iteration.\\n for i, _ in enumerate(regions):\\n assert i07_nexus.signal_regions[i] == regions[i]\",\n \"def select_proper_region(self):\\n # Click the desired region\\n region = self.driver.find_element_by_css_selector(web_map[self.region][button_path])\\n region.click()\\n time.sleep(1)\\n\\n try:\\n search = self.driver.find_element_by_css_selector(go_to_search)\\n search.click()\\n time.sleep(1)\\n return True\\n except NoSuchElementException:\\n # This means that the information of this autonomous community is not available\\n # at this version\\n return False\",\n \"def treasure_condition(locations):\\n return not len(locations) == 0\",\n \"def in_region(point, plotregion):\\n\\n if ((point[0] >= plotregion[0]) and\\n (point[0] < plotregion[1]) and\\n (point[1] >= plotregion[2]) and\\n (point[1] < plotregion[3])):\\n return True\\n else:\\n return False\",\n \"def contains(self, region):\\n region = as_region(region)\\n\\n if region.chromosome != self.chromosome:\\n return False\\n\\n if region.start >= self.start and region.end <= self.end:\\n return True\\n return False\",\n \"def in_zone(self, bottom_left, top_right):\\n return (bottom_left.x <= self.pos.x and self.pos.x <= bottom_left.x and\\n top_right.y <= self.pos.y and self.pos.y <= top_right.y)\",\n \"def check_has_regions(seq):\\n for j in range(len(seq)):\\n seq[j]['has_entries'] = 0\\n if int(seq[j]['entry_count']) != 0 and int(seq[j]['is_country']) != 1:\\n seq[j]['has_entries'] = 1\\n\\n if int(seq[j]['entry_count']) != 0 and ('regions' not in seq[j] or 'children' not in seq[j]) :\\n seq[j]['has_entries'] = 1\\n if 'children' in seq[j]:\\n seq[j]['has_children'] = 1\\n else:\\n seq[j]['has_children'] = 0\\n return seq\",\n \"def inside_limits(self, point):\\n if not self.regions:\\n # Use rectangle check\\n lat, lon = point.latitude, point.longitude\\n if (lon > self.limits[0] and lat > self.limits[1] and\\n lon < self.limits[2] and lat < self.limits[3]):\\n return True\\n else:\\n return False\\n else:\\n # Check inside all possible regions\\n p = Point((point.longitude, point.latitude))\\n print(p, point)\\n # import IPython; IPython.embed()\\n for name, poly in self.regions.items():\\n # if poly.contains(p):\\n if p.intersects(poly):\\n return name\\n return False\",\n \"def contains(self, loc):\\n if loc.isLeft(self.topLeft): return False\\n if loc.isRight(self.botRight): return False\\n if loc.isAbove(self.topLeft): return False\\n if loc.isBelow(self.botRight): return False\\n return True\",\n \"def overlaps(self, region):\\n region = as_region(region)\\n\\n if region.chromosome != self.chromosome:\\n return False\\n\\n if self.end is None or region.start is None or region.start <= self.end:\\n if self.start is None or region.end is None or region.end >= self.start:\\n return True\\n return False\",\n \"def test_signal_regions_len(i07_nexus, regions):\\n assert len(i07_nexus.signal_regions) == len(regions)\",\n \"def test_boundary_boxes(gt_detection_combo):\\n found = False\\n overlap_threshold = 0.7\\n\\n for found_box in gt_detection_combo.detected_boxes:\\n if overlap_between(gt_detection_combo.gt_box, found_box) > overlap_threshold:\\n found = True\\n break\\n\\n assert found is True\",\n \"def is_in_box_rt(self, rt):\\n regions = self.boxes_rt.at(rt)\\n if len(regions) > 0:\\n return True\\n else:\\n return False\",\n \"def detect_enemies_by_region(self, obs, for_subgroup=False):\\n if for_subgroup:\\n position = self.get_avg_location_of_self_subgroup(obs)\\n else:\\n position = self.get_current_location(obs)\\n enemy_y, enemy_x = (\\n obs.observation.feature_screen.player_relative == _PLAYER_ENEMY).nonzero()\\n enemies = list(zip(enemy_x, enemy_y))\\n\\n # top-left of map is (0,0) and bottom-right is (map_width-1, map_height-1)\\n def detect_enemies(region_direction):\\n for enemy in enemies:\\n if region_direction == \\\"NORTH_WEST\\\":\\n if enemy[0] < position[0] and enemy[1] < position[1]:\\n return 1\\n elif region_direction == \\\"NORTH_EAST\\\":\\n if enemy[0] >= position[0] and enemy[1] < position[1]:\\n return 1\\n elif region_direction == \\\"SOUTH_WEST\\\":\\n if enemy[0] < position[0] and enemy[1] >= position[1]:\\n return 1\\n elif region_direction == \\\"SOUTH_EAST\\\":\\n if enemy[0] >= position[0] and enemy[1] >= position[1]:\\n return 1\\n return 0\\n\\n presences = {}\\n regions = [\\\"NORTH_WEST\\\", \\\"NORTH_EAST\\\", \\\"SOUTH_WEST\\\", \\\"SOUTH_EAST\\\"]\\n for region in regions:\\n presences[region] = detect_enemies(region)\\n\\n return presences[\\\"NORTH_WEST\\\"], presences[\\\"NORTH_EAST\\\"], presences[\\\"SOUTH_WEST\\\"], presences[\\\"SOUTH_EAST\\\"]\",\n \"def test_is_mountain_in_range(self):\\n self.assertTrue(self.user_location.is_mountain_in_range(self.mountain_one))\\n self.assertFalse(self.user_location.is_mountain_in_range(self.mountain_two))\",\n \"def check_robot_selection(number_of_robots=None):\\n # Check if any robots are selected\\n robots = get_robot_roots()\\n if not robots:\\n return False\\n # Check against number of robots\\n if number_of_robots:\\n if len(robots) > number_of_robots:\\n return False\\n return True\",\n \"def check_region(self, region_id, action=\\\"check\\\"):\\n self.init_structures()\\n con = SimConnection()\\n con.connect(self.gridinfo._url)\\n scenedata = con._con.ogrescene_list({\\\"RegionID\\\":region_id})\\n total = 0\\n total_yes = 0\\n for groupid, scenegroup in scenedata['res'].items():\\n if getattr(self, action+\\\"_group\\\")(groupid, scenegroup):\\n total_yes += 1\\n total += 1\\n report = []\\n report.append(\\\"--. \\\\n\\\")\\n report.append(\\\"total objects %s. \\\\n\\\"%(total,))\\n for key in self._found.keys():\\n report.append(\\\"total \\\"+key+\\\" %s. \\\\n\\\"%(self._total_server[key],))\\n report.append(key+\\\" in blend %s\\\\n\\\"%(self._found[key],))\\n return report\",\n \"def is_robot_in_canvas(self, robot):\\n return robot in self.__robots\",\n \"def check_region(self, number):\\n return (not self.whitelist_regions or\\n number.country_code in self._country_code_whitelist)\",\n \"def whitelist_regions(self):\\n return getattr(self, '_do_whitelist_regions', False)\",\n \"def check_surroundings(x_coord, y_coord, value):\\n\\t\\tfor i in range(3):\\n\\t\\t\\tfor j in range(3):\\n\\t\\t\\t\\texamining = world[x_coord - 1 + i][y_coord - 1 + j]\\n\\t\\t\\t\\tif examining.name == value:\\n\\t\\t\\t\\t\\treturn True\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tpass\\n\\t\\treturn False\",\n \"def check_for_obstacles(self):\\n obs = False\\n obs_p = []\\n for point in self.obstacles:\\n if -0.15 <= point[1] <= 0.15: # robot is 178mm wide\\n # Obstacles should be less than or equal to 0.2 m away before being detected\\n if 0 <= point[0] <= .2:\\n obs_p.append(point)\\n obs = True\\n if obs:\\n pos = self.determine_pos_of_obstacle(obs_p)\\n data = Obstacle()\\n data.x = pos[0]\\n data.y = pos[1]\\n data.obstacle = True\\n self.obs_pub.publish(data)\",\n \"def test_bkg_regions(i07_nexus: I07Nexus, regions):\\n for i, _ in enumerate(regions):\\n assert i07_nexus.background_regions[i] == regions[i]\",\n \"def is_inside_home_ring(self, detections):\\n YAW_THRESHOLD = 1.3 # radians\\n see_home_tag = False\\n good_orientations = 0\\n bad_orientations = 0\\n\\n for detection in detections:\\n if detection.id == 256:\\n see_home_tag = True\\n home_detection = self._transform_to_base_link(detection)\\n\\n quat = [home_detection.pose.orientation.x,\\n home_detection.pose.orientation.y,\\n home_detection.pose.orientation.z,\\n home_detection.pose.orientation.w]\\n _r, _p, y = tf.transformations.euler_from_quaternion(quat)\\n y -= math.pi / 2\\n y = angles.normalize_angle(y)\\n\\n if abs(y) < YAW_THRESHOLD:\\n bad_orientations += 1\\n else:\\n good_orientations += 1\\n\\n if not see_home_tag:\\n return False\\n\\n return bad_orientations >= good_orientations\",\n \"def check_region(deepconsensus_input: deepconsensus_pb2.DeepConsensusInput,\\n species: str,\\n contig_chrom: Dict[str, str]) -> Tuple[bool, bool, bool]:\\n\\n # Eval set contains only molecules that start and end within the bounds.\\n # Train set contains only molecules that are entirely outside of the bounds.\\n # Based on this logic, molecules that span the training and eval regions\\n # will be thrown out entirely.\\n\\n if species == 'ecoli':\\n assert 'ecoli' in deepconsensus_input.chrom_name\\n in_train_region = between(deepconsensus_input.chrom_start, *\\n dc_constants.ECOLI_REGIONS['TRAIN']) and between(\\n deepconsensus_input.chrom_end, *\\n dc_constants.ECOLI_REGIONS['TRAIN'])\\n in_eval_region = between(deepconsensus_input.chrom_start, *\\n dc_constants.ECOLI_REGIONS['EVAL']) and between(\\n deepconsensus_input.chrom_end, *\\n dc_constants.ECOLI_REGIONS['EVAL'])\\n in_test_region = between(deepconsensus_input.chrom_start, *\\n dc_constants.ECOLI_REGIONS['TEST']) and between(\\n deepconsensus_input.chrom_end, *\\n dc_constants.ECOLI_REGIONS['TEST'])\\n\\n elif species == 'human':\\n assert 'ecoli' not in deepconsensus_input.chrom_name\\n # Resolve the chrom name for each contig\\n chrom_name = contig_chrom.get(deepconsensus_input.chrom_name,\\n deepconsensus_input.chrom_name)\\n in_train_region = chrom_name in dc_constants.HUMAN_TRAIN_REGIONS\\n in_eval_region = chrom_name in dc_constants.HUMAN_EVAL_REGIONS\\n in_test_region = chrom_name in dc_constants.HUMAN_TEST_REGIONS\\n\\n else:\\n raise ValueError(\\n f\\\"Invalid species: {species}. Must be either 'human' or 'ecoli.'\\\")\\n\\n return in_train_region, in_eval_region, in_test_region\",\n \"def test_api_regions(self):\\n # load api base\\n r = requests.get('{server}/api/0.1/'.format(\\n server=self.get_server_url())).json()\\n # load regions from url specified in api base\\n r = requests.get(r['regions']).json()\\n self.assertIn('count', r)\\n self.assertIn('next', r)\\n self.assertIn('prev', r)\\n self.assertIn('regions', r)\",\n \"def doesArmTouchObstacles(armPos, obstacles):\\n for i in range(len(armPos)):\\n cur_arm = armPos[i]\\n arm_x = [cur_arm[0][0],cur_arm[1][0]]\\n arm_y = [cur_arm[0][1],cur_arm[1][1]]\\n if (arm_x[0] != arm_x[1]):\\n arm_a = (arm_y[1]-arm_y[0])/(arm_x[1]-arm_x[0])\\n arm_b = arm_y[1]-arm_a*arm_x[1]\\n for i in range(len(obstacles)):\\n cur_obs = obstacles[i]\\n x_range = np.linspace(arm_x[0],arm_x[1],1000)\\n y_range = arm_a * x_range + arm_b\\n for j in range(1000):\\n cur_x = x_range[j]\\n cur_y = y_range[j]\\n if(((cur_y-cur_obs[1])**2 +(cur_x-cur_obs[0])**2) <= cur_obs[2]**2):\\n return True\\n if (arm_x[0] == arm_x[1]):\\n for i in range(len(obstacles)):\\n cur_obs = obstacles[i]\\n y_range = np.linspace(arm_y[0],arm_y[1],1000)\\n cur_x = arm_x[0]\\n for j in range(1000):\\n cur_y = y_range[j]\\n if(((cur_y-cur_obs[1])**2 +(cur_x-cur_obs[0])**2) <= cur_obs[2]**2):\\n return True\\n\\n\\n #print(obstacles)\\n\\n return False\",\n \"def check_boundaries(self):\\n # Checks if the enemy bar has gone of the net\\n if self.rect.left <= self.settings.WINDOW_WIDTH / 2:\\n self.rect.left = self.settings.WINDOW_WIDTH / 2\\n self.isMovingUp = False\\n\\n # Checks if the enemy bar has gone out of bound to the right\\n if self.rect.right >= self.settings.WINDOW_WIDTH:\\n self.rect.right = self.settings.WINDOW_WIDTH\\n self.isMovingUp = True\",\n \"def isRegionHasBuilding(self, regionID, iBuilding):\\n\\t\\tplotList = utils.getRegionPlotList([regionID])\\n\\t\\tfor tCoords in plotList:\\n\\t\\t\\tif self.isCityHasBuilding(tCoords, iBuilding):\\n\\t\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def verify(self):\\n if \\\"robot\\\" not in self.keys():\\n raise Exception(\\\"No Section 'robot' in RobotConfig\\\")\\n# if \\\"name\\\" not in self[\\\"robot\\\"]:\\n# raise Exception(\\\"No robot.name specified in RobotConfig\\\")\\n if \\\"controller_file\\\" not in self['robot']:\\n raise Exception(\\\"No robot.controller_file specified in RobotConfig\\\")\\n# if \\\"ros_master_uri\\\" not in self['robot']:\\n# raise Exception(\\\"No robot.ros_master_uri specified in RobotConfig\\\")\\n# if \\\"bluegigga_dev\\\" not in self['robot']:\\n# raise Exception(\\\"No robot.bluegigga_dev specified in RobotConfig\\\")\\n if \\\"robot_dev\\\" not in self['robot']:\\n raise Exception(\\\"No robot.robot_dev specified in RobotConfig\\\")\",\n \"def check_obstructed(r1,r2): \\n \\n if r1==r2:\\n return False\\n \\n #Densely sample line connecting r1 and r2.\\n #If any of those sampled points is inside the rectangle, then the \\n #line of sight intersects the rectangle and the tower's view is\\n #obstructed.\\n NP = 1000\\n sampled_x = np.linspace(r1[0],r2[0],NP)\\n sampled_y = np.linspace(r1[1],r2[1],NP)\\n for x,y,w,h in self.coordinates__obstacles:\\n for pt in xrange(NP):\\n if (sampled_x[pt] > x) and (sampled_x[pt] < x+w) and \\\\\\n (sampled_y[pt] > y) and (sampled_y[pt] < y+h):\\n return True\\n return False\",\n \"def _check_all_systems_ready(self):\\n for r in self.robots:\\n r.joints = None\\n while r.joints is None and not rospy.is_shutdown():\\n try:\\n r.joints = rospy.wait_for_message(\\n r.ns + '/joint_states', JointState, timeout=3.0)\\n except:\\n rospy.logerr(\\\"Current /joint_states not ready yet.\\\\n\\\\\\n Do you spawn the robot and launch ros_control?\\\")\\n try:\\n r.model_index = rospy.wait_for_message('/gazebo/model_states', ModelStates, 3).name.index(r.ns[1:])\\n except rospy.exceptions.ROSException:\\n rospy.logerr(\\\"Robot model does not exist.\\\")\\n\\n # rospy.logdebug(\\\"ALL SYSTEMS READY\\\")\\n return True\",\n \"def validate_det1_region(regfile):\\n err=-1\\n import regions\\n# from regions.io.ds9.read import DS9Parser\\n from regions import Regions\\n assert os.path.isfile(regfile), f'{regfile} does not exist!'\\n \\n# with open(regfile) as fh: \\n# region_string = fh.read()\\n# parser = DS9Parser(region_string)\\n# assert parser.coordsys == 'image', \\\\\\n# f'Region coordinate system is {parser.coordsys}, not image!'\\n\\n reg = Regions.read(regfile)\\n\\n\\n # Check and make sure this is a \\\"pixel\\\" region and not a \\\"sky\\\" region\\n\\n assert 'Pixel' in f'{type(reg[0])}', \\\\\\n f'Region coordinate system is not image coordinates for {regfile}\\\\n'\\n\\n # Check to make sure tha the first region in the file is an \\\"include\\\" region\\n for ri in reg:\\n assert ri.meta['include'] is True, \\\\\\n f'\\\\n {regfile} has an exclusion region first! \\\\n Put the source region first instead!'\\n break\",\n \"def test_region_check(self):\\n reference = {'region': 'reference'}\\n target = {'region': 'target'}\\n\\n # Check that IOError is raised for nonmatching regions\\n self.assertRaises(IOError, librad_drift.RadiometricDrift.check_fields, reference, target)\\n\\n # Check no error raised if regions match\\n librad_drift.RadiometricDrift.check_fields(reference, reference)\",\n \"def maybe_rectal(self):\\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))\",\n \"def check_obstacle_ahead(distances, angles, save_index = None, length_to_check = 250, half_robot_width = 180, threshold_low = 12, threshold_high = 100):\\n distances = np.array(distances)\\n angles = np.array(angles)\\n # compute angle to differentiate regions\\n delta = np.arctan(half_robot_width / length_to_check) * 57.3\\n\\n # compute the indices for the 2 regions of interest\\n idcs1 = np.logical_or(np.logical_and(angles <= 90, angles >= delta), np.logical_and(angles >= 270, angles <= (360 - delta)))\\n idcs2 = np.logical_or(np.logical_and(angles >= 0, angles <= delta), np.logical_and(angles <= 360, angles >= (360 - delta)))\\n\\n # compute the critical ditance for those regions (set of angles)\\n critical_distance_1 = half_robot_width / np.abs(np.sin(angles[idcs1] / 57.3))\\n critical_distance_2 = length_to_check / np.abs(np.cos(angles[idcs2] / 57.3))\\n\\n # compare actual distances with critical distances\\n obstacles1 = distances[idcs1] < critical_distance_1\\n obstacles2 = distances[idcs2] < critical_distance_2\\n \\n # save for debug\\n if save_index is not None:\\n np.save(\\\"/home/arthur/dev/ros/data/lidar/angles_{}.npy\\\".format(save_index), angles)\\n np.save(\\\"/home/arthur/dev/ros/data/lidar/distances_{}.npy\\\".format(save_index), distances)\\n \\n # return true depending on the obstacle detection\\n count = (np.count_nonzero(obstacles1) + np.count_nonzero(obstacles2))\\n return count >= threshold_low and count <= threshold_high\",\n \"def is_legal(self, start, end) -> bool:\\n return self.board(end) == 0 \\\\\\n and self.board(start) > 0 \\\\\\n and self._check_zone_locks(start, end) \\\\\\n and self.exists_path(start, end)\",\n \"def test_build_genomic_regions(self):\\n\\n CDS = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t7700\\\\t7900\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t7999\\\\t8500\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n UTR5 = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t7499\\\\t7700\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n UTR3 = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t8500\\\\t9000\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n proxintron = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t100\\\\t300\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t798\\\\t998\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t2000\\\\t2200\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t2798\\\\t2998\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t6000\\\\t6200\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t6798\\\\t6998\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t7900\\\\t7998\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True\\n )\\n distintron = pybedtools.BedTool(\\\"\\\"\\\"chr1\\\\t301\\\\t797\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t2201\\\\t2797\\\\tfoo\\\\t0\\\\t+\\\\n\\n chr1\\\\t6201\\\\t6797\\\\tfoo\\\\t0\\\\t+\\\\n\\\"\\\"\\\", from_string = True)\\n \\n regions = build_genomic_regions(pybedtools.BedTool(clipper.test_file(\\\"test.gtf\\\")), prox_distance=200) \\n \\n #print UTR3\\n\\n #print regions['UTR3']\\n print proxintron\\n print regions['proxintron']\\n #print regions['distintron']\\n \\n self.assertEqual(len(CDS.intersect(regions['CDS'], f= 1.0, r = True)), 2)\\n self.assertEqual(len(UTR5.intersect(regions['UTR5'], f= 1.0, r = True)), 1)\\n self.assertEqual(len(UTR3.intersect(regions['UTR3'], f= 1.0, r = True)), 1)\\n self.assertEqual(len(proxintron.intersect(regions['proxintron'], f= 1.0, r = True)), 7)\\n self.assertEqual(len(distintron.intersect(regions['distintron'], f= 1.0, r = True)), 3)\",\n \"def test_areas_locked_ok(self):\",\n \"def satifiesWinConditions(self, coordinates):\\n if self.treasureCaptured and (self.x, self.y) in coordinates:\\n return True\\n else:\\n return False\",\n \"def test_regions(self):\\n for i, item in enumerate(self._letters_proto.item):\\n for code in item.region:\\n # Region codes should be alpha-2 (where possible) or alpha-3 codes as\\n # defined by ISO 3166 standard.\\n self.assertLess(1, len(code))\\n self.assertGreater(4, len(code))\\n self.assertTrue(code.isupper(), f'Letter {i}: Region code `{code}` '\\n 'should be upper-case')\\n if len(code) == 3:\\n country = pycountry.countries.get(alpha_3=code)\\n self.assertTrue(country, f'Failed to find country for code `{code}`')\\n if hasattr(country, 'alpha_2'):\\n self.fail(f'Letter {i}: Please use two-letter code '\\n f'`{country.alpha_2}` instead of `{country.alpha_3}` '\\n f'for {country.name}')\\n else:\\n country = pycountry.countries.get(alpha_2=code)\\n self.assertTrue(country, f'Failed to find country for code {code}')\",\n \"def robotCanOccupy(self, (xIndex, yIndex)):\\n for dx in range(0, self.growRadiusInCells + 1):\\n for dy in range(0, self.growRadiusInCells + 1):\\n xPlus = util.clip(xIndex+dx, 0, self.xN-1)\\n xMinus = util.clip(xIndex-dx, 0, self.xN-1)\\n yPlus = util.clip(yIndex+dy, 0, self.yN-1)\\n yMinus = util.clip(yIndex-dy, 0, self.yN-1)\\n if self.occupied((xPlus, yPlus)) or \\\\\\n self.occupied((xPlus,yMinus)) or \\\\\\n self.occupied((xMinus, yPlus)) or \\\\\\n self.occupied((xMinus, yMinus)):\\n return False\\n return True\",\n \"def is_valid_region(region):\\n return re.match(r'^[a-z0-9\\\\-]+$', region)\",\n \"def test_bkg_regions_len(i07_nexus: I07Nexus, regions):\\n assert len(i07_nexus.background_regions) == len(regions)\",\n \"def test_build__set_regions(self, valid_service: fixture) -> None:\\n service: Service = valid_service\\n\\n assert service.regions == set_service_regions()\",\n \"def find_valid_region(self, spat_rel):\\n # The top-down view is transposed.\\n if spat_rel == \\\"above\\\":\\n is_valid = np.vectorize(lambda x: (x > 157.5) or (x <= -157.5))\\n elif spat_rel == \\\"above-right\\\":\\n is_valid = np.vectorize(lambda x: (x > -157.5) and (x <= -112.5))\\n elif spat_rel == \\\"right\\\":\\n is_valid = np.vectorize(lambda x: (x > -112.5 and x <= -67.5))\\n elif spat_rel == \\\"below-right\\\":\\n is_valid = np.vectorize(lambda x: (x > -67.5) and (x <= -22.5))\\n elif spat_rel == \\\"below\\\":\\n is_valid = np.vectorize(lambda x: (x > -22.5) and (x <= 22.5))\\n elif spat_rel == \\\"below-left\\\":\\n is_valid = np.vectorize(lambda x: (x > 22.5) and (x <= 67.5))\\n elif spat_rel == \\\"left\\\":\\n is_valid = np.vectorize(lambda x: (x > 67.5) and (x <= 112.5))\\n elif spat_rel == \\\"above-left\\\":\\n is_valid = np.vectorize(lambda x: (x > 112.5) and (x <= 157.5))\\n return is_valid\",\n \"def count_hits_region(location, region):\\n l=len(region)\\n c=0\\n for i in range(0,l-1):\\n if hits_border(location,region[i],region[i+1])==True:\\n c=c+1\\n return c\",\n \"def _is_occupied(\\n grid: List[List[str]], row: int, col: int, dx: int, dy: int) -> bool:\\n while 0 <= (row + dy) < len(grid) and 0 <= (col + dx) < len(grid[0]):\\n row += dy\\n col += dx\\n if grid[row][col] == 'L':\\n return False\\n if grid[row][col] == '#':\\n return True\\n return False\",\n \"def test_occupied1(self):\\n array = np.array(['A'])\\n self.assertFalse(self.tt.occupied(array, 0, 0))\",\n \"def check_inside(self, person):\\n p_top_x = person[0] + self.padding\\n p_left_y = person[1] + self.padding\\n p_bottom_x = person[2] - self.padding\\n p_right_y = person[3] - self.padding\\n\\n return p_top_x >= self.top_x and p_left_y >= self.left_y and p_bottom_x <= self.bottom_x \\\\\\n and p_right_y <= self.right_y\",\n \"def check_confidence_regions(sigma1, sigma2, sigma3, samples, mean):\\n\\tsigma1_count = 0\\n\\tsigma2_count = 0\\n\\tsigma3_count = 0\\n\\t\\n\\tfor sample in samples[1000:,:]:\\n\\t\\ttest1 = ellipse_boundary(sigma1, sample, mean)\\n\\t\\ttest2 = ellipse_boundary(sigma2, sample, mean)\\n\\t\\ttest3 = ellipse_boundary(sigma3, sample, mean)\\n\\n\\t\\tif test1 < 1:\\n\\t\\t\\tsigma1_count += 1\\n\\t\\t\\tsigma2_count += 1\\n\\t\\t\\tsigma3_count += 1\\n\\t\\telif test2 < 1:\\n\\t\\t\\tsigma2_count += 1\\n\\t\\t\\tsigma3_count += 1\\n\\t\\telif test3 < 1:\\n\\t\\t\\tsigma3_count += 1\\n\\t\\n\\tregion_count = {'1': sigma1_count, '2': sigma2_count, '3': sigma3_count}\\n\\tprint('region count')\\n\\tprint(region_count)\\n\\tprint('sigma1')\\n\\tprint(sigma1)\\n\\tprint('sigma2')\\n\\tprint(sigma2)\\n\\tprint('sigma3')\\n\\tprint(sigma3)\\n\\t\\n\\treturn region_count\",\n \"def maze_guard():\\n cell_guard = all([1 <= len(row) <= 100 for row in maze])\\n row_guard = 1 <= len(maze) <= 100\\n return cell_guard and row_guard\",\n \"def test_avalanche_warning_by_region_obs(self):\\n pass\",\n \"def isFreeOfIslam(self, regionList):\\n\\t\\tbSuccess = True\\n\\t\\tfor regionID in regionList:\\n\\t\\t\\tplotList = utils.getRegionPlotList([regionID])\\n\\t\\t\\tfor tPlot in plotList:\\n\\t\\t\\t\\tpCurrent = gc.getMap().plot(tPlot[0], tPlot[1])\\n\\t\\t\\t\\tif pCurrent.isCity():\\n\\t\\t\\t\\t\\tif pCurrent.getPlotCity().isHasReligion(con.iSunni) or pCurrent.getPlotCity().isHasReligion(con.iShia):\\n\\t\\t\\t\\t\\t\\tbSuccess = False\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\treturn bSuccess\",\n \"def check_region_components(region, is_level0, base_path):\\n if is_level0:\\n region = \\\"_\\\".join([region, Util.LEVEL0_FLAG])\\n # 1.load config file\\n with open(region_component_conf, 'r') as f:\\n region_component_dic = json.load(f)\\n # 2.get all check components of this region\\n region_check_function_str = region_component_dic.get(region.upper())\\n if not region_check_function_str:\\n Util.print_error(\\\"config file did not contain this region[%s] check function. check please\\\" % region)\\n return False\\n region_check_function_list = region_check_function_str.split(\\\"|\\\")\\n\\n region_check_component_dic = {}\\n for region_check_function in region_check_function_list:\\n function_name = region_check_function.strip()\\n if function_name:\\n function_full_name = function_name + CHECK_FUNCTION_NAME_SUFFIX\\n region_check_component_dic[function_name] = getattr(CheckFunctions, function_full_name)(base_path, region)\\n # 3.check each component of this region\\n failed_components_check_info_dic = OrderedDict({})\\n success_components_check_info_dic = OrderedDict({})\\n for name, check_component in region_check_component_dic.iteritems():\\n try:\\n if check_component.check():\\n success_components_check_info_dic[name] = \\\"\\\"\\n else:\\n failed_components_check_info_dic[name] = \\\"Failed\\\"\\n\\n except CheckException, e:\\n failed_components_check_info_dic[name] = e.message\\n\\n return success_components_check_info_dic, failed_components_check_info_dic\",\n \"def argoverlappingregions(input_region, region_array):\\n overlap_i = np.where(np.all([input_region[0] == region_array[:,0],\\n input_region[1] <= region_array[:,2],\\n input_region[2] >= region_array[:,1]],axis=0))\\n return overlap_i[0]\",\n \"def ContainsRect(*args, **kwargs):\\n return _gdi_.Region_ContainsRect(*args, **kwargs)\",\n \"def ejscreen_areas_of_concern_data_exists(cls):\\n return cls.EJSCREEN_AREAS_OF_CONCERN_SOURCE.is_file()\",\n \"def _is_valid_land(x, y, grid):\\n return (x >= 0) and (x < len(grid)) and (y >= 0) and (y < len(grid[0])) and grid[x][y]\",\n \"def goal_occupied(self, view):\\n for line in view.obstacles:\\n if linesegdist2(line.p1, line.p2, self.goal) < self.radius ** 2:\\n return True\\n\\n for p in view.pedestrians:\\n if p.velocity.length2() == 0.0:\\n if p.position.distance_to2(self.goal) < p.radius:\\n return True\\n\\n return False\",\n \"def input_check(self):\\n\\n if self.species == 'He': assert self.line_model == 'voigt'\\n n_upper_range, e_dens_range, temp_range, b_field_range = get_param_ranges(self.line_model)\\n\\n if np.isnan(n_upper_range).sum() <= 1:\\n assert (self.n_upper in range(n_upper_range[0], n_upper_range[1]))\\n if np.isnan(e_dens_range).sum() <= 1:\\n assert (e_dens_range[0] <= self.e_dens <= e_dens_range[1])\\n if np.isnan(temp_range).sum() <= 1:\\n assert (temp_range[0] <= self.temp <= temp_range[1])\\n if np.isnan(b_field_range).sum() <= 1:\\n assert (b_field_range[0] <= self.b_field <= b_field_range[1])\",\n \"def Contains(*args, **kwargs):\\n return _gdi_.Region_Contains(*args, **kwargs)\",\n \"def detect_in_bounds(self):\\n creature_x, creature_y = self.creature.current_location\\n if creature_x < 0 or creature_x >= self.world_width\\\\\\n or creature_y < 0 or creature_y >= self.world_height:\\n print('The creature is out of bounds!')\\n return False\\n return True\",\n \"def test_if_not_fires_for_enter_on_zone_leave(self):\\n self.hass.states.set('geo_location.entity', 'hello', {\\n 'latitude': 32.880586,\\n 'longitude': -117.237564,\\n 'source': 'test_source'\\n })\\n self.hass.block_till_done()\\n\\n assert setup_component(self.hass, automation.DOMAIN, {\\n automation.DOMAIN: {\\n 'trigger': {\\n 'platform': 'geo_location',\\n 'source': 'test_source',\\n 'zone': 'zone.test',\\n 'event': 'enter',\\n },\\n 'action': {\\n 'service': 'test.automation',\\n }\\n }\\n })\\n\\n self.hass.states.set('geo_location.entity', 'hello', {\\n 'latitude': 32.881011,\\n 'longitude': -117.234758\\n })\\n self.hass.block_till_done()\\n\\n self.assertEqual(0, len(self.calls))\",\n \"def test_occupied2(self):\\n array = np.array(['O'])\\n self.assertTrue(self.tt.occupied(array, 0, 0))\",\n \"def test_avalanche_warning_by_region_simple(self):\\n pass\",\n \"def test_topo_current_occupants_positive():\\n instance = topo.Topography()\\n assert instance.current_occupants()[\\\"Herbivores\\\"] >= 0\\\\\\n and instance.current_occupants()[\\\"Carnivores\\\"] >= 0\",\n \"def validarea(state, area):\\n if area > len(state) - MEMORY:\\n state[HEAD][STATUS] = OOB\\n return False\\n else:\\n return True\",\n \"def _check_occupied(self, col, row):\\n if self.board[row - 1][col - 1] == EMPTY:\\n return False\\n else:\\n return True\",\n \"def _check_sonar_obstacles(self):\\n # TODO: what's a good number?\\n BLOCKED_THRESHOLD = 0.7\\n\\n rate = rospy.Rate(10) # 10 hz\\n count = 10\\n left = 0\\n center = 0\\n right = 0\\n\\n for i in range(count):\\n obstacle = self.swarmie.get_obstacle_condition()\\n\\n if obstacle & Obstacle.SONAR_LEFT == Obstacle.SONAR_LEFT:\\n left += 1\\n if (obstacle & Obstacle.SONAR_CENTER ==\\n Obstacle.SONAR_CENTER):\\n center += 1\\n if obstacle & Obstacle.SONAR_RIGHT == Obstacle.SONAR_RIGHT:\\n right += 1\\n\\n rate.sleep()\\n\\n left_blocked = left / count > BLOCKED_THRESHOLD\\n center_blocked = center / count > BLOCKED_THRESHOLD\\n right_blocked = right / count > BLOCKED_THRESHOLD\\n\\n return left_blocked, center_blocked, right_blocked\",\n \"def test_api_region(self):\\n # load api base\\n r = requests.get('{server}/api/0.1/'.format(\\n server=self.get_server_url())).json()\\n # load samples from url specified in api base\\n r = requests.get(r['regions']).json()\\n r = requests.get(r['regions'][0]['url']).json()\\n self.assertIn('html', r)\\n self.assertIn('id', r)\\n self.assertIn('name', r)\\n self.assertIn('url', r)\\n self.assertIn('rivers', r)\\n self.assertIn('sections', r)\\n self.assertIn('gages', r)\",\n \"def check_win(game, pokemon_locations):\\n #traverse game\\n for i in range(len(game)):\\n if game[i] == FLAG:#flagged\\n if i not in pokemon_locations:\\n return False\\n elif game[i] == '~':\\n return False\\n return True\",\n \"def _sample_regions(region_rois, gt_regions, voc_sign):\\n # overlaps: (rois x gt_regions)\\n overlaps_gt = bbox_overlaps(\\n np.ascontiguousarray(region_rois[:, 1:5], dtype=np.float),\\n np.ascontiguousarray(gt_regions[:, :4], dtype=np.float))\\n # gt_assignment = overlaps_gt.argmax(axis=1)\\n max_overlaps_gt = overlaps_gt.max(axis=1)\\n # labels = gt_regions[gt_assignment, 4:]\\n fg_inds = np.where(max_overlaps_gt >= cfg.TRAIN.FG_THRESH_REGION)[0]\\n bg_inds = np.where(\\n (max_overlaps_gt < cfg.TRAIN.BG_THRESH_HI_REGION) & (max_overlaps_gt >= cfg.TRAIN.BG_THRESH_LO_REGION))[0]\\n\\n # ## Debug Codes\\n # print('fg: {} v.s. bg:{}'.format(len(fg_inds), len(bg_inds)))\\n # gt_hit_overlap = overlaps_gt.max(axis=0)\\n # hit_ids = np.unique(np.where(gt_hit_overlap >= cfg.TRAIN.FG_THRESH_REGION)[0])\\n # print('Recall: {} ({}/{})'.format(\\n # float(len(hit_ids)) / len(gt_regions), len(hit_ids), len(gt_regions)))\\n # The indices that we're selecting (both fg and bg)\\n keep_inds = np.append(fg_inds, bg_inds)\\n # Select sampled values from various arrays:\\n labels = np.ones((len(keep_inds), gt_regions.shape[1] - 4), dtype=np.int64) * voc_sign['end']\\n # Here we randomly select regions overlapped with proposed ROI more than 0.7\\n gt_assignment = np.zeros(len(fg_inds), dtype=np.int64)\\n for i in range(len(fg_inds)):\\n gt_assignment[i] = npr.choice(np.where(overlaps_gt[fg_inds[i]] > cfg.TRAIN.FG_THRESH_REGION)[0], size=1)\\n labels[i] = gt_regions[gt_assignment[i], 4:]\\n\\n # add start label to background and padding them with <end> sign\\n labels[len(fg_inds):, 0] = voc_sign['start']\\n rois = region_rois[keep_inds]\\n\\n targets_fg = bbox_transform(rois[:len(fg_inds), 1:5], gt_regions[gt_assignment, :4])\\n bbox_inside_weights_fg = np.ones(targets_fg.shape, dtype=np.float32) * cfg.TRAIN.BBOX_INSIDE_WEIGHTS\\n targets_bg = np.zeros((bg_inds.size, targets_fg.shape[1]), dtype=np.float32)\\n bbox_inside_weight_bg = np.zeros(targets_bg.shape, dtype=np.float32)\\n bbox_targets = np.vstack([targets_fg, targets_bg])\\n bbox_inside_weight = np.vstack([bbox_inside_weights_fg, bbox_inside_weight_bg])\\n\\n return labels, bbox_targets, bbox_inside_weight, keep_inds\",\n \"def is_map_obstacle_in_screen_range(self):\\n raise NotImplementedError\",\n \"def has_guardian(self):\\n return self.tiles.count(3) > 0\",\n \"def check(self, parameters):\\n if np.any(parameters < self._lower):\\n return False\\n if np.any(parameters > self._upper):\\n return False\\n return True\",\n \"def _detect_obstacles(self):\\n def _distance(point, line_point1, line_point2):\\n \\\"\\\"\\\"calcuate the distance between a point and a line\\\"\\\"\\\"\\n vec1 = line_point1 - point\\n vec2 = line_point2 - point\\n distance = np.abs(np.cross(vec1,vec2)) / np.linalg.norm(line_point1-line_point2)\\n return distance\\n\\n def _acute_angle(point, line_point1, line_point2):\\n \\\"\\\"\\\"detetrmine if the point is whithin the boundary of the line through law of cosines\\\"\\\"\\\"\\n base_line = np.linalg.norm(line_point1-line_point2)\\n assert base_line > 0, \\\"check the library useage\\\"\\n line1 = np.linalg.norm(point - line_point1)\\n line2 = np.linalg.norm(point - line_point2)\\n cos_angle_1 = (base_line**2 + line1**2 - line2**2)/(2*base_line*line1)\\n cos_angle_2 = (base_line**2 + line2**2 - line1**2)/(2*base_line*line2)\\n if cos_angle_1 * cos_angle_2 > 0:\\n return True\\n else:\\n return False\\n\\n if self.obstacles != \\\"None\\\": # if user assigned some obstacles\\n for line in self.env_config: \\n line_point1, line_point2 = np.array(line[0]), np.array(line[1])\\n point = np.array(self.state[:2])\\n distance = _distance(point, line_point1, line_point2)\\n acute_angle = _acute_angle(point, line_point1, line_point2)\\n if distance <= 0.02 and acute_angle:\\n self.adsorption = True\\n break\\n else:\\n self.adsorption = False\",\n \"def in_node(self, coord):\\n for axis in range(3):\\n if coord[axis] < self.mins[axis] or coord[axis] > self.maxs[axis]:\\n return False\\n\\n return True\",\n \"def test_outside_plus_inside(self):\\n for region, bounds in load_region_bounds_dict().items():\\n lon_bounds, lat_bounds = bounds\\n for key in ['data01', 'ds_shift_lon', 'ds_rev_both', 'ds_irr_both']:\\n outside_data = climapy.xr_mask_bounds(data_dict[key],\\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\\n select_how='outside')['PRECL']\\n inside_data = climapy.xr_mask_bounds(data_dict[key],\\n lon_bounds=lon_bounds, lat_bounds=lat_bounds,\\n select_how='inside')['PRECL']\\n outside_plus_inside = (np.nan_to_num(outside_data.values) +\\n np.nan_to_num(inside_data.values))\\n diff_from_input = outside_plus_inside - data_dict[key]['PRECL'].values\\n assert np.abs(diff_from_input).max() == 0\",\n \"def _check_market_place_in_range(self):\\n\\t\\tfor building in self.get_buildings_in_range():\\n\\t\\t\\tif building.id == BUILDINGS.MARKET_PLACE_CLASS:\\n\\t\\t\\t\\tif StaticPather.get_path_on_roads(self.island, self, building) is not None:\\n\\t\\t\\t\\t\\t# a market place is in range\\n\\t\\t\\t\\t\\treturn\\n\\t\\t# no market place found\\n\\t\\tself.session.ingame_gui.message_widget.add(self.position.origin.x, self.position.origin.y, \\\\\\n\\t\\t 'NO_MARKET_PLACE_IN_RANGE')\",\n \"def is_within(\\r\\n self,\\r\\n y: Tuple[int, int],\\r\\n x: Tuple[int, int],\\r\\n expansion: int = 0,\\r\\n ) -> Tuple[bool, bool, Dict[str, bool]]:\\r\\n if expansion != 0:\\r\\n # expand tile boundaries\\r\\n y = (min(0, y[0] - expansion), y[1] + expansion)\\r\\n x = (min(0, x[0] - expansion), x[1] + expansion)\\r\\n\\r\\n if self.anatomical_structure is None:\\r\\n # do not proceed without anatomical structure\\r\\n return True, True, {\\\"any\\\": True}\\r\\n points = list(product(x, y))\\r\\n paths = {}\\r\\n for i, region in enumerate(self.anatomical_structure):\\r\\n region_name = region[\\\"properties\\\"][\\\"classification\\\"][\\\"name\\\"]\\r\\n for j, coords in enumerate(region[\\\"geometry\\\"][\\\"coordinates\\\"]):\\r\\n coords = np.array(coords, dtype=np.int32).squeeze()\\r\\n paths[f\\\"{region_name}_{i}_{j}\\\"] = mpath.Path(coords)\\r\\n # if any corner is within the structure, consider the whole tile within\\r\\n within_region = {\\r\\n region: np.any(path.contains_points(points))\\r\\n for region, path in paths.items()\\r\\n }\\r\\n within_any = np.any(list(within_region.values()))\\r\\n within_cortex = np.any(\\r\\n [\\r\\n \\\"cortex\\\" in region.lower() and within\\r\\n for region, within in within_region.items()\\r\\n ]\\r\\n )\\r\\n return within_any, within_cortex, within_region\",\n \"def violations(robot, q):\\n ub = np.array(variable_dict_to_list(robot.ub))\\n lb = np.array(variable_dict_to_list(robot.lb))\\n ja_violations = (q > ub) | (q < lb)\\n return any(ja_violations)\",\n \"def is_inside(point, region):\\n points = region.vertices\\n extrame = Point(x=1000000, y=point.y)\\n\\n points = points + [points[0]]\\n intersect_count = 0\\n for i in range(len(points) - 1):\\n if is_intersect(Line(point, extrame),\\n Line(points[i], points[i+1])):\\n intersect_count += 1\\n return intersect_count % 2 == 1\",\n \"def is_inside(self, coordinates: tuple) -> bool:\\n if len(coordinates) != 2:\\n raise IndexError(\\\"Coordinates consist of x and y\\\")\\n x, y = coordinates\\n if (self.MIN_X <= x <= self.MAX_X) and (self.MIN_Y <= y <= self.MAX_Y):\\n return True\\n else:\\n return False\",\n \"def is_rectal(self):\\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\\\\n or bool(self.depth and 4 <= self.depth <= 16)\",\n \"def check_for_residue_existance(self):\\n if not self.pose.total_residue():\\n print \\\"No pose Loaded.\\\"\\n return False\\n\\n if not self.current_chain.get() or not self.current_residue.get():\\n print \\\"Chain or residue not set\\\"\\n return False\\n\\n current_region = self.current_residue.get().split(\\\":\\\")\\n if len(current_region)>1:\\n ResStart = int(current_region[0]); ResEnd = int(self.current_region[1])\\n\\n\\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResStart)==0 or self.pose.pdb_info().pdb2pose(self.current_chain.get(), ResEnd)==0:\\n print \\\"Region not found in pose\\\"\\n return False\\n else:\\n if self.pose.pdb_info().pdb2pose(self.current_chain.get(), int(self.current_residue.get())) ==0:\\n\\n print \\\"Residue not found in pose\\\"\\n return False\\n\\n #If everythig is good then:\\n return True\",\n \"def in_bounds(self, location: tuple) -> bool:\\n return 0 <= min(location) and max(location) <= 7\",\n \"def Check(self):\\n cleared = False\\n while not cleared:\\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\\n x1 = i[0][0]\\n y1 = i[0][1]\\n r1 = i[0][2] / 2\\n idx1 = i[0][3]\\n x2 = i[1][0]\\n y2 = i[1][1]\\n r2 = i[1][2] / 2\\n idx1 = i[0][3]\\n idx2 = i[1][3]\\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\\n radii = (r1 + r2) * (r1 + r2)\\n if distance == radii:\\n cleared = True\\n elif distance > radii:\\n cleared = True\\n else:\\n if x1 > x2 and y1 > y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n elif x1 > x2 and y1 < y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n elif x1 < x2 and y1 > y2:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n else:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n _logger.debug(\\n f\\\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\\\"\\n )\\n cleared = False\\n return\",\n \"def regionstomask(in_regions, genome_len):\\n out_mask = np.zeros((2,genome_len)).astype(bool)\\n for region in in_regions:\\n out_mask[region[0],region[1]:region[2]+1] = True\\n return out_mask\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6682395","0.6617277","0.655005","0.65364325","0.6430662","0.6267606","0.61465126","0.61261976","0.6090589","0.6046472","0.6023994","0.6016984","0.59815913","0.59123266","0.5840832","0.58313024","0.5781557","0.57534957","0.5749572","0.57270414","0.5690216","0.5683975","0.5646001","0.5636102","0.56139797","0.5597318","0.5590149","0.5580774","0.556603","0.5554568","0.55449545","0.55290514","0.55209327","0.5516169","0.55133593","0.5507222","0.5505058","0.54762906","0.54661787","0.5465404","0.54450756","0.5440314","0.5430434","0.54241467","0.54183936","0.5411161","0.53954464","0.53954005","0.53944355","0.5390652","0.538642","0.5373584","0.53696924","0.53695065","0.536563","0.5364573","0.5356382","0.534412","0.5329655","0.5318662","0.52998453","0.52952653","0.5289389","0.5284439","0.5279091","0.526919","0.5267771","0.5264897","0.5261955","0.52580976","0.52488506","0.5245128","0.5243166","0.52315146","0.52307785","0.5230496","0.5217016","0.52093667","0.52080107","0.52054846","0.52029383","0.52025557","0.5195145","0.5194088","0.51937175","0.5192128","0.5188637","0.5188331","0.5187905","0.51819456","0.5178398","0.51766443","0.5176605","0.5173223","0.51724726","0.5171854","0.51702106","0.5169697","0.5166523","0.5165757","0.5157372"],"string":"[\n \"0.6682395\",\n \"0.6617277\",\n \"0.655005\",\n \"0.65364325\",\n \"0.6430662\",\n \"0.6267606\",\n \"0.61465126\",\n \"0.61261976\",\n \"0.6090589\",\n \"0.6046472\",\n \"0.6023994\",\n \"0.6016984\",\n \"0.59815913\",\n \"0.59123266\",\n \"0.5840832\",\n \"0.58313024\",\n \"0.5781557\",\n \"0.57534957\",\n \"0.5749572\",\n \"0.57270414\",\n \"0.5690216\",\n \"0.5683975\",\n \"0.5646001\",\n \"0.5636102\",\n \"0.56139797\",\n \"0.5597318\",\n \"0.5590149\",\n \"0.5580774\",\n \"0.556603\",\n \"0.5554568\",\n \"0.55449545\",\n \"0.55290514\",\n \"0.55209327\",\n \"0.5516169\",\n \"0.55133593\",\n \"0.5507222\",\n \"0.5505058\",\n \"0.54762906\",\n \"0.54661787\",\n \"0.5465404\",\n \"0.54450756\",\n \"0.5440314\",\n \"0.5430434\",\n \"0.54241467\",\n \"0.54183936\",\n \"0.5411161\",\n \"0.53954464\",\n \"0.53954005\",\n \"0.53944355\",\n \"0.5390652\",\n \"0.538642\",\n \"0.5373584\",\n \"0.53696924\",\n \"0.53695065\",\n \"0.536563\",\n \"0.5364573\",\n \"0.5356382\",\n \"0.534412\",\n \"0.5329655\",\n \"0.5318662\",\n \"0.52998453\",\n \"0.52952653\",\n \"0.5289389\",\n \"0.5284439\",\n \"0.5279091\",\n \"0.526919\",\n \"0.5267771\",\n \"0.5264897\",\n \"0.5261955\",\n \"0.52580976\",\n \"0.52488506\",\n \"0.5245128\",\n \"0.5243166\",\n \"0.52315146\",\n \"0.52307785\",\n \"0.5230496\",\n \"0.5217016\",\n \"0.52093667\",\n \"0.52080107\",\n \"0.52054846\",\n \"0.52029383\",\n \"0.52025557\",\n \"0.5195145\",\n \"0.5194088\",\n \"0.51937175\",\n \"0.5192128\",\n \"0.5188637\",\n \"0.5188331\",\n \"0.5187905\",\n \"0.51819456\",\n \"0.5178398\",\n \"0.51766443\",\n \"0.5176605\",\n \"0.5173223\",\n \"0.51724726\",\n \"0.5171854\",\n \"0.51702106\",\n \"0.5169697\",\n \"0.5166523\",\n \"0.5165757\",\n \"0.5157372\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88988,"cells":{"query":{"kind":"string","value":"(override) shows regions to enter"},"document":{"kind":"string","value":"def get_validation_geometry(self, world) -> ValidationGeometry:\n return create_validation_geometry(self.regions)"},"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 render_regions(view=None):\r\n # Get current active view\r\n if view is None:\r\n view = sublime.active_window().active_view()\r\n # Unable to set regions when no view available\r\n if view is None:\r\n return\r\n\r\n # Do no set regions if view is empty or still loading\r\n if view.size() == 0 or view.is_loading():\r\n return\r\n\r\n # Remove all markers to avoid marker conflict\r\n view.erase_regions(S.REGION_KEY_BREAKPOINT)\r\n view.erase_regions(S.REGION_KEY_CURRENT)\r\n view.erase_regions(S.REGION_KEY_DISABLED)\r\n\r\n # Get filename of current view and check if is a valid filename\r\n filename = view.file_name()\r\n if not filename:\r\n return\r\n\r\n # Determine icon for regions\r\n icon_current = get_region_icon(S.KEY_CURRENT_LINE)\r\n icon_disabled = get_region_icon(S.KEY_BREAKPOINT_DISABLED)\r\n icon_enabled = get_region_icon(S.KEY_BREAKPOINT_ENABLED)\r\n\r\n # Get all (disabled) breakpoint rows (line numbers) for file\r\n breakpoint_rows = []\r\n disabled_rows = []\r\n if filename in S.BREAKPOINT and isinstance(S.BREAKPOINT[filename], dict):\r\n for lineno, bp in S.BREAKPOINT[filename].items():\r\n # Do not show temporary breakpoint\r\n if S.BREAKPOINT_RUN is not None and S.BREAKPOINT_RUN['filename'] == filename and S.BREAKPOINT_RUN['lineno'] == lineno:\r\n continue\r\n # Determine if breakpoint is enabled or disabled\r\n if bp['enabled']:\r\n breakpoint_rows.append(lineno)\r\n else:\r\n disabled_rows.append(lineno)\r\n\r\n # Get current line from breakpoint hit\r\n if S.BREAKPOINT_ROW is not None:\r\n # Make sure current breakpoint is in this file\r\n if filename == S.BREAKPOINT_ROW['filename']:\r\n # Remove current line number from breakpoint rows to avoid marker conflict\r\n if S.BREAKPOINT_ROW['lineno'] in breakpoint_rows:\r\n breakpoint_rows.remove(S.BREAKPOINT_ROW['lineno'])\r\n # Set icon for current breakpoint\r\n icon_breakpoint_current = get_region_icon(S.KEY_BREAKPOINT_CURRENT)\r\n if icon_breakpoint_current:\r\n icon_current = icon_breakpoint_current\r\n if S.BREAKPOINT_ROW['lineno'] in disabled_rows:\r\n disabled_rows.remove(S.BREAKPOINT_ROW['lineno'])\r\n # Set current line marker\r\n if icon_current:\r\n view.add_regions(S.REGION_KEY_CURRENT, rows_to_region(S.BREAKPOINT_ROW['lineno']), S.REGION_SCOPE_CURRENT, icon_current, sublime.HIDDEN)\r\n\r\n # Set breakpoint marker(s)\r\n if breakpoint_rows and icon_enabled:\r\n view.add_regions(S.REGION_KEY_BREAKPOINT, rows_to_region(breakpoint_rows), S.REGION_SCOPE_BREAKPOINT, icon_enabled, sublime.HIDDEN)\r\n if disabled_rows and icon_disabled:\r\n view.add_regions(S.REGION_KEY_DISABLED, rows_to_region(disabled_rows), S.REGION_SCOPE_BREAKPOINT, icon_disabled, sublime.HIDDEN)","def add_regions(self, regions, **options):\n \n options.setdefault(\"col\", color(0,0,1))\n options.setdefault(\"style\", \"box\")\n options.setdefault(\"height\", 0.5)\n \n return self.add_track(RegionTrack, -.5, regions, **options)","def RegionList(self):\n command = \"\"\"\n IPython.notebook.kernel.execute(\"RegionList=\" + JSON.stringify(JS9.GetShapes(\"regions\", {{display: '{wid}JS9'}})));\n \"\"\".format(wid=self.wid)\n get_ipython().run_cell_magic('javascript', '', command)","def draw_visible_area(self):\n\n if not self.given_center:\n return\n\n # Figure out what regions we should be showing\n horiz_width = self.hbar.pageStep()\n gui_start_x = self.hbar.value()\n vert_height = self.vbar.pageStep()\n gui_start_y = self.vbar.value()\n (game_min_x, game_max_y) = self.scene_to_ingame(gui_start_x, gui_start_y)\n (game_max_x, game_min_y) = self.scene_to_ingame(\n gui_start_x + horiz_width,\n gui_start_y + vert_height,\n )\n min_rx = game_min_x//32 - 1\n max_rx = game_max_x//32 + 1\n min_ry = game_min_y//32 - 1\n max_ry = game_max_y//32 + 1\n\n # First find out how many regions we're going to have to load (so that\n # we can initialize a progressbar)\n valid_regions = set()\n regions_to_load = []\n for rx in range(min_rx, max_rx+1):\n for ry in range(min_ry, max_ry+1):\n region = (rx, ry)\n valid_regions.add(region)\n if region in self.regions:\n if not self.regions[region].loaded:\n regions_to_load.append(region)\n\n # Initialize progressbar\n region_loading = self.mainwindow.region_loading\n region_loading.start(len(regions_to_load))\n\n # Now actually do the loading\n for idx, region in enumerate(regions_to_load):\n #print('Loading region {}'.format(region))\n self.regions[region].load()\n self.loaded_regions.add(region)\n region_loading.update(idx)\n\n # Unload regions which are too far out\n regions_to_unload = []\n for region in list(self.loaded_regions):\n if region not in valid_regions:\n regions_to_unload.append(region)\n\n region_loading.start(len(regions_to_unload), label='Unloading Regions')\n for idx, region in enumerate(regions_to_unload):\n #print('Unloading region {}'.format(region))\n self.regions[region].unload()\n self.loaded_regions.remove(region)\n region_loading.update(idx)\n\n # Finish our progress bar\n region_loading.finish()","def __str__(self):\n return self.regions","def regions(self, regions):\n self._regions = regions","def __init__(self):\n self.regions = []","def print(self):\n\n print(self._name, \": loc\")\n for region in self._regions:\n print(region.label(), \":\", region.loc())","def rendered_regions(self, obj):\n return obj.render_json(self.context.get('request'))","def push_regions(self, regions: [MouseRegion]):\n raise NotImplementedError","def region_region_checkerboard(self, **_):\n outputs: dict = {}\n\n if self.AGG_BY == \"zone\":\n agg = \"zone\"\n else:\n agg = \"region\"\n\n # List of properties needed by the plot, properties are a set of tuples and\n # contain 3 parts: required True/False, property name and scenarios required,\n # scenarios must be a list.\n properties = [(True, f\"{agg}_{agg}s_Net_Interchange\", self.Scenarios)]\n\n # Runs get_formatted_data within PlotDataStoreAndProcessor to populate PlotDataStoreAndProcessor dictionary\n # with all required properties, returns a 1 if required data is missing\n check_input_data = self.get_formatted_data(properties)\n\n if 1 in check_input_data:\n return MissingInputData()\n\n ncols, nrows = set_x_y_dimension(len(self.Scenarios))\n grid_size = ncols * nrows\n excess_axs = grid_size - len(self.Scenarios)\n\n mplt = PlotLibrary(nrows, ncols, squeeze=False, ravel_axs=True)\n fig, axs = mplt.get_figure()\n plt.subplots_adjust(wspace=0.02, hspace=0.4)\n max_flow_group = []\n Data_Out = []\n n = 0\n for scenario in self.Scenarios:\n rr_int = self[f\"{agg}_{agg}s_Net_Interchange\"].get(scenario)\n if shift_leapday:\n rr_int = adjust_for_leapday(rr_int)\n\n if self.AGG_BY != \"region\" and self.AGG_BY != \"zone\":\n agg_region_mapping = (\n self.region_mapping[[\"region\", self.AGG_BY]]\n .set_index(\"region\")\n .to_dict()[self.AGG_BY]\n )\n # Checks if keys all aggregate to a single value, this plot requires multiple values to work\n if len(set(agg_region_mapping.values())) == 1:\n return UnsupportedAggregation()\n rr_int = rr_int.reset_index()\n rr_int[\"parent\"] = rr_int[\"parent\"].map(agg_region_mapping)\n rr_int[\"child\"] = rr_int[\"child\"].map(agg_region_mapping)\n rr_int_agg = rr_int.groupby([\"parent\", \"child\"], as_index=True).sum()\n rr_int_agg.rename(columns={\"values\": \"flow (MW)\"}, inplace=True)\n rr_int_agg = rr_int_agg.loc[\n rr_int_agg[\"flow (MW)\"] > 0.01\n ] # Keep only positive flows\n rr_int_agg.sort_values(ascending=False, by=\"flow (MW)\")\n rr_int_agg = rr_int_agg / 1000 # MWh -> GWh\n\n data_out = rr_int_agg.copy()\n data_out.rename(\n columns={\"flow (MW)\": \"{} flow (GWh)\".format(scenario)}, inplace=True\n )\n\n max_flow = max(rr_int_agg[\"flow (MW)\"])\n rr_int_agg = rr_int_agg.unstack(\"child\")\n rr_int_agg = rr_int_agg.droplevel(level=0, axis=1)\n\n current_cmap = plt.cm.get_cmap()\n current_cmap.set_bad(color=\"grey\")\n\n axs[n].imshow(rr_int_agg)\n axs[n].set_xticks(np.arange(rr_int_agg.shape[1]))\n axs[n].set_yticks(np.arange(rr_int_agg.shape[0]))\n axs[n].set_xticklabels(rr_int_agg.columns)\n axs[n].set_yticklabels(rr_int_agg.index)\n axs[n].set_title(scenario.replace(\"_\", \" \"), fontweight=\"bold\")\n\n # Rotate the tick labels and set their alignment.\n plt.setp(\n axs[n].get_xticklabels(),\n rotation=90,\n ha=\"right\",\n rotation_mode=\"anchor\",\n )\n\n # Delineate the boxes and make room at top and bottom\n axs[n].set_xticks(np.arange(rr_int_agg.shape[1] + 1) - 0.5, minor=True)\n axs[n].set_yticks(np.arange(rr_int_agg.shape[0] + 1) - 0.5, minor=True)\n axs[n].grid(which=\"minor\", color=\"k\", linestyle=\"-\", linewidth=1)\n axs[n].tick_params(which=\"minor\", bottom=False, left=False)\n\n max_flow_group.append(max_flow)\n Data_Out.append(data_out)\n n += 1\n\n # Remove extra axes\n mplt.remove_excess_axs(excess_axs, grid_size)\n\n cmap = cm.inferno\n norm = mcolors.Normalize(vmin=0, vmax=max(max_flow_group))\n cax = plt.axes([0.90, 0.1, 0.035, 0.8])\n fig.colorbar(\n cm.ScalarMappable(norm=norm, cmap=cmap),\n cax=cax,\n label=\"Total Net Interchange [GWh]\",\n )\n plt.xlabel(\"To Region\", color=\"black\", rotation=\"horizontal\", labelpad=40)\n plt.ylabel(\"From Region\", color=\"black\", rotation=\"vertical\", labelpad=40)\n\n data_table_out = pd.concat(Data_Out, axis=1)\n save_figures = self.figure_folder.joinpath(f\"{self.AGG_BY}_transmission\")\n fig.savefig(\n save_figures.joinpath(\"region_region_checkerboard.svg\"),\n dpi=600,\n bbox_inches=\"tight\",\n )\n data_table_out.to_csv(save_figures.joinpath(\"region_region_checkerboard.csv\"))\n\n outputs = DataSavedInModule()\n return outputs","def description(self):\n return \"create a <b>region</b> with edge at cursor\"","def set_region(sender, instance, *args, **kwargs):\n if instance.geocity and not instance.georegion:\n instance.georegion = instance.geocity.region","def initialize_region(self):\n self.new_region_name = \"\"\n self.map.regions.create_new_region()","def __init__(self, *args, **kwargs):\n _gdi_.Region_swiginit(self,_gdi_.new_Region(*args, **kwargs))","def get_valid_regions(self):\n pass","def _choose_regions(self, display_regions=False):\n dstl = Load_DSTL()\n if self.class_type == 1:\n # Select regions where there are buildings (with red roofs)\n test_image, test_mask = dstl.extract_region_pos(2300, 3000, cutout_size=[400, 400], object_class=self.class_type)\n train_image, train_mask = dstl.extract_region_pos(1900, 3100, cutout_size=[400, 400], object_class=self.class_type)\n cv_image, cv_mask = dstl.extract_region_pos(950, 1450, cutout_size=[200, 200], object_class=self.class_type)\n elif self.class_type == 5:\n train_image, train_mask = dstl.extract_region_pos(1150, 2150, cutout_size=[400, 400], object_class=self.class_type)\n test_image, test_mask = dstl.extract_region_pos(2300, 3000, cutout_size=[400, 400], object_class=self.class_type)\n cv_image, cv_mask = dstl.extract_region_pos(1900, 1950, cutout_size=[400, 400], object_class=self.class_type)\n else:\n pass\n self.images = {'train': train_image, 'cv': cv_image, 'test': test_image}\n self.masks = {'train': train_mask, 'cv': cv_mask, 'test': test_mask}\n if display_regions:\n for key in self.images.keys():\n display_three_band(self.images[key], self.masks[key], colors='green', title='{:} region'.format(key))","def range(self, event):\r\n \r\n p = (event.x, self.toCartesian(event.y))\r\n \r\n if self.selectedRegion is None:\r\n self.selectedStart = Region(p[X],p[Y], p[X],p[Y])\r\n self.selectedRegion = self.selectedStart.unionPoint(p)\r\n \r\n self.paint()\r\n \r\n # return (node,sub-tree) where sub-tree is True if draining entire tree\r\n # rooted at node. Draw these as shaded red rectangle to identify whole\r\n # sub-tree is selected.\r\n for pair in self.tree.range(self.selectedRegion):\r\n p = pair[0].point\r\n \r\n if pair[1]:\r\n self.canvas.create_rectangle(pair[0].region.x_min, self.toTk(pair[0].region.y_min), \r\n pair[0].region.x_max, self.toTk(pair[0].region.y_max),\r\n fill='Red', stipple='gray12')\r\n else:\r\n self.canvas.create_rectangle(p[X] - BoxSize, self.toTk(p[Y]) - BoxSize, \r\n p[X] + BoxSize, self.toTk(p[Y]) + BoxSize, fill='Red')\r\n\r\n self.queryRect = self.canvas.create_rectangle(self.selectedRegion.x_min, self.toTk(self.selectedRegion.y_min), \r\n self.selectedRegion.x_max, self.toTk(self.selectedRegion.y_max), \r\n outline='Red', dash=(2, 4))","def which_region(self, g):\n return NotImplementedError","def which_region(self, g):\n raise NotImplementedError","def onEditorCollapsed(self, collapsed):\r\n # productive\r\n profprint()\r\n if collapsed:\r\n pass\r\n else:\r\n self.createAddOrSelectLabelMapNode()","def __coverageMarkersShown(self, shown):\n if shown:\n self.notcoveredNextAct.setEnabled(True)\n self.notcoveredPreviousAct.setEnabled(True)\n else:\n self.notcoveredNextAct.setEnabled(False)\n self.notcoveredPreviousAct.setEnabled(False)","def on_select(self, pos1, pos2):\n \n # determine selected chrom\n chrom = self.pos2chrom(*pos1)\n chrom2 = self.pos2chrom(*pos2)\n\n if chrom == None:\n print \"no chromosome selected\"\n return\n\n if chrom != chrom2:\n print \"please select only one chromosome\"\n return\n\n x1 = pos1[0]\n x2 = pos2[0]\n if x1 > x2:\n x1, x2 = x2, x1\n chrom_pos = self.chrom_pos[chrom][0]\n\n newchrom = Region(chrom.species, chrom.seqname, chrom.feature, \n int(max(chrom.start + x1 - chrom_pos, 0)),\n int(min(chrom.start + x2 - chrom_pos, chrom.end)))\n\n print \"displaying region: %s:%s:%s-%s:%s\" % \\\n (newchrom.species, newchrom.seqname, \n util.int2pretty(newchrom.start),\n util.int2pretty(newchrom.end),\n [\"+\", \"+\", \"-\"][newchrom.strand])\n\n # create sub-browser\n subbrowser = GenomeOverview([newchrom],\n winpos=self.win.get_position(),\n winsize=self.win.get_size())\n\n for track_class, offset, args, kargs, tracks in self.metatracks:\n subbrowser.add_track(track_class, offset, *args, **kargs)\n \n subbrowser.show()","def drawIndex_region(t0, t1, t2, t3):\r\n get_pos0(t0)\r\n t0.fd(50)\r\n t0.pd()\r\n t0.pencolor(\"blue\")\r\n t0.write(\"Sub-Saharan Africa\", font=(\"Arial\", 10, \"bold\"))\r\n t1.rt(90)\r\n get_pos1(t1)\r\n t1.fd(50)\r\n t1.pd()\r\n t1.pencolor(\"red\")\r\n t1.write(\"South Asia\", font=(\"Arial\", 10, \"bold\"))\r\n get_pos2(t2)\r\n t2.fd(50)\r\n t2.pd()\r\n t2.pencolor(\"green\")\r\n t2.write(\"Europe and Central Asia\", font=(\"Arial\", 10, \"bold\"))\r\n get_pos3(t3)\r\n t3.fd(50)\r\n t3.pd()\r\n t3.pencolor(\"gold\")\r\n t3.write(\"Latin America & Caribbean\", font=(\"Arial\", 10, \"bold\"))\r\n t0.pu()\r\n t1.pu()\r\n t2.pu()\r\n t3.pu()\r\n t0.back(80)\r\n t0.pd()\r\n t0.pencolor(\"black\")\r\n t0.write(\"Middle East and North Africa\", font=(\"Arial\", 10, \"bold\"))\r\n t1.back(80)\r\n t1.pd()\r\n t1.pencolor(\"yellow\")\r\n t1.write(\"North America\", font=(\"Arial\", 10, \"bold\"))\r\n t2.back(80)\r\n t2.pd()\r\n t2.pencolor(\"purple\")\r\n t2.write(\"East Asia and Pacific\", font=(\"Arial\", 10, \"bold\"))\r\n t3.goto(initialCoordinates())\r\n t0.pu()\r\n t1.pu()\r\n t2.pu()\r\n t0.goto(initialCoordinates())\r\n t1.goto(initialCoordinates())\r\n t2.goto(initialCoordinates())\r\n t3.goto(initialCoordinates())","def river_region(rr_id):\n r = RiverRegionRenderer(request, rr_id, None)\n return r.render()","def update_help(self):\n if self.region_id is not None:\n controller.set_help_text(\"\"\"Drag to desired region width.<br/>\\n\n <b>R</b> to set the region<br/>\\n\n <b>D</b> to delete/cancel the current region<br/>\n <b>*</b> to extend to maximum on this side\n \"\"\")\n else:\n controller.set_help_text(\"\"\"<b> Edit Regions: </b><br/>\\n\n <b>R</b> to start a new region<br/>\\n\n <b>E</b> to edit nearest region<br/>\\n\n <b>D</b> to delete the nearest region\n \"\"\")","def _create_mid_region_frame(self):\n self.region_option = tk.StringVar()\n self.region_option.set(\"euw\")\n self.frames.append(tk.LabelFrame(self.master))\n self.option_menu = tk.OptionMenu(self.frames[5], self.region_option,\n \"euw\", \"na\", \"eune\")\n self.option_menu.grid(sticky=\"ew\")\n self.frames[5].grid(column=1, row=0, sticky=\"ns\", pady=10)\n self.frames[5].columnconfigure(0, weight=1)","def regions(self):\n return self._regions","def select_regions(data, region_col, regions, combine_subregions=True):","def showSS(self, show):\n\t\tfrom chimera.Sequence import defHelixColor, defStrandColor\n\t\thelixReg = self.getRegion(\"structure helices\", create=1,\n\t\t\t\tfill=(1.0, 1.0, 0.8), outline=defHelixColor)\n\t\tstrandReg = self.getRegion(\"structure strands\", create=1,\n\t\t\t\tfill=(0.8, 1.0, 0.8), outline=defStrandColor)\n\t\thelixReg.shown = show\n\t\tstrandReg.shown = show\n\t\tif not show:\n\t\t\treturn\n\t\thelixReg.clear(makeCB=False) # callback will happen in\n\t\tstrandReg.clear(makeCB=False) # addBlocks below\n\n\t\tassocSeqs = {}\n\t\thelices = []\n\t\tstrands = []\n\t\tfor aseq in self.seqCanvas.mav.associations.values():\n\t\t\tassocSeqs[aseq] = 1\n\t\tfor aseq in assocSeqs.keys():\n\t\t\tinHelix = inStrand = 0\n\t\t\tfor pos in range(len(aseq.ungapped())):\n\t\t\t\tisHelix = isStrand = 0\n\t\t\t\tfor matchMap in aseq.matchMaps.values():\n\t\t\t\t\ttry:\n\t\t\t\t\t\tres = matchMap[pos]\n\t\t\t\t\texcept KeyError:\n\t\t\t\t\t\tcontinue\n\t\t\t\t\tif res.isHelix:\n\t\t\t\t\t\tisHelix = 1\n\t\t\t\t\telif res.isStrand:\n\t\t\t\t\t\tisStrand = 1\n\t\t\t\tgapped = aseq.ungapped2gapped(pos)\n\t\t\t\tif isHelix:\n\t\t\t\t\tif inHelix:\n\t\t\t\t\t\thelices[-1][-1] = gapped\n\t\t\t\t\telse:\n\t\t\t\t\t\thelices.append([aseq, aseq,\n\t\t\t\t\t\t\t\tgapped, gapped])\n\t\t\t\t\t\tinHelix = 1\n\t\t\t\telse:\n\t\t\t\t\tif inHelix:\n\t\t\t\t\t\tinHelix = 0\n\t\t\t\tif isStrand:\n\t\t\t\t\tif inStrand:\n\t\t\t\t\t\tstrands[-1][-1] = gapped\n\t\t\t\t\telse:\n\t\t\t\t\t\tstrands.append([aseq, aseq,\n\t\t\t\t\t\t\t\tgapped, gapped])\n\t\t\t\t\t\tinStrand = 1\n\t\t\t\telse:\n\t\t\t\t\tif inStrand:\n\t\t\t\t\t\tinStrand = 0\n\t\thelixReg.addBlocks(helices)\n\t\tstrandReg.addBlocks(strands)","def whitelist_regions(self):\n return getattr(self, '_do_whitelist_regions', False)","def __repr__(self: RcnRegion) -> str:\n return f\"RcnRegion.{self.name}\"","def main(self, _):\n all_addresses = find_addresses.probe_regions()\n\n print(\"\")\n if not all_addresses:\n print(\"No namespace elastic IP addresses found.\")\n\n for region in consts.REGIONS:\n region_addresses = [address for address in all_addresses\n if address['region'] == region]\n if not region_addresses:\n continue\n\n print(f\"{region}: {len(region_addresses)} address(es) found:\")\n for address in region_addresses:\n if 'instance_name' in address:\n print(f\" {address['ip']} ({address['instance_name']})\")\n elif 'association_id' in address:\n print(f\" {address['ip']} (unknown association)\")\n else:\n print(f\" {address['ip']} (not associated)\")","def __init__(self, region):\r\n self.region = region","def display(self):\r\n if self.invisible and not self.highlighted:\r\n return\r\n \r\n loc = self.loc\r\n SlTrace.lg(\"edge: %s\" % str(loc), \"display\")\r\n if self.highlighted:\r\n if self.turned_on:\r\n if self.on_highlighting:\r\n c1x,c1y,c3x,c3y = self.get_rect(enlarge=True)\r\n self.highlight_tag = self.sel_area.canvas.create_rectangle(\r\n c1x, c1y, c3x, c3y,\r\n fill=SelectPart.edge_fill_highlight)\r\n else:\r\n if self.off_highlighting:\r\n c1x,c1y,c3x,c3y = self.get_rect(enlarge=True)\r\n self.highlight_tag = self.sel_area.canvas.create_rectangle(\r\n c1x, c1y, c3x, c3y,\r\n fill=SelectPart.edge_fill_highlight)\r\n else:\r\n self.display_clear()\r\n c1x, c1y, c3x, c3y = self.get_rect()\r\n self.display_tag = self.sel_area.canvas.create_rectangle(\r\n c1x, c1y, c3x, c3y,\r\n fill=self.color)\r\n if SlTrace.trace(\"show_id\"):\r\n dir_x, dir_y = self.edge_dxy()\r\n chr_w = 5\r\n chr_h = chr_w*2\r\n if dir_x != 0: # sideways\r\n offset_x = -len(str(self.id))*chr_w/2 + chr_w\r\n offset_y = chr_h\r\n if dir_y != 0: # up/down\r\n offset_x = len(str(self.id))*chr_w\r\n offset_y = 0 \r\n \r\n cx = (c1x+c3x)/2 + offset_x\r\n cy = (c1y+c3y)/2 + offset_y\r\n self.name_tag = self.display_text((cx, cy), text=str(self.id))","def onLoadSegmentationButton(self):\n inputVolume = self.inputSelector.currentNode()\n segmentationFile = self.segmentationsPath + self.segmentationFilesComboBox.currentText\n \n loadedSegmentationVolumeNode = slicer.util.loadVolume(segmentationFile)\n voxels = slicer.util.arrayFromVolume(loadedSegmentationVolumeNode)\n imgLabel = np.copy(voxels)\n \n tmpVoxels = np.copy(voxels)\n tmpVoxels[:] = imgLabel[:]\n \n slicer.util.updateVolumeFromArray(loadedSegmentationVolumeNode, tmpVoxels)\n \n removeLastSegmentation = self.removeLastSegmentationCheckBox.isChecked() \n showBackGround = self.showBackGroundCheckBox.isChecked()\n displaySegmentationMap(loadedSegmentationVolumeNode, imgLabel, self.labelColorsList, removeLastSegmentation, showBackGround)\n \n slicer.util.setSliceViewerLayers(background=inputVolume)","def __str__(self):\n return \"Region: \" + self.name + \" with parent \" + self.parent + \" and self code \" + self.FHIRCode","def helptext(self):\n return \"\"\"<b> Edit Regions </b> <br/>\\n\n <b>R</b> to start a new region or set the edge if editing<br/>\\n\n <b>E</b> to edit nearest region<br/>\\n\n <b>D</b> to delete/cancel the current/nearest region\n \"\"\"","def list_regions():\n regions_areas = (\n db.session.query(\n models.Region.code.label(\"region_code\"),\n models.Region.name.label(\"region_name\"),\n db.case([(models.District.code.is_(None),\n db.literal_column(\"'admin_area'\"))],\n else_=db.literal_column(\"'district'\")).label(\"area_type\"),\n db.case([(models.District.code.is_(None), models.AdminArea.code)],\n else_=models.District.code).label(\"area_code\"),\n db.case([(models.District.code.is_(None), models.AdminArea.name)],\n else_=models.District.name).label(\"area_name\")\n ).select_from(models.Region)\n .join(models.Region.areas)\n .outerjoin(models.AdminArea.districts)\n .filter(models.Region.code != \"GB\")\n .order_by(\"region_name\", \"area_name\")\n .all()\n )\n regions = {}\n areas = {}\n for row in regions_areas:\n regions[row.region_code] = row.region_name\n areas.setdefault(row.region_code, []).append(row)\n\n return render_template(\"regions.html\", regions=regions, areas=areas)","def create_panel_custom_regions():\n panel_id = request.json[\"panel_id\"]\n chrom = request.json[\"chrom\"]\n start = request.json[\"start\"]\n end = request.json[\"end\"]\n name = request.json[\"name\"]\n regions = select_region_by_location(s, chrom, start, end) # if region already exists, return current entry\n if regions:\n for i in regions:\n add_region_to_panel(s, i.id, panel_id)\n s.commit()\n continue\n else:\n create_custom_region(s, panel_id, chrom, start, end, name)\n\n return jsonify(\"complete\")","def ffgs_regions():\n return [\n ('Hispaniola', 'hispaniola'),\n ('Central America', 'centralamerica')\n ]","def delete_this_region(self):","def __highlight_region_cmd(region_list):\n assert( (isinstance(region_list, list) or isinstance(region_list, tuple)) and len(region_list) >= 1 )\n assert( isinstance(region_list[0], list) or isinstance(region_list[0], tuple) )\n CMD = '-highlightRegion \"'\n for region in region_list:\n if len(region) == 2:\n CMD += \"%s-%s:fill=%s,outline=#FFFFFF,radius=15;\" % (region[0], region[1], \"00FF00\")\n else:\n CMD += \"%s-%s:fill=%s,outline=#FFFFFF,radius=15;\" % (region[0], region[1], region[2])\n CMD += '\"'\n return CMD","def filter_regions(self):\n return self.filter_nodes('/DistrictBuilder/Regions/Region')","def display(self):\n map_show = self.map.copy()\n map_show[self.currY, self.currX] = 4 \n print(map_show)","def handle(self, args):\n\n # Load the regions for the sg command\n regions = Regions.load()\n\n # Filter regions specified\n args.regions = set(args.regions)\n if \"all\" not in args.regions:\n regions = Regions(\n region for region in regions\n if str(region) in args.regions\n )\n\n results = wait(\n (partial(self.handle_region, region) for region in regions),\n args=(args,))\n\n table = [['', 'Region', 'Notes']] + results\n print(tabulate(table, tablefmt=args.tablefmt, headers='firstrow'))","def ReadRegions(self, fname=\"temp\"):\n self.fname = fname\n command = \"\"\"IPython.notebook.kernel.execute('file = open(\"temp\", \"w\"); [file.write(x[\"wcsstr\"]) for x in '+ JSON.stringify(JS9.GetShapes(\"regions\", {{display: '{wid}JS9'}})) +']; file.close()');\"\"\".format(wid=self.wid)\n get_ipython().run_cell_magic('javascript', '', command)","def handle(self, args):\n args.regions = set(args.regions)\n regions = Regions(\n region for region in Regions.load()\n if str(region) in args.regions\n )\n\n results = wait(\n (partial(self.handle_region, region) for region in regions),\n args=(args,))\n\n table = [['', 'Region', 'Notes']] + results\n print(tabulate(table, tablefmt=args.tablefmt, headers='firstrow'))","def add_region(self, position):\n region = self.region_selector(position)\n self.regions[id(region)] = region","def show_map(self):\n self.m1.display()","def nine_regions(self):\n\n coordinateList = []\n\n # Top left.\n x = (int)( self.oriImgSize[IDX_WIDTH] * self.ratioTopLeft[IDX_X] )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * self.ratioTopLeft[IDX_Y] )\n coordinateList.append( [x, y] )\n\n # Top center.\n x = (int)( self.oriImgSize[IDX_WIDTH] * 0.5 - self.regionSize[IDX_WIDTH] / 2 )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * self.ratioTopLeft[IDX_Y] ) \n coordinateList.append( [x, y] )\n\n # Top right.\n x = (int)( self.oriImgSize[IDX_WIDTH] * ( 1.0 - self.ratioTopLeft[IDX_X] ) - self.regionSize[IDX_WIDTH] )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * self.ratioTopLeft[IDX_Y] )\n coordinateList.append( [x, y] )\n\n # Center left.\n x = (int)( self.oriImgSize[IDX_WIDTH] * self.ratioTopLeft[IDX_X] )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * 0.5 - self.regionSize[IDX_HEIGHT] / 2 )\n coordinateList.append( [x, y] )\n\n # Center.\n x = (int)( self.oriImgSize[IDX_WIDTH] * 0.5 - self.regionSize[IDX_WIDTH] / 2 )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * 0.5 - self.regionSize[IDX_HEIGHT] / 2 )\n coordinateList.append( [x, y] )\n\n # Center right.\n x = (int)( self.oriImgSize[IDX_WIDTH] * (1.0 - self.ratioTopLeft[IDX_X]) - self.regionSize[IDX_WIDTH] )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * 0.5 - self.regionSize[IDX_HEIGHT] / 2 )\n coordinateList.append( [x, y] )\n\n # Bottom left.\n x = (int)( self.oriImgSize[IDX_WIDTH] * self.ratioTopLeft[IDX_X] )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * (1.0 - self.ratioTopLeft[IDX_Y]) - self.regionSize[IDX_HEIGHT] )\n coordinateList.append( [x, y] )\n\n # Bottom center.\n x = (int)( self.oriImgSize[IDX_WIDTH] * 0.5 - self.regionSize[IDX_WIDTH] / 2 )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * (1.0 - self.ratioTopLeft[IDX_Y]) - self.regionSize[IDX_HEIGHT] )\n coordinateList.append( [x, y] )\n\n # Bottom right.\n x = (int)( self.oriImgSize[IDX_WIDTH] * (1.0 - self.ratioTopLeft[IDX_X]) - self.regionSize[IDX_WIDTH] )\n y = (int)( self.oriImgSize[IDX_HEIGHT] * (1.0 - self.ratioTopLeft[IDX_Y]) - self.regionSize[IDX_HEIGHT] )\n coordinateList.append( [x, y] )\n\n return coordinateList","def regions(self) -> Sequence[str]:\n return pulumi.get(self, \"regions\")","def area(self):\n ...","def LoadRegions(self, fname='js9.reg'):\n self.fname=fname\n command = \"JS9.LoadRegions('{fname}', {{display:'{wid}JS9'}})\".format(fname=fname, wid=self.wid)\n get_ipython().run_cell_magic('javascript', '', command)","def changeSubdivRegion(*args, action: int=0, level: int=0, **kwargs)->bool:\n pass","def state_preview_enter(cfg, app, win):","def update_zoom_region(self):\n self.linear_region.setRegion(self.plot_zoom.getViewBox().viewRange()[0])","def show(self):\r\n display(self.grid_part)","def initial_representations():\n cmd.hide('everything', 'all')\n cmd.show('cartoon', 'all')\n cmd.select('ligand', 'resn NFT')\n cmd.deselect()\n cmd.show(\"sticks\", \"ligand\")","def update_resistance_region(self):\n self.linear_region.setRegion(\n self.resistance_graph.getViewBox().viewRange()[0])","def region(self):\n return [node.region for node in self]","def test_center_region(self):\n before_b = \"\"\"\\\n Some 90% of all presidentially declared disasters are weather related,\n leading to around 500 deaths per year and nearly $14 billion in damage.\n StormReady, a program started in 1999 in Tulsa, OK,\n helps arm America's communities with the communication and safety\n skills needed to save lives and property– before and during the event.\n StormReady helps community leaders and emergency managers strengthen local safety programs.\n \"\"\"\n after_b = \"\"\"\\\n Some 90% of all presidentially declared disasters are weather related,\n leading to around 500 deaths per year and nearly $14 billion in damage.\n StormReady, a program started in 1999 in Tulsa, OK,\n helps arm America's communities with the communication and safety\n skills needed to save lives and property– before and during the event.\n StormReady helps community leaders and emergency managers strengthen local safety programs.\n \"\"\"\n self.run_test(\n before_b=before_b,\n after_b=after_b,\n before_sel=(\"1.0\", \"7.0\"),\n after_sel=(\"1.0\", \"7.0\"),\n command_name=\"center-region\",\n directives=\"@pagewidth 70\",\n )","def update_plots_using_region(self):\n self.frequency_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.resistance_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.temperature_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.pressure_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.humidity_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)","def draw_region(self, constraint, agent):\n if (constraint == self.obstacles) and (self.obstacles[agent] is not None):\n for area in self.obstacles[agent]:\n x_min, x_max = area[0][0], area[0][1]\n y_min, y_max = area[1][0], area[1][1]\n rectangle = plt.Rectangle((x_min, y_min), x_max - x_min, y_max - y_min, fc='k', ec=\"k\")\n plt.gca().add_patch(rectangle)\n elif (constraint == self.observation_areas) and (self.observation_areas[agent] is not None):\n for observation_area in self.observation_areas[agent]:\n x_min, x_max = observation_area.region[0][0], observation_area.region[0][1]\n y_min, y_max = observation_area.region[1][0], observation_area.region[1][1]\n rectangle = plt.Rectangle((x_min, y_min), x_max - x_min, y_max - y_min, fc='c', ec=\"c\", alpha=0.5)\n plt.gca().add_patch(rectangle)\n\n plt.xlim(self.Xi[0])\n plt.ylim(self.Xi[1])","def mark_regions_image(self, image, stats):\n detector = cv2.SimpleBlobDetector_create()\n keypoints = detector.detect(image)\n output = cv2.drawKeypoints(image, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\n cv2.namedWindow(\"marks\", cv2.WINDOW_AUTOSIZE)\n cv2.imshow(\"marks\", output)\n cv2.waitKey(0)\n cv2.destroyWindow(\"marks\")\n return output","def createSubdivRegion(*args, **kwargs)->bool:\n pass","def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\n #Read in the image that is segmented/labelled for nuclei\n img=imread(img_dir)\n\n #save plots to show clusters\n fig = plt.figure(figsize=(6, 2))\n ax0 = fig.add_subplot(131)\n ax1 = fig.add_subplot(132)\n ax3 = fig.add_subplot(133)\n #show segmented image labels\n ax0.imshow(img,aspect='auto') \n ax0.axis('off')\n #nuclear centroid color-coded by their orientation\n img1=ax1.scatter(data[\"Y\"], data[\"X\"], c=data[\"angles\"],s=1)\n ax1.set_xlim(0,img.shape[0])\n ax1.set_ylim(img.shape[1],0)\n plt.colorbar(img1)\n ax1.axis('off')\n\n # plot the cluster assignments\n img3=ax3.scatter(data[data[\"clusters\"]> -1][\"Y\"], data[data[\"clusters\"]> -1][\"X\"], \n c=data[data[\"clusters\"]> -1][\"clusters\"],cmap=\"plasma\",s=1)\n ax3.set_xlim(0,img.shape[0])\n ax3.set_ylim(img.shape[1],0)\n ax3.axis('off')\n\n #add titles\n ax0.title.set_text('Segmented Image')\n ax1.title.set_text('Filtered Orientation')\n ax3.title.set_text('Clusters')\n\n if display_not_save:\n plt.show()\n else: \n plt.savefig((output_dir+\"/\"+img_dir.rsplit('/', 1)[-1][:-4]+\"_\"+str(dbscn_length)+\"_\"+ str(dbscn_min_size)+\".png\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\n fig.clf()\n plt.close(fig)\n plt.close('all')\n \n \n del fig,ax0,ax1,ax3,img1,img3","def _index(self):\n bFirstCall = super(PageXmlSeparatorRegion, self)._index()\n \n if bFirstCall:\n # indexing was required\n # , so first call\n # , so we need to make the computation of edges crossing separators!\n self.addSeparatorFeature()","def regions(self) -> pulumi.Output[Sequence[str]]:\n return pulumi.get(self, \"regions\")","def drawCoordinatePlane_region():\r\n turtle2 = t.Screen()\r\n turtle2.title(\"Life Expectancy versus Region\")\r\n t2.speed(0)\r\n t3.speed(0)\r\n setTurtle(t0)\r\n setTurtle(t1)\r\n setTurtle(t2)\r\n setTurtle(t3)\r\n drawAxes(t0)\r\n t1.left(90)\r\n drawAxes(t1)\r\n t0.pu()\r\n t0.fd(-80)\r\n t0.lt(90)\r\n drawlabels(t0, t1)\r\n drawPoints(t0, t1)\r\n t0.pu()\r\n t1.pu()\r\n t2.pu()\r\n t3.pu()\r\n t0.goto(initialCoordinates())\r\n t1.goto(initialCoordinates())\r\n t2.goto(initialCoordinates())\r\n t3.goto(initialCoordinates())\r\n t1.lt(90)","def find_hetero_regions(M_original, P_original, plotshow=True, figsize=(20,1)):\n hetero = M_original != P_original\n regions_bounds = np.concatenate([[0], np.where(hetero[:-1] != hetero[1:])[0]+1, [len(hetero)]])\n regions = []\n for b, begin in enumerate(regions_bounds[:-1]):\n if hetero[begin]:\n regions.append(np.arange(regions_bounds[b], regions_bounds[b+1]))\n\n if plotshow:\n\n print(\"Haplotypes (true labels):\")\n plot_haplo(M_original,P_original,figsize=figsize)\n plt.show()\n\n plt.figure(figsize=figsize)\n cols = np.concatenate([[r]*len(regions[r]) for r in range(len(regions))])\n plt.scatter(np.concatenate(regions), [1]*len(np.concatenate(regions)), c=cols, cmap=\"Accent\")\n plt.scatter(regions_bounds, [1]*len(regions_bounds), color=\"red\")\n plt.yticks([], [])\n plt.title(\"Heterozygous Regions\")\n plt.show()\n \n return regions","def select_proper_region(self):\n # Click the desired region\n region = self.driver.find_element_by_css_selector(web_map[self.region][button_path])\n region.click()\n time.sleep(1)\n\n try:\n search = self.driver.find_element_by_css_selector(go_to_search)\n search.click()\n time.sleep(1)\n return True\n except NoSuchElementException:\n # This means that the information of this autonomous community is not available\n # at this version\n return False","def get_region_dropdown(mode):\n print(mode)\n if mode == SelectionMode.Continents.value:\n return {'display': 'none'}, {'display': 'block'}, {'display': 'none'}\n elif mode == SelectionMode.Countries.value:\n return {'display': 'none'}, {'display': 'none'}, {'display': 'block'}\n \n return {'height': '35px'}, {'display': 'none'}, {'display': 'none'}","def area(self):","def update_temperature_region(self):\n self.linear_region.setRegion(\n self.temperature_plot_graph.getViewBox().viewRange()[0])","def regions(self):\n\n class RegionIter(object):\n def __init__(self, region_based):\n self._region_based = region_based\n\n def __len__(self):\n return self._region_based._region_len()\n\n def __iter__(self):\n return self()\n\n def _fix_chromosome(self, regions):\n for r in regions:\n r.fix_chromosome(copy=True)\n\n def __call__(self, key=None, *args, **kwargs):\n fix_chromosome = kwargs.pop('fix_chromosome', False)\n\n if key is None:\n iterator = self._region_based._region_iter(*args, **kwargs)\n else:\n if isinstance(key, string_types) or isinstance(key, GenomicRegion):\n iterator = self._region_based.region_subset(key, *args, **kwargs)\n else:\n iterator = self._region_based._get_regions(key, *args, **kwargs)\n\n if fix_chromosome:\n return self._fix_chromosome(iterator)\n else:\n return iterator\n\n def __getitem__(self, item):\n if isinstance(item, string_types) or isinstance(item, GenomicRegion):\n return self._region_based.region_subset(item)\n return self._region_based._get_regions(item)\n\n return RegionIter(self)","def to_region(self):\n\n coords = self.convert_coords()\n log.debug(coords)\n viz_keywords = ['color', 'dash', 'dashlist', 'width', 'font', 'symsize',\n 'symbol', 'symsize', 'fontsize', 'fontstyle', 'usetex',\n 'labelpos', 'labeloff', 'linewidth', 'linestyle',\n 'point', 'textangle', 'fontweight']\n\n if isinstance(coords[0], SkyCoord):\n reg = self.shape_to_sky_region[self.region_type](*coords)\n elif isinstance(coords[0], PixCoord):\n reg = self.shape_to_pixel_region[self.region_type](*coords)\n else:\n self._raise_error(\"No central coordinate\")\n\n reg.visual = RegionVisual()\n reg.meta = RegionMeta()\n\n # both 'text' and 'label' should be set to the same value, where we\n # default to the 'text' value since that is the one used by ds9 regions\n label = self.meta.get('text',\n self.meta.get('label', \"\"))\n if label != '':\n reg.meta['label'] = label\n for key in self.meta:\n if key in viz_keywords:\n reg.visual[key] = self.meta[key]\n else:\n reg.meta[key] = self.meta[key]\n reg.meta['include'] = self.include\n return reg","def __editShowCodeInfo(self):\n self.showEditorInfo(self.activeWindow())","def displaySegmentationMap(inputVolume, segmentationMap, labelColorsList, removeLastSegmentation, showBackGround): \n # Remove last segmentation, including 3D representation\n if removeLastSegmentation:\n countSegmentationNode = slicer.mrmlScene.GetNumberOfNodesByClass(\"vtkMRMLSegmentationNode\")\n if countSegmentationNode > 0:\n slicer.mrmlScene.RemoveNode( slicer.mrmlScene.GetNthNodeByClass(countSegmentationNode-1, \"vtkMRMLSegmentationNode\") )\n \n segmentationNode = slicer.mrmlScene.AddNewNodeByClass(\"vtkMRMLSegmentationNode\")\n segmentationNode.CreateDefaultDisplayNodes()\n segmentationNode.SetReferenceImageGeometryParameterFromVolumeNode(inputVolume)\n \n segmentationNode.RemoveClosedSurfaceRepresentation()\n\n # Create segment editor to get access to effects\n segmentEditorWidget = slicer.qMRMLSegmentEditorWidget()\n segmentEditorWidget.setMRMLScene(slicer.mrmlScene)\n segmentEditorNode = slicer.mrmlScene.AddNewNodeByClass(\"vtkMRMLSegmentEditorNode\")\n segmentEditorWidget.setMRMLSegmentEditorNode(segmentEditorNode)\n segmentEditorWidget.setSegmentationNode(segmentationNode)\n segmentEditorWidget.setMasterVolumeNode(inputVolume)\n \n for i in range(len(labelColorsList)):\n addedSegmentID = segmentationNode.GetSegmentation().AddEmptySegment(labelColorsList[i][0])\n segmentationNode.GetSegmentation().GetSegment(addedSegmentID).SetColor(labelColorsList[i][1])\n segmentEditorWidget.setCurrentSegmentID(addedSegmentID)\n \n # Thresholding\n segmentEditorWidget.setActiveEffectByName(\"Threshold\")\n effect = segmentEditorWidget.activeEffect()\n thresh = i+1\n effect.setParameter(\"MinimumThreshold\", str(clip(thresh, 0, 255)))\n effect.setParameter(\"MaximumThreshold\", str(clip(thresh, 0, 255)))\n effect.self().onApply()\n\n if (not showBackGround) and (i == len(labelColorsList) - 1):\n segmentationNode.GetDisplayNode().SetSegmentVisibility (addedSegmentID, False)\n\n # print 3D representation\n segmentationNode.CreateClosedSurfaceRepresentation()","def _process_region(self, region, writer):","def __setNonTabAreaItemsFromRegionHidden(self,area, view):\r\n x,y,w,h = area\r\n\r\n # Loop through all objects on screen and remove ones which are completely covered by given area and are not in same container as area\r\n for node in view.findall('/*[@center and @is-in-tab-area=\"false\"]'):\r\n nodeX, nodeY, nodeW, nodeH = [int(p) for p in node.getAttribute('coords').split(\",\")]\r\n if nodeX>x and (nodeX+nodeW)<(x+w) and nodeY>y and (nodeY+nodeH)<(y+h):\r\n if node.getName()=='label':\r\n debug.out(\"Removing node %s(%s,%s,%s,%s) from area %s,%s,%s,%s\"%(node.getAttribute(\"text\"),nodeX, nodeY,nodeW,nodeH,x,y,w,h))\r\n\r\n node.setAttribute(\"visible\",\"hidden\")\r\n return view","def visualise():\n\n column = request.form.getlist('columnName')\n regions = request.form.getlist('raw_regions')\n #take the single string and return a list\n regions = query_proc.prep_regions(regions)\n #get that tables of interst\n table = query_proc.column_to_table(column)\n\n var_data = query_proc.get_region_data(table, column, regions)\n minval = query_proc.get_region_data_min(table, column, regions)\n maxval = query_proc.get_region_data_max(table, column, regions)\n\n #column diction to get human fiendly designation\n column_dict = name_column.get_name_column_dict()\n real_column = column_dict[column[0]]\n\n\n ##packing for the template\n region = regions[0]\n min_max = [minval, maxval]\n step = query_proc.calc_steps(min_max)\n min_max.append(step)\n\n min_max = json.dumps(min_max)\n json_vardata = json.dumps(var_data)\n\n return render_template('visualise.html',\n title='Data on a Map!',\n column=column,\n real_column=real_column,\n region=region,\n min_max=min_max,\n json_vardata=json_vardata)","def updateDisplay(self):\n\t\tregion = braille.handler.mainBuffer.regions[-1] if braille.handler.mainBuffer.regions else None\n\t\tif isinstance(region, braille.TextInfoRegion):\n\t\t\tbraille.handler._doCursorMove(region)","def displayNative(self):\n\n\t\tcmd.hide(\"lines\", \"native\")\n\t\tcmd.color(\"gray\", \"native & name CA\")\n\t\t#cmd.zoom(\"nearby\")","def generate_level(self):\n for _ in range(AMOUNT_REGIONS_TO_DRAW):\n self._generate_next_blocks()","def run(self):\n\n self.window.run_command(\"show_panel\", {\"panel\": \"output.reg_replace\"})","def getRegionPlotList(self, lRegions, bBorder = False):\n\t\t\n\t\tplotList = []\n\t\tfor x in range(con.iMapWidth):\n\t\t\tfor y in range(con.iMapHeight):\n\t\t\t\tif gc.getMap().plot(x, y).getRegionID() in lRegions:\n\t\t\t\t\tif not bBorder:\n\t\t\t\t\t\tplotList.append((x, y))\n\t\t\t\t\telse:\n\t\t\t\t\t\tfor x2 in range(x-1, x+2):\n\t\t\t\t\t\t\tfor y2 in range(y-1, y+2):\n\t\t\t\t\t\t\t\tif (x2, y2) not in plotList: plotList.append((x2, y2))\n\t\t\n\t\treturn plotList","def region_graph(t0, t1, t2, t3):\r\n medians0 = sorted(sub_saharan_africa_countries())\r\n t0.goto(-250, ((medians0[0])-50))\r\n t0.rt(90)\r\n for idx in range(1, len(medians0)):\r\n t0.pencolor(\"blue\")\r\n t0.pd()\r\n t0.setpos((-250+(idx*10.5)), ((medians0[idx])))\r\n\r\n medians1 = sorted(south_asia_countries())\r\n t1.goto(-250, ((medians1[0]) - 60))\r\n t1.rt(90)\r\n for idx in range(1, len(medians1)):\r\n t1.pencolor(\"red\")\r\n t1.pd()\r\n t1.setpos((-250 + (idx * 68.5)), (2*(medians1[idx])+10))\r\n\r\n medians2 = sorted(europe_central_asia_countries())\r\n t2.goto(-250, (medians2[0])+60)\r\n t2.rt(90)\r\n for idx in range(1, len(medians2)):\r\n t2.pencolor(\"green\")\r\n t2.pd()\r\n t2.setpos((-250 + (idx*10.19)), (2 * (medians2[idx]) + 10))\r\n\r\n medians3 = sorted(latin_america_countries())\r\n t3.goto(-250, (medians3[0]) + 20)\r\n t3.rt(90)\r\n for idx in range(1, len(medians3)):\r\n t3.pencolor(\"gold\")\r\n t3.pd()\r\n t3.setpos((-250 + (idx * 14.39)), (2 * (medians3[idx]) + 10))\r\n\r\n t0.pu()\r\n t0.goto(initialCoordinates())\r\n t1.pu()\r\n t1.goto(initialCoordinates())\r\n t2.pu()\r\n t2.goto(initialCoordinates())\r\n t3.pu()\r\n t3.goto(initialCoordinates())\r\n\r\n medians4 = sorted(middle_east_countries())\r\n t0.goto(-250, (medians4[0])-40)\r\n t0.rt(90)\r\n for idx in range(1, len(medians4)):\r\n t0.pencolor(\"BLACK\")\r\n t0.pd()\r\n t0.setpos((-250 + (idx * 26.3)), (2 * (medians4[idx]) + 10))\r\n t0.rt(180)\r\n\r\n medians5 = sorted(north_america_countries())\r\n t1.goto(-250, (medians5[0])+60)\r\n t1.rt(90)\r\n for idx in range(1, len(medians5)):\r\n t1.pencolor(\"YELLOW\")\r\n t1.pd()\r\n t1.setpos((-250 + (idx * 485.3)), (2 * (medians5[idx]) + 10))\r\n t1.rt(180)\r\n\r\n medians6 = sorted(east_asia_pacific_countries())\r\n t2.goto(-250, (medians6[0]))\r\n t2.rt(90)\r\n for idx in range(1, len(medians6)):\r\n t2.pencolor(\"purple\")\r\n t2.pd()\r\n t2.setpos((-250 + (idx * 16)), (2 * (medians6[idx]) + 10))\r\n t0.pu()\r\n t0.goto(initialCoordinates())\r\n t1.pu()\r\n t1.goto(initialCoordinates())\r\n t2.pu()\r\n t2.goto(initialCoordinates())","def show(self):\r\n wlight.lightController.redraw()","def dump(self, contents=False):\n print(self)\n for region in self.regions:\n print(region)\n hexdump(region.data, address=region.address)","def __init__(self, *args, **kwargs):\n _gdi_.RegionIterator_swiginit(self,_gdi_.new_RegionIterator(*args, **kwargs))","def show_editor(self):\r\n self.frame.Show()\r\n self.frame.Raise()","def get_regions(self):\n return self._regions","def AddRegions(self, **kwargs):\n # Addregions use pixel coordinates. listRegions and SaveRegions use RA and Dec.\n n_objs = 0\n objs = []\n # default shape is circle\n if not 'shape' in kwargs:\n kwargs['shape'] = ['circle']\n for k in kwargs.keys():\n n_objs = max(n_objs, len(kwargs[k]))\n for j in range(n_objs):\n temp = {}\n for k in kwargs.keys():\n try:\n temp[k] = kwargs[k][j]\n except IndexError:\n if k == 'shape': \n temp[k] = 'circle'\n objs.append(temp)\n self.all_objs = json.dumps(objs)\n command = \"JS9.AddRegions({objs}, {{display:'{wid}{suffix}'}})\".format(objs=self.all_objs, wid=self.wid, suffix=self.suffix)\n get_ipython().run_cell_magic('javascript', '', command)","def closeRegions(regions):\n for orig,table in regions.items():\n for dest in table['neighbors']:\n if not regions.has_key(dest):\n regions[dest] = {'neighbors': set(),\n 'value': 4}\n regions[dest]['neighbors'].add(orig)\n return regions","def show_custom_graph(self):\n pass","def draw_pins():\n\n pass","def __init__(self, machine):\n super().__init__(machine)\n self.features['has_segment_displays'] = True","def selected(self):\n\t\treturn [self.regions[int(i)]\n\t\t\tfor i in self.regionListing.hlist.info_selection()]","def GetRegionVertices(self, *float, **kwargs):\n ...","def onShow(self):\n pass"],"string":"[\n \"def render_regions(view=None):\\r\\n # Get current active view\\r\\n if view is None:\\r\\n view = sublime.active_window().active_view()\\r\\n # Unable to set regions when no view available\\r\\n if view is None:\\r\\n return\\r\\n\\r\\n # Do no set regions if view is empty or still loading\\r\\n if view.size() == 0 or view.is_loading():\\r\\n return\\r\\n\\r\\n # Remove all markers to avoid marker conflict\\r\\n view.erase_regions(S.REGION_KEY_BREAKPOINT)\\r\\n view.erase_regions(S.REGION_KEY_CURRENT)\\r\\n view.erase_regions(S.REGION_KEY_DISABLED)\\r\\n\\r\\n # Get filename of current view and check if is a valid filename\\r\\n filename = view.file_name()\\r\\n if not filename:\\r\\n return\\r\\n\\r\\n # Determine icon for regions\\r\\n icon_current = get_region_icon(S.KEY_CURRENT_LINE)\\r\\n icon_disabled = get_region_icon(S.KEY_BREAKPOINT_DISABLED)\\r\\n icon_enabled = get_region_icon(S.KEY_BREAKPOINT_ENABLED)\\r\\n\\r\\n # Get all (disabled) breakpoint rows (line numbers) for file\\r\\n breakpoint_rows = []\\r\\n disabled_rows = []\\r\\n if filename in S.BREAKPOINT and isinstance(S.BREAKPOINT[filename], dict):\\r\\n for lineno, bp in S.BREAKPOINT[filename].items():\\r\\n # Do not show temporary breakpoint\\r\\n if S.BREAKPOINT_RUN is not None and S.BREAKPOINT_RUN['filename'] == filename and S.BREAKPOINT_RUN['lineno'] == lineno:\\r\\n continue\\r\\n # Determine if breakpoint is enabled or disabled\\r\\n if bp['enabled']:\\r\\n breakpoint_rows.append(lineno)\\r\\n else:\\r\\n disabled_rows.append(lineno)\\r\\n\\r\\n # Get current line from breakpoint hit\\r\\n if S.BREAKPOINT_ROW is not None:\\r\\n # Make sure current breakpoint is in this file\\r\\n if filename == S.BREAKPOINT_ROW['filename']:\\r\\n # Remove current line number from breakpoint rows to avoid marker conflict\\r\\n if S.BREAKPOINT_ROW['lineno'] in breakpoint_rows:\\r\\n breakpoint_rows.remove(S.BREAKPOINT_ROW['lineno'])\\r\\n # Set icon for current breakpoint\\r\\n icon_breakpoint_current = get_region_icon(S.KEY_BREAKPOINT_CURRENT)\\r\\n if icon_breakpoint_current:\\r\\n icon_current = icon_breakpoint_current\\r\\n if S.BREAKPOINT_ROW['lineno'] in disabled_rows:\\r\\n disabled_rows.remove(S.BREAKPOINT_ROW['lineno'])\\r\\n # Set current line marker\\r\\n if icon_current:\\r\\n view.add_regions(S.REGION_KEY_CURRENT, rows_to_region(S.BREAKPOINT_ROW['lineno']), S.REGION_SCOPE_CURRENT, icon_current, sublime.HIDDEN)\\r\\n\\r\\n # Set breakpoint marker(s)\\r\\n if breakpoint_rows and icon_enabled:\\r\\n view.add_regions(S.REGION_KEY_BREAKPOINT, rows_to_region(breakpoint_rows), S.REGION_SCOPE_BREAKPOINT, icon_enabled, sublime.HIDDEN)\\r\\n if disabled_rows and icon_disabled:\\r\\n view.add_regions(S.REGION_KEY_DISABLED, rows_to_region(disabled_rows), S.REGION_SCOPE_BREAKPOINT, icon_disabled, sublime.HIDDEN)\",\n \"def add_regions(self, regions, **options):\\n \\n options.setdefault(\\\"col\\\", color(0,0,1))\\n options.setdefault(\\\"style\\\", \\\"box\\\")\\n options.setdefault(\\\"height\\\", 0.5)\\n \\n return self.add_track(RegionTrack, -.5, regions, **options)\",\n \"def RegionList(self):\\n command = \\\"\\\"\\\"\\n IPython.notebook.kernel.execute(\\\"RegionList=\\\" + JSON.stringify(JS9.GetShapes(\\\"regions\\\", {{display: '{wid}JS9'}})));\\n \\\"\\\"\\\".format(wid=self.wid)\\n get_ipython().run_cell_magic('javascript', '', command)\",\n \"def draw_visible_area(self):\\n\\n if not self.given_center:\\n return\\n\\n # Figure out what regions we should be showing\\n horiz_width = self.hbar.pageStep()\\n gui_start_x = self.hbar.value()\\n vert_height = self.vbar.pageStep()\\n gui_start_y = self.vbar.value()\\n (game_min_x, game_max_y) = self.scene_to_ingame(gui_start_x, gui_start_y)\\n (game_max_x, game_min_y) = self.scene_to_ingame(\\n gui_start_x + horiz_width,\\n gui_start_y + vert_height,\\n )\\n min_rx = game_min_x//32 - 1\\n max_rx = game_max_x//32 + 1\\n min_ry = game_min_y//32 - 1\\n max_ry = game_max_y//32 + 1\\n\\n # First find out how many regions we're going to have to load (so that\\n # we can initialize a progressbar)\\n valid_regions = set()\\n regions_to_load = []\\n for rx in range(min_rx, max_rx+1):\\n for ry in range(min_ry, max_ry+1):\\n region = (rx, ry)\\n valid_regions.add(region)\\n if region in self.regions:\\n if not self.regions[region].loaded:\\n regions_to_load.append(region)\\n\\n # Initialize progressbar\\n region_loading = self.mainwindow.region_loading\\n region_loading.start(len(regions_to_load))\\n\\n # Now actually do the loading\\n for idx, region in enumerate(regions_to_load):\\n #print('Loading region {}'.format(region))\\n self.regions[region].load()\\n self.loaded_regions.add(region)\\n region_loading.update(idx)\\n\\n # Unload regions which are too far out\\n regions_to_unload = []\\n for region in list(self.loaded_regions):\\n if region not in valid_regions:\\n regions_to_unload.append(region)\\n\\n region_loading.start(len(regions_to_unload), label='Unloading Regions')\\n for idx, region in enumerate(regions_to_unload):\\n #print('Unloading region {}'.format(region))\\n self.regions[region].unload()\\n self.loaded_regions.remove(region)\\n region_loading.update(idx)\\n\\n # Finish our progress bar\\n region_loading.finish()\",\n \"def __str__(self):\\n return self.regions\",\n \"def regions(self, regions):\\n self._regions = regions\",\n \"def __init__(self):\\n self.regions = []\",\n \"def print(self):\\n\\n print(self._name, \\\": loc\\\")\\n for region in self._regions:\\n print(region.label(), \\\":\\\", region.loc())\",\n \"def rendered_regions(self, obj):\\n return obj.render_json(self.context.get('request'))\",\n \"def push_regions(self, regions: [MouseRegion]):\\n raise NotImplementedError\",\n \"def region_region_checkerboard(self, **_):\\n outputs: dict = {}\\n\\n if self.AGG_BY == \\\"zone\\\":\\n agg = \\\"zone\\\"\\n else:\\n agg = \\\"region\\\"\\n\\n # List of properties needed by the plot, properties are a set of tuples and\\n # contain 3 parts: required True/False, property name and scenarios required,\\n # scenarios must be a list.\\n properties = [(True, f\\\"{agg}_{agg}s_Net_Interchange\\\", self.Scenarios)]\\n\\n # Runs get_formatted_data within PlotDataStoreAndProcessor to populate PlotDataStoreAndProcessor dictionary\\n # with all required properties, returns a 1 if required data is missing\\n check_input_data = self.get_formatted_data(properties)\\n\\n if 1 in check_input_data:\\n return MissingInputData()\\n\\n ncols, nrows = set_x_y_dimension(len(self.Scenarios))\\n grid_size = ncols * nrows\\n excess_axs = grid_size - len(self.Scenarios)\\n\\n mplt = PlotLibrary(nrows, ncols, squeeze=False, ravel_axs=True)\\n fig, axs = mplt.get_figure()\\n plt.subplots_adjust(wspace=0.02, hspace=0.4)\\n max_flow_group = []\\n Data_Out = []\\n n = 0\\n for scenario in self.Scenarios:\\n rr_int = self[f\\\"{agg}_{agg}s_Net_Interchange\\\"].get(scenario)\\n if shift_leapday:\\n rr_int = adjust_for_leapday(rr_int)\\n\\n if self.AGG_BY != \\\"region\\\" and self.AGG_BY != \\\"zone\\\":\\n agg_region_mapping = (\\n self.region_mapping[[\\\"region\\\", self.AGG_BY]]\\n .set_index(\\\"region\\\")\\n .to_dict()[self.AGG_BY]\\n )\\n # Checks if keys all aggregate to a single value, this plot requires multiple values to work\\n if len(set(agg_region_mapping.values())) == 1:\\n return UnsupportedAggregation()\\n rr_int = rr_int.reset_index()\\n rr_int[\\\"parent\\\"] = rr_int[\\\"parent\\\"].map(agg_region_mapping)\\n rr_int[\\\"child\\\"] = rr_int[\\\"child\\\"].map(agg_region_mapping)\\n rr_int_agg = rr_int.groupby([\\\"parent\\\", \\\"child\\\"], as_index=True).sum()\\n rr_int_agg.rename(columns={\\\"values\\\": \\\"flow (MW)\\\"}, inplace=True)\\n rr_int_agg = rr_int_agg.loc[\\n rr_int_agg[\\\"flow (MW)\\\"] > 0.01\\n ] # Keep only positive flows\\n rr_int_agg.sort_values(ascending=False, by=\\\"flow (MW)\\\")\\n rr_int_agg = rr_int_agg / 1000 # MWh -> GWh\\n\\n data_out = rr_int_agg.copy()\\n data_out.rename(\\n columns={\\\"flow (MW)\\\": \\\"{} flow (GWh)\\\".format(scenario)}, inplace=True\\n )\\n\\n max_flow = max(rr_int_agg[\\\"flow (MW)\\\"])\\n rr_int_agg = rr_int_agg.unstack(\\\"child\\\")\\n rr_int_agg = rr_int_agg.droplevel(level=0, axis=1)\\n\\n current_cmap = plt.cm.get_cmap()\\n current_cmap.set_bad(color=\\\"grey\\\")\\n\\n axs[n].imshow(rr_int_agg)\\n axs[n].set_xticks(np.arange(rr_int_agg.shape[1]))\\n axs[n].set_yticks(np.arange(rr_int_agg.shape[0]))\\n axs[n].set_xticklabels(rr_int_agg.columns)\\n axs[n].set_yticklabels(rr_int_agg.index)\\n axs[n].set_title(scenario.replace(\\\"_\\\", \\\" \\\"), fontweight=\\\"bold\\\")\\n\\n # Rotate the tick labels and set their alignment.\\n plt.setp(\\n axs[n].get_xticklabels(),\\n rotation=90,\\n ha=\\\"right\\\",\\n rotation_mode=\\\"anchor\\\",\\n )\\n\\n # Delineate the boxes and make room at top and bottom\\n axs[n].set_xticks(np.arange(rr_int_agg.shape[1] + 1) - 0.5, minor=True)\\n axs[n].set_yticks(np.arange(rr_int_agg.shape[0] + 1) - 0.5, minor=True)\\n axs[n].grid(which=\\\"minor\\\", color=\\\"k\\\", linestyle=\\\"-\\\", linewidth=1)\\n axs[n].tick_params(which=\\\"minor\\\", bottom=False, left=False)\\n\\n max_flow_group.append(max_flow)\\n Data_Out.append(data_out)\\n n += 1\\n\\n # Remove extra axes\\n mplt.remove_excess_axs(excess_axs, grid_size)\\n\\n cmap = cm.inferno\\n norm = mcolors.Normalize(vmin=0, vmax=max(max_flow_group))\\n cax = plt.axes([0.90, 0.1, 0.035, 0.8])\\n fig.colorbar(\\n cm.ScalarMappable(norm=norm, cmap=cmap),\\n cax=cax,\\n label=\\\"Total Net Interchange [GWh]\\\",\\n )\\n plt.xlabel(\\\"To Region\\\", color=\\\"black\\\", rotation=\\\"horizontal\\\", labelpad=40)\\n plt.ylabel(\\\"From Region\\\", color=\\\"black\\\", rotation=\\\"vertical\\\", labelpad=40)\\n\\n data_table_out = pd.concat(Data_Out, axis=1)\\n save_figures = self.figure_folder.joinpath(f\\\"{self.AGG_BY}_transmission\\\")\\n fig.savefig(\\n save_figures.joinpath(\\\"region_region_checkerboard.svg\\\"),\\n dpi=600,\\n bbox_inches=\\\"tight\\\",\\n )\\n data_table_out.to_csv(save_figures.joinpath(\\\"region_region_checkerboard.csv\\\"))\\n\\n outputs = DataSavedInModule()\\n return outputs\",\n \"def description(self):\\n return \\\"create a <b>region</b> with edge at cursor\\\"\",\n \"def set_region(sender, instance, *args, **kwargs):\\n if instance.geocity and not instance.georegion:\\n instance.georegion = instance.geocity.region\",\n \"def initialize_region(self):\\n self.new_region_name = \\\"\\\"\\n self.map.regions.create_new_region()\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.Region_swiginit(self,_gdi_.new_Region(*args, **kwargs))\",\n \"def get_valid_regions(self):\\n pass\",\n \"def _choose_regions(self, display_regions=False):\\n dstl = Load_DSTL()\\n if self.class_type == 1:\\n # Select regions where there are buildings (with red roofs)\\n test_image, test_mask = dstl.extract_region_pos(2300, 3000, cutout_size=[400, 400], object_class=self.class_type)\\n train_image, train_mask = dstl.extract_region_pos(1900, 3100, cutout_size=[400, 400], object_class=self.class_type)\\n cv_image, cv_mask = dstl.extract_region_pos(950, 1450, cutout_size=[200, 200], object_class=self.class_type)\\n elif self.class_type == 5:\\n train_image, train_mask = dstl.extract_region_pos(1150, 2150, cutout_size=[400, 400], object_class=self.class_type)\\n test_image, test_mask = dstl.extract_region_pos(2300, 3000, cutout_size=[400, 400], object_class=self.class_type)\\n cv_image, cv_mask = dstl.extract_region_pos(1900, 1950, cutout_size=[400, 400], object_class=self.class_type)\\n else:\\n pass\\n self.images = {'train': train_image, 'cv': cv_image, 'test': test_image}\\n self.masks = {'train': train_mask, 'cv': cv_mask, 'test': test_mask}\\n if display_regions:\\n for key in self.images.keys():\\n display_three_band(self.images[key], self.masks[key], colors='green', title='{:} region'.format(key))\",\n \"def range(self, event):\\r\\n \\r\\n p = (event.x, self.toCartesian(event.y))\\r\\n \\r\\n if self.selectedRegion is None:\\r\\n self.selectedStart = Region(p[X],p[Y], p[X],p[Y])\\r\\n self.selectedRegion = self.selectedStart.unionPoint(p)\\r\\n \\r\\n self.paint()\\r\\n \\r\\n # return (node,sub-tree) where sub-tree is True if draining entire tree\\r\\n # rooted at node. Draw these as shaded red rectangle to identify whole\\r\\n # sub-tree is selected.\\r\\n for pair in self.tree.range(self.selectedRegion):\\r\\n p = pair[0].point\\r\\n \\r\\n if pair[1]:\\r\\n self.canvas.create_rectangle(pair[0].region.x_min, self.toTk(pair[0].region.y_min), \\r\\n pair[0].region.x_max, self.toTk(pair[0].region.y_max),\\r\\n fill='Red', stipple='gray12')\\r\\n else:\\r\\n self.canvas.create_rectangle(p[X] - BoxSize, self.toTk(p[Y]) - BoxSize, \\r\\n p[X] + BoxSize, self.toTk(p[Y]) + BoxSize, fill='Red')\\r\\n\\r\\n self.queryRect = self.canvas.create_rectangle(self.selectedRegion.x_min, self.toTk(self.selectedRegion.y_min), \\r\\n self.selectedRegion.x_max, self.toTk(self.selectedRegion.y_max), \\r\\n outline='Red', dash=(2, 4))\",\n \"def which_region(self, g):\\n return NotImplementedError\",\n \"def which_region(self, g):\\n raise NotImplementedError\",\n \"def onEditorCollapsed(self, collapsed):\\r\\n # productive\\r\\n profprint()\\r\\n if collapsed:\\r\\n pass\\r\\n else:\\r\\n self.createAddOrSelectLabelMapNode()\",\n \"def __coverageMarkersShown(self, shown):\\n if shown:\\n self.notcoveredNextAct.setEnabled(True)\\n self.notcoveredPreviousAct.setEnabled(True)\\n else:\\n self.notcoveredNextAct.setEnabled(False)\\n self.notcoveredPreviousAct.setEnabled(False)\",\n \"def on_select(self, pos1, pos2):\\n \\n # determine selected chrom\\n chrom = self.pos2chrom(*pos1)\\n chrom2 = self.pos2chrom(*pos2)\\n\\n if chrom == None:\\n print \\\"no chromosome selected\\\"\\n return\\n\\n if chrom != chrom2:\\n print \\\"please select only one chromosome\\\"\\n return\\n\\n x1 = pos1[0]\\n x2 = pos2[0]\\n if x1 > x2:\\n x1, x2 = x2, x1\\n chrom_pos = self.chrom_pos[chrom][0]\\n\\n newchrom = Region(chrom.species, chrom.seqname, chrom.feature, \\n int(max(chrom.start + x1 - chrom_pos, 0)),\\n int(min(chrom.start + x2 - chrom_pos, chrom.end)))\\n\\n print \\\"displaying region: %s:%s:%s-%s:%s\\\" % \\\\\\n (newchrom.species, newchrom.seqname, \\n util.int2pretty(newchrom.start),\\n util.int2pretty(newchrom.end),\\n [\\\"+\\\", \\\"+\\\", \\\"-\\\"][newchrom.strand])\\n\\n # create sub-browser\\n subbrowser = GenomeOverview([newchrom],\\n winpos=self.win.get_position(),\\n winsize=self.win.get_size())\\n\\n for track_class, offset, args, kargs, tracks in self.metatracks:\\n subbrowser.add_track(track_class, offset, *args, **kargs)\\n \\n subbrowser.show()\",\n \"def drawIndex_region(t0, t1, t2, t3):\\r\\n get_pos0(t0)\\r\\n t0.fd(50)\\r\\n t0.pd()\\r\\n t0.pencolor(\\\"blue\\\")\\r\\n t0.write(\\\"Sub-Saharan Africa\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t1.rt(90)\\r\\n get_pos1(t1)\\r\\n t1.fd(50)\\r\\n t1.pd()\\r\\n t1.pencolor(\\\"red\\\")\\r\\n t1.write(\\\"South Asia\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n get_pos2(t2)\\r\\n t2.fd(50)\\r\\n t2.pd()\\r\\n t2.pencolor(\\\"green\\\")\\r\\n t2.write(\\\"Europe and Central Asia\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n get_pos3(t3)\\r\\n t3.fd(50)\\r\\n t3.pd()\\r\\n t3.pencolor(\\\"gold\\\")\\r\\n t3.write(\\\"Latin America & Caribbean\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t0.pu()\\r\\n t1.pu()\\r\\n t2.pu()\\r\\n t3.pu()\\r\\n t0.back(80)\\r\\n t0.pd()\\r\\n t0.pencolor(\\\"black\\\")\\r\\n t0.write(\\\"Middle East and North Africa\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t1.back(80)\\r\\n t1.pd()\\r\\n t1.pencolor(\\\"yellow\\\")\\r\\n t1.write(\\\"North America\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t2.back(80)\\r\\n t2.pd()\\r\\n t2.pencolor(\\\"purple\\\")\\r\\n t2.write(\\\"East Asia and Pacific\\\", font=(\\\"Arial\\\", 10, \\\"bold\\\"))\\r\\n t3.goto(initialCoordinates())\\r\\n t0.pu()\\r\\n t1.pu()\\r\\n t2.pu()\\r\\n t0.goto(initialCoordinates())\\r\\n t1.goto(initialCoordinates())\\r\\n t2.goto(initialCoordinates())\\r\\n t3.goto(initialCoordinates())\",\n \"def river_region(rr_id):\\n r = RiverRegionRenderer(request, rr_id, None)\\n return r.render()\",\n \"def update_help(self):\\n if self.region_id is not None:\\n controller.set_help_text(\\\"\\\"\\\"Drag to desired region width.<br/>\\\\n\\n <b>R</b> to set the region<br/>\\\\n\\n <b>D</b> to delete/cancel the current region<br/>\\n <b>*</b> to extend to maximum on this side\\n \\\"\\\"\\\")\\n else:\\n controller.set_help_text(\\\"\\\"\\\"<b> Edit Regions: </b><br/>\\\\n\\n <b>R</b> to start a new region<br/>\\\\n\\n <b>E</b> to edit nearest region<br/>\\\\n\\n <b>D</b> to delete the nearest region\\n \\\"\\\"\\\")\",\n \"def _create_mid_region_frame(self):\\n self.region_option = tk.StringVar()\\n self.region_option.set(\\\"euw\\\")\\n self.frames.append(tk.LabelFrame(self.master))\\n self.option_menu = tk.OptionMenu(self.frames[5], self.region_option,\\n \\\"euw\\\", \\\"na\\\", \\\"eune\\\")\\n self.option_menu.grid(sticky=\\\"ew\\\")\\n self.frames[5].grid(column=1, row=0, sticky=\\\"ns\\\", pady=10)\\n self.frames[5].columnconfigure(0, weight=1)\",\n \"def regions(self):\\n return self._regions\",\n \"def select_regions(data, region_col, regions, combine_subregions=True):\",\n \"def showSS(self, show):\\n\\t\\tfrom chimera.Sequence import defHelixColor, defStrandColor\\n\\t\\thelixReg = self.getRegion(\\\"structure helices\\\", create=1,\\n\\t\\t\\t\\tfill=(1.0, 1.0, 0.8), outline=defHelixColor)\\n\\t\\tstrandReg = self.getRegion(\\\"structure strands\\\", create=1,\\n\\t\\t\\t\\tfill=(0.8, 1.0, 0.8), outline=defStrandColor)\\n\\t\\thelixReg.shown = show\\n\\t\\tstrandReg.shown = show\\n\\t\\tif not show:\\n\\t\\t\\treturn\\n\\t\\thelixReg.clear(makeCB=False) # callback will happen in\\n\\t\\tstrandReg.clear(makeCB=False) # addBlocks below\\n\\n\\t\\tassocSeqs = {}\\n\\t\\thelices = []\\n\\t\\tstrands = []\\n\\t\\tfor aseq in self.seqCanvas.mav.associations.values():\\n\\t\\t\\tassocSeqs[aseq] = 1\\n\\t\\tfor aseq in assocSeqs.keys():\\n\\t\\t\\tinHelix = inStrand = 0\\n\\t\\t\\tfor pos in range(len(aseq.ungapped())):\\n\\t\\t\\t\\tisHelix = isStrand = 0\\n\\t\\t\\t\\tfor matchMap in aseq.matchMaps.values():\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tres = matchMap[pos]\\n\\t\\t\\t\\t\\texcept KeyError:\\n\\t\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\tif res.isHelix:\\n\\t\\t\\t\\t\\t\\tisHelix = 1\\n\\t\\t\\t\\t\\telif res.isStrand:\\n\\t\\t\\t\\t\\t\\tisStrand = 1\\n\\t\\t\\t\\tgapped = aseq.ungapped2gapped(pos)\\n\\t\\t\\t\\tif isHelix:\\n\\t\\t\\t\\t\\tif inHelix:\\n\\t\\t\\t\\t\\t\\thelices[-1][-1] = gapped\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\thelices.append([aseq, aseq,\\n\\t\\t\\t\\t\\t\\t\\t\\tgapped, gapped])\\n\\t\\t\\t\\t\\t\\tinHelix = 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif inHelix:\\n\\t\\t\\t\\t\\t\\tinHelix = 0\\n\\t\\t\\t\\tif isStrand:\\n\\t\\t\\t\\t\\tif inStrand:\\n\\t\\t\\t\\t\\t\\tstrands[-1][-1] = gapped\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tstrands.append([aseq, aseq,\\n\\t\\t\\t\\t\\t\\t\\t\\tgapped, gapped])\\n\\t\\t\\t\\t\\t\\tinStrand = 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif inStrand:\\n\\t\\t\\t\\t\\t\\tinStrand = 0\\n\\t\\thelixReg.addBlocks(helices)\\n\\t\\tstrandReg.addBlocks(strands)\",\n \"def whitelist_regions(self):\\n return getattr(self, '_do_whitelist_regions', False)\",\n \"def __repr__(self: RcnRegion) -> str:\\n return f\\\"RcnRegion.{self.name}\\\"\",\n \"def main(self, _):\\n all_addresses = find_addresses.probe_regions()\\n\\n print(\\\"\\\")\\n if not all_addresses:\\n print(\\\"No namespace elastic IP addresses found.\\\")\\n\\n for region in consts.REGIONS:\\n region_addresses = [address for address in all_addresses\\n if address['region'] == region]\\n if not region_addresses:\\n continue\\n\\n print(f\\\"{region}: {len(region_addresses)} address(es) found:\\\")\\n for address in region_addresses:\\n if 'instance_name' in address:\\n print(f\\\" {address['ip']} ({address['instance_name']})\\\")\\n elif 'association_id' in address:\\n print(f\\\" {address['ip']} (unknown association)\\\")\\n else:\\n print(f\\\" {address['ip']} (not associated)\\\")\",\n \"def __init__(self, region):\\r\\n self.region = region\",\n \"def display(self):\\r\\n if self.invisible and not self.highlighted:\\r\\n return\\r\\n \\r\\n loc = self.loc\\r\\n SlTrace.lg(\\\"edge: %s\\\" % str(loc), \\\"display\\\")\\r\\n if self.highlighted:\\r\\n if self.turned_on:\\r\\n if self.on_highlighting:\\r\\n c1x,c1y,c3x,c3y = self.get_rect(enlarge=True)\\r\\n self.highlight_tag = self.sel_area.canvas.create_rectangle(\\r\\n c1x, c1y, c3x, c3y,\\r\\n fill=SelectPart.edge_fill_highlight)\\r\\n else:\\r\\n if self.off_highlighting:\\r\\n c1x,c1y,c3x,c3y = self.get_rect(enlarge=True)\\r\\n self.highlight_tag = self.sel_area.canvas.create_rectangle(\\r\\n c1x, c1y, c3x, c3y,\\r\\n fill=SelectPart.edge_fill_highlight)\\r\\n else:\\r\\n self.display_clear()\\r\\n c1x, c1y, c3x, c3y = self.get_rect()\\r\\n self.display_tag = self.sel_area.canvas.create_rectangle(\\r\\n c1x, c1y, c3x, c3y,\\r\\n fill=self.color)\\r\\n if SlTrace.trace(\\\"show_id\\\"):\\r\\n dir_x, dir_y = self.edge_dxy()\\r\\n chr_w = 5\\r\\n chr_h = chr_w*2\\r\\n if dir_x != 0: # sideways\\r\\n offset_x = -len(str(self.id))*chr_w/2 + chr_w\\r\\n offset_y = chr_h\\r\\n if dir_y != 0: # up/down\\r\\n offset_x = len(str(self.id))*chr_w\\r\\n offset_y = 0 \\r\\n \\r\\n cx = (c1x+c3x)/2 + offset_x\\r\\n cy = (c1y+c3y)/2 + offset_y\\r\\n self.name_tag = self.display_text((cx, cy), text=str(self.id))\",\n \"def onLoadSegmentationButton(self):\\n inputVolume = self.inputSelector.currentNode()\\n segmentationFile = self.segmentationsPath + self.segmentationFilesComboBox.currentText\\n \\n loadedSegmentationVolumeNode = slicer.util.loadVolume(segmentationFile)\\n voxels = slicer.util.arrayFromVolume(loadedSegmentationVolumeNode)\\n imgLabel = np.copy(voxels)\\n \\n tmpVoxels = np.copy(voxels)\\n tmpVoxels[:] = imgLabel[:]\\n \\n slicer.util.updateVolumeFromArray(loadedSegmentationVolumeNode, tmpVoxels)\\n \\n removeLastSegmentation = self.removeLastSegmentationCheckBox.isChecked() \\n showBackGround = self.showBackGroundCheckBox.isChecked()\\n displaySegmentationMap(loadedSegmentationVolumeNode, imgLabel, self.labelColorsList, removeLastSegmentation, showBackGround)\\n \\n slicer.util.setSliceViewerLayers(background=inputVolume)\",\n \"def __str__(self):\\n return \\\"Region: \\\" + self.name + \\\" with parent \\\" + self.parent + \\\" and self code \\\" + self.FHIRCode\",\n \"def helptext(self):\\n return \\\"\\\"\\\"<b> Edit Regions </b> <br/>\\\\n\\n <b>R</b> to start a new region or set the edge if editing<br/>\\\\n\\n <b>E</b> to edit nearest region<br/>\\\\n\\n <b>D</b> to delete/cancel the current/nearest region\\n \\\"\\\"\\\"\",\n \"def list_regions():\\n regions_areas = (\\n db.session.query(\\n models.Region.code.label(\\\"region_code\\\"),\\n models.Region.name.label(\\\"region_name\\\"),\\n db.case([(models.District.code.is_(None),\\n db.literal_column(\\\"'admin_area'\\\"))],\\n else_=db.literal_column(\\\"'district'\\\")).label(\\\"area_type\\\"),\\n db.case([(models.District.code.is_(None), models.AdminArea.code)],\\n else_=models.District.code).label(\\\"area_code\\\"),\\n db.case([(models.District.code.is_(None), models.AdminArea.name)],\\n else_=models.District.name).label(\\\"area_name\\\")\\n ).select_from(models.Region)\\n .join(models.Region.areas)\\n .outerjoin(models.AdminArea.districts)\\n .filter(models.Region.code != \\\"GB\\\")\\n .order_by(\\\"region_name\\\", \\\"area_name\\\")\\n .all()\\n )\\n regions = {}\\n areas = {}\\n for row in regions_areas:\\n regions[row.region_code] = row.region_name\\n areas.setdefault(row.region_code, []).append(row)\\n\\n return render_template(\\\"regions.html\\\", regions=regions, areas=areas)\",\n \"def create_panel_custom_regions():\\n panel_id = request.json[\\\"panel_id\\\"]\\n chrom = request.json[\\\"chrom\\\"]\\n start = request.json[\\\"start\\\"]\\n end = request.json[\\\"end\\\"]\\n name = request.json[\\\"name\\\"]\\n regions = select_region_by_location(s, chrom, start, end) # if region already exists, return current entry\\n if regions:\\n for i in regions:\\n add_region_to_panel(s, i.id, panel_id)\\n s.commit()\\n continue\\n else:\\n create_custom_region(s, panel_id, chrom, start, end, name)\\n\\n return jsonify(\\\"complete\\\")\",\n \"def ffgs_regions():\\n return [\\n ('Hispaniola', 'hispaniola'),\\n ('Central America', 'centralamerica')\\n ]\",\n \"def delete_this_region(self):\",\n \"def __highlight_region_cmd(region_list):\\n assert( (isinstance(region_list, list) or isinstance(region_list, tuple)) and len(region_list) >= 1 )\\n assert( isinstance(region_list[0], list) or isinstance(region_list[0], tuple) )\\n CMD = '-highlightRegion \\\"'\\n for region in region_list:\\n if len(region) == 2:\\n CMD += \\\"%s-%s:fill=%s,outline=#FFFFFF,radius=15;\\\" % (region[0], region[1], \\\"00FF00\\\")\\n else:\\n CMD += \\\"%s-%s:fill=%s,outline=#FFFFFF,radius=15;\\\" % (region[0], region[1], region[2])\\n CMD += '\\\"'\\n return CMD\",\n \"def filter_regions(self):\\n return self.filter_nodes('/DistrictBuilder/Regions/Region')\",\n \"def display(self):\\n map_show = self.map.copy()\\n map_show[self.currY, self.currX] = 4 \\n print(map_show)\",\n \"def handle(self, args):\\n\\n # Load the regions for the sg command\\n regions = Regions.load()\\n\\n # Filter regions specified\\n args.regions = set(args.regions)\\n if \\\"all\\\" not in args.regions:\\n regions = Regions(\\n region for region in regions\\n if str(region) in args.regions\\n )\\n\\n results = wait(\\n (partial(self.handle_region, region) for region in regions),\\n args=(args,))\\n\\n table = [['', 'Region', 'Notes']] + results\\n print(tabulate(table, tablefmt=args.tablefmt, headers='firstrow'))\",\n \"def ReadRegions(self, fname=\\\"temp\\\"):\\n self.fname = fname\\n command = \\\"\\\"\\\"IPython.notebook.kernel.execute('file = open(\\\"temp\\\", \\\"w\\\"); [file.write(x[\\\"wcsstr\\\"]) for x in '+ JSON.stringify(JS9.GetShapes(\\\"regions\\\", {{display: '{wid}JS9'}})) +']; file.close()');\\\"\\\"\\\".format(wid=self.wid)\\n get_ipython().run_cell_magic('javascript', '', command)\",\n \"def handle(self, args):\\n args.regions = set(args.regions)\\n regions = Regions(\\n region for region in Regions.load()\\n if str(region) in args.regions\\n )\\n\\n results = wait(\\n (partial(self.handle_region, region) for region in regions),\\n args=(args,))\\n\\n table = [['', 'Region', 'Notes']] + results\\n print(tabulate(table, tablefmt=args.tablefmt, headers='firstrow'))\",\n \"def add_region(self, position):\\n region = self.region_selector(position)\\n self.regions[id(region)] = region\",\n \"def show_map(self):\\n self.m1.display()\",\n \"def nine_regions(self):\\n\\n coordinateList = []\\n\\n # Top left.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * self.ratioTopLeft[IDX_X] )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * self.ratioTopLeft[IDX_Y] )\\n coordinateList.append( [x, y] )\\n\\n # Top center.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * 0.5 - self.regionSize[IDX_WIDTH] / 2 )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * self.ratioTopLeft[IDX_Y] ) \\n coordinateList.append( [x, y] )\\n\\n # Top right.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * ( 1.0 - self.ratioTopLeft[IDX_X] ) - self.regionSize[IDX_WIDTH] )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * self.ratioTopLeft[IDX_Y] )\\n coordinateList.append( [x, y] )\\n\\n # Center left.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * self.ratioTopLeft[IDX_X] )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * 0.5 - self.regionSize[IDX_HEIGHT] / 2 )\\n coordinateList.append( [x, y] )\\n\\n # Center.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * 0.5 - self.regionSize[IDX_WIDTH] / 2 )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * 0.5 - self.regionSize[IDX_HEIGHT] / 2 )\\n coordinateList.append( [x, y] )\\n\\n # Center right.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * (1.0 - self.ratioTopLeft[IDX_X]) - self.regionSize[IDX_WIDTH] )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * 0.5 - self.regionSize[IDX_HEIGHT] / 2 )\\n coordinateList.append( [x, y] )\\n\\n # Bottom left.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * self.ratioTopLeft[IDX_X] )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * (1.0 - self.ratioTopLeft[IDX_Y]) - self.regionSize[IDX_HEIGHT] )\\n coordinateList.append( [x, y] )\\n\\n # Bottom center.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * 0.5 - self.regionSize[IDX_WIDTH] / 2 )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * (1.0 - self.ratioTopLeft[IDX_Y]) - self.regionSize[IDX_HEIGHT] )\\n coordinateList.append( [x, y] )\\n\\n # Bottom right.\\n x = (int)( self.oriImgSize[IDX_WIDTH] * (1.0 - self.ratioTopLeft[IDX_X]) - self.regionSize[IDX_WIDTH] )\\n y = (int)( self.oriImgSize[IDX_HEIGHT] * (1.0 - self.ratioTopLeft[IDX_Y]) - self.regionSize[IDX_HEIGHT] )\\n coordinateList.append( [x, y] )\\n\\n return coordinateList\",\n \"def regions(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"regions\\\")\",\n \"def area(self):\\n ...\",\n \"def LoadRegions(self, fname='js9.reg'):\\n self.fname=fname\\n command = \\\"JS9.LoadRegions('{fname}', {{display:'{wid}JS9'}})\\\".format(fname=fname, wid=self.wid)\\n get_ipython().run_cell_magic('javascript', '', command)\",\n \"def changeSubdivRegion(*args, action: int=0, level: int=0, **kwargs)->bool:\\n pass\",\n \"def state_preview_enter(cfg, app, win):\",\n \"def update_zoom_region(self):\\n self.linear_region.setRegion(self.plot_zoom.getViewBox().viewRange()[0])\",\n \"def show(self):\\r\\n display(self.grid_part)\",\n \"def initial_representations():\\n cmd.hide('everything', 'all')\\n cmd.show('cartoon', 'all')\\n cmd.select('ligand', 'resn NFT')\\n cmd.deselect()\\n cmd.show(\\\"sticks\\\", \\\"ligand\\\")\",\n \"def update_resistance_region(self):\\n self.linear_region.setRegion(\\n self.resistance_graph.getViewBox().viewRange()[0])\",\n \"def region(self):\\n return [node.region for node in self]\",\n \"def test_center_region(self):\\n before_b = \\\"\\\"\\\"\\\\\\n Some 90% of all presidentially declared disasters are weather related,\\n leading to around 500 deaths per year and nearly $14 billion in damage.\\n StormReady, a program started in 1999 in Tulsa, OK,\\n helps arm America's communities with the communication and safety\\n skills needed to save lives and property– before and during the event.\\n StormReady helps community leaders and emergency managers strengthen local safety programs.\\n \\\"\\\"\\\"\\n after_b = \\\"\\\"\\\"\\\\\\n Some 90% of all presidentially declared disasters are weather related,\\n leading to around 500 deaths per year and nearly $14 billion in damage.\\n StormReady, a program started in 1999 in Tulsa, OK,\\n helps arm America's communities with the communication and safety\\n skills needed to save lives and property– before and during the event.\\n StormReady helps community leaders and emergency managers strengthen local safety programs.\\n \\\"\\\"\\\"\\n self.run_test(\\n before_b=before_b,\\n after_b=after_b,\\n before_sel=(\\\"1.0\\\", \\\"7.0\\\"),\\n after_sel=(\\\"1.0\\\", \\\"7.0\\\"),\\n command_name=\\\"center-region\\\",\\n directives=\\\"@pagewidth 70\\\",\\n )\",\n \"def update_plots_using_region(self):\\n self.frequency_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.resistance_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.temperature_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.pressure_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.humidity_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\",\n \"def draw_region(self, constraint, agent):\\n if (constraint == self.obstacles) and (self.obstacles[agent] is not None):\\n for area in self.obstacles[agent]:\\n x_min, x_max = area[0][0], area[0][1]\\n y_min, y_max = area[1][0], area[1][1]\\n rectangle = plt.Rectangle((x_min, y_min), x_max - x_min, y_max - y_min, fc='k', ec=\\\"k\\\")\\n plt.gca().add_patch(rectangle)\\n elif (constraint == self.observation_areas) and (self.observation_areas[agent] is not None):\\n for observation_area in self.observation_areas[agent]:\\n x_min, x_max = observation_area.region[0][0], observation_area.region[0][1]\\n y_min, y_max = observation_area.region[1][0], observation_area.region[1][1]\\n rectangle = plt.Rectangle((x_min, y_min), x_max - x_min, y_max - y_min, fc='c', ec=\\\"c\\\", alpha=0.5)\\n plt.gca().add_patch(rectangle)\\n\\n plt.xlim(self.Xi[0])\\n plt.ylim(self.Xi[1])\",\n \"def mark_regions_image(self, image, stats):\\n detector = cv2.SimpleBlobDetector_create()\\n keypoints = detector.detect(image)\\n output = cv2.drawKeypoints(image, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\\n cv2.namedWindow(\\\"marks\\\", cv2.WINDOW_AUTOSIZE)\\n cv2.imshow(\\\"marks\\\", output)\\n cv2.waitKey(0)\\n cv2.destroyWindow(\\\"marks\\\")\\n return output\",\n \"def createSubdivRegion(*args, **kwargs)->bool:\\n pass\",\n \"def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\\n #Read in the image that is segmented/labelled for nuclei\\n img=imread(img_dir)\\n\\n #save plots to show clusters\\n fig = plt.figure(figsize=(6, 2))\\n ax0 = fig.add_subplot(131)\\n ax1 = fig.add_subplot(132)\\n ax3 = fig.add_subplot(133)\\n #show segmented image labels\\n ax0.imshow(img,aspect='auto') \\n ax0.axis('off')\\n #nuclear centroid color-coded by their orientation\\n img1=ax1.scatter(data[\\\"Y\\\"], data[\\\"X\\\"], c=data[\\\"angles\\\"],s=1)\\n ax1.set_xlim(0,img.shape[0])\\n ax1.set_ylim(img.shape[1],0)\\n plt.colorbar(img1)\\n ax1.axis('off')\\n\\n # plot the cluster assignments\\n img3=ax3.scatter(data[data[\\\"clusters\\\"]> -1][\\\"Y\\\"], data[data[\\\"clusters\\\"]> -1][\\\"X\\\"], \\n c=data[data[\\\"clusters\\\"]> -1][\\\"clusters\\\"],cmap=\\\"plasma\\\",s=1)\\n ax3.set_xlim(0,img.shape[0])\\n ax3.set_ylim(img.shape[1],0)\\n ax3.axis('off')\\n\\n #add titles\\n ax0.title.set_text('Segmented Image')\\n ax1.title.set_text('Filtered Orientation')\\n ax3.title.set_text('Clusters')\\n\\n if display_not_save:\\n plt.show()\\n else: \\n plt.savefig((output_dir+\\\"/\\\"+img_dir.rsplit('/', 1)[-1][:-4]+\\\"_\\\"+str(dbscn_length)+\\\"_\\\"+ str(dbscn_min_size)+\\\".png\\\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\\n fig.clf()\\n plt.close(fig)\\n plt.close('all')\\n \\n \\n del fig,ax0,ax1,ax3,img1,img3\",\n \"def _index(self):\\n bFirstCall = super(PageXmlSeparatorRegion, self)._index()\\n \\n if bFirstCall:\\n # indexing was required\\n # , so first call\\n # , so we need to make the computation of edges crossing separators!\\n self.addSeparatorFeature()\",\n \"def regions(self) -> pulumi.Output[Sequence[str]]:\\n return pulumi.get(self, \\\"regions\\\")\",\n \"def drawCoordinatePlane_region():\\r\\n turtle2 = t.Screen()\\r\\n turtle2.title(\\\"Life Expectancy versus Region\\\")\\r\\n t2.speed(0)\\r\\n t3.speed(0)\\r\\n setTurtle(t0)\\r\\n setTurtle(t1)\\r\\n setTurtle(t2)\\r\\n setTurtle(t3)\\r\\n drawAxes(t0)\\r\\n t1.left(90)\\r\\n drawAxes(t1)\\r\\n t0.pu()\\r\\n t0.fd(-80)\\r\\n t0.lt(90)\\r\\n drawlabels(t0, t1)\\r\\n drawPoints(t0, t1)\\r\\n t0.pu()\\r\\n t1.pu()\\r\\n t2.pu()\\r\\n t3.pu()\\r\\n t0.goto(initialCoordinates())\\r\\n t1.goto(initialCoordinates())\\r\\n t2.goto(initialCoordinates())\\r\\n t3.goto(initialCoordinates())\\r\\n t1.lt(90)\",\n \"def find_hetero_regions(M_original, P_original, plotshow=True, figsize=(20,1)):\\n hetero = M_original != P_original\\n regions_bounds = np.concatenate([[0], np.where(hetero[:-1] != hetero[1:])[0]+1, [len(hetero)]])\\n regions = []\\n for b, begin in enumerate(regions_bounds[:-1]):\\n if hetero[begin]:\\n regions.append(np.arange(regions_bounds[b], regions_bounds[b+1]))\\n\\n if plotshow:\\n\\n print(\\\"Haplotypes (true labels):\\\")\\n plot_haplo(M_original,P_original,figsize=figsize)\\n plt.show()\\n\\n plt.figure(figsize=figsize)\\n cols = np.concatenate([[r]*len(regions[r]) for r in range(len(regions))])\\n plt.scatter(np.concatenate(regions), [1]*len(np.concatenate(regions)), c=cols, cmap=\\\"Accent\\\")\\n plt.scatter(regions_bounds, [1]*len(regions_bounds), color=\\\"red\\\")\\n plt.yticks([], [])\\n plt.title(\\\"Heterozygous Regions\\\")\\n plt.show()\\n \\n return regions\",\n \"def select_proper_region(self):\\n # Click the desired region\\n region = self.driver.find_element_by_css_selector(web_map[self.region][button_path])\\n region.click()\\n time.sleep(1)\\n\\n try:\\n search = self.driver.find_element_by_css_selector(go_to_search)\\n search.click()\\n time.sleep(1)\\n return True\\n except NoSuchElementException:\\n # This means that the information of this autonomous community is not available\\n # at this version\\n return False\",\n \"def get_region_dropdown(mode):\\n print(mode)\\n if mode == SelectionMode.Continents.value:\\n return {'display': 'none'}, {'display': 'block'}, {'display': 'none'}\\n elif mode == SelectionMode.Countries.value:\\n return {'display': 'none'}, {'display': 'none'}, {'display': 'block'}\\n \\n return {'height': '35px'}, {'display': 'none'}, {'display': 'none'}\",\n \"def area(self):\",\n \"def update_temperature_region(self):\\n self.linear_region.setRegion(\\n self.temperature_plot_graph.getViewBox().viewRange()[0])\",\n \"def regions(self):\\n\\n class RegionIter(object):\\n def __init__(self, region_based):\\n self._region_based = region_based\\n\\n def __len__(self):\\n return self._region_based._region_len()\\n\\n def __iter__(self):\\n return self()\\n\\n def _fix_chromosome(self, regions):\\n for r in regions:\\n r.fix_chromosome(copy=True)\\n\\n def __call__(self, key=None, *args, **kwargs):\\n fix_chromosome = kwargs.pop('fix_chromosome', False)\\n\\n if key is None:\\n iterator = self._region_based._region_iter(*args, **kwargs)\\n else:\\n if isinstance(key, string_types) or isinstance(key, GenomicRegion):\\n iterator = self._region_based.region_subset(key, *args, **kwargs)\\n else:\\n iterator = self._region_based._get_regions(key, *args, **kwargs)\\n\\n if fix_chromosome:\\n return self._fix_chromosome(iterator)\\n else:\\n return iterator\\n\\n def __getitem__(self, item):\\n if isinstance(item, string_types) or isinstance(item, GenomicRegion):\\n return self._region_based.region_subset(item)\\n return self._region_based._get_regions(item)\\n\\n return RegionIter(self)\",\n \"def to_region(self):\\n\\n coords = self.convert_coords()\\n log.debug(coords)\\n viz_keywords = ['color', 'dash', 'dashlist', 'width', 'font', 'symsize',\\n 'symbol', 'symsize', 'fontsize', 'fontstyle', 'usetex',\\n 'labelpos', 'labeloff', 'linewidth', 'linestyle',\\n 'point', 'textangle', 'fontweight']\\n\\n if isinstance(coords[0], SkyCoord):\\n reg = self.shape_to_sky_region[self.region_type](*coords)\\n elif isinstance(coords[0], PixCoord):\\n reg = self.shape_to_pixel_region[self.region_type](*coords)\\n else:\\n self._raise_error(\\\"No central coordinate\\\")\\n\\n reg.visual = RegionVisual()\\n reg.meta = RegionMeta()\\n\\n # both 'text' and 'label' should be set to the same value, where we\\n # default to the 'text' value since that is the one used by ds9 regions\\n label = self.meta.get('text',\\n self.meta.get('label', \\\"\\\"))\\n if label != '':\\n reg.meta['label'] = label\\n for key in self.meta:\\n if key in viz_keywords:\\n reg.visual[key] = self.meta[key]\\n else:\\n reg.meta[key] = self.meta[key]\\n reg.meta['include'] = self.include\\n return reg\",\n \"def __editShowCodeInfo(self):\\n self.showEditorInfo(self.activeWindow())\",\n \"def displaySegmentationMap(inputVolume, segmentationMap, labelColorsList, removeLastSegmentation, showBackGround): \\n # Remove last segmentation, including 3D representation\\n if removeLastSegmentation:\\n countSegmentationNode = slicer.mrmlScene.GetNumberOfNodesByClass(\\\"vtkMRMLSegmentationNode\\\")\\n if countSegmentationNode > 0:\\n slicer.mrmlScene.RemoveNode( slicer.mrmlScene.GetNthNodeByClass(countSegmentationNode-1, \\\"vtkMRMLSegmentationNode\\\") )\\n \\n segmentationNode = slicer.mrmlScene.AddNewNodeByClass(\\\"vtkMRMLSegmentationNode\\\")\\n segmentationNode.CreateDefaultDisplayNodes()\\n segmentationNode.SetReferenceImageGeometryParameterFromVolumeNode(inputVolume)\\n \\n segmentationNode.RemoveClosedSurfaceRepresentation()\\n\\n # Create segment editor to get access to effects\\n segmentEditorWidget = slicer.qMRMLSegmentEditorWidget()\\n segmentEditorWidget.setMRMLScene(slicer.mrmlScene)\\n segmentEditorNode = slicer.mrmlScene.AddNewNodeByClass(\\\"vtkMRMLSegmentEditorNode\\\")\\n segmentEditorWidget.setMRMLSegmentEditorNode(segmentEditorNode)\\n segmentEditorWidget.setSegmentationNode(segmentationNode)\\n segmentEditorWidget.setMasterVolumeNode(inputVolume)\\n \\n for i in range(len(labelColorsList)):\\n addedSegmentID = segmentationNode.GetSegmentation().AddEmptySegment(labelColorsList[i][0])\\n segmentationNode.GetSegmentation().GetSegment(addedSegmentID).SetColor(labelColorsList[i][1])\\n segmentEditorWidget.setCurrentSegmentID(addedSegmentID)\\n \\n # Thresholding\\n segmentEditorWidget.setActiveEffectByName(\\\"Threshold\\\")\\n effect = segmentEditorWidget.activeEffect()\\n thresh = i+1\\n effect.setParameter(\\\"MinimumThreshold\\\", str(clip(thresh, 0, 255)))\\n effect.setParameter(\\\"MaximumThreshold\\\", str(clip(thresh, 0, 255)))\\n effect.self().onApply()\\n\\n if (not showBackGround) and (i == len(labelColorsList) - 1):\\n segmentationNode.GetDisplayNode().SetSegmentVisibility (addedSegmentID, False)\\n\\n # print 3D representation\\n segmentationNode.CreateClosedSurfaceRepresentation()\",\n \"def _process_region(self, region, writer):\",\n \"def __setNonTabAreaItemsFromRegionHidden(self,area, view):\\r\\n x,y,w,h = area\\r\\n\\r\\n # Loop through all objects on screen and remove ones which are completely covered by given area and are not in same container as area\\r\\n for node in view.findall('/*[@center and @is-in-tab-area=\\\"false\\\"]'):\\r\\n nodeX, nodeY, nodeW, nodeH = [int(p) for p in node.getAttribute('coords').split(\\\",\\\")]\\r\\n if nodeX>x and (nodeX+nodeW)<(x+w) and nodeY>y and (nodeY+nodeH)<(y+h):\\r\\n if node.getName()=='label':\\r\\n debug.out(\\\"Removing node %s(%s,%s,%s,%s) from area %s,%s,%s,%s\\\"%(node.getAttribute(\\\"text\\\"),nodeX, nodeY,nodeW,nodeH,x,y,w,h))\\r\\n\\r\\n node.setAttribute(\\\"visible\\\",\\\"hidden\\\")\\r\\n return view\",\n \"def visualise():\\n\\n column = request.form.getlist('columnName')\\n regions = request.form.getlist('raw_regions')\\n #take the single string and return a list\\n regions = query_proc.prep_regions(regions)\\n #get that tables of interst\\n table = query_proc.column_to_table(column)\\n\\n var_data = query_proc.get_region_data(table, column, regions)\\n minval = query_proc.get_region_data_min(table, column, regions)\\n maxval = query_proc.get_region_data_max(table, column, regions)\\n\\n #column diction to get human fiendly designation\\n column_dict = name_column.get_name_column_dict()\\n real_column = column_dict[column[0]]\\n\\n\\n ##packing for the template\\n region = regions[0]\\n min_max = [minval, maxval]\\n step = query_proc.calc_steps(min_max)\\n min_max.append(step)\\n\\n min_max = json.dumps(min_max)\\n json_vardata = json.dumps(var_data)\\n\\n return render_template('visualise.html',\\n title='Data on a Map!',\\n column=column,\\n real_column=real_column,\\n region=region,\\n min_max=min_max,\\n json_vardata=json_vardata)\",\n \"def updateDisplay(self):\\n\\t\\tregion = braille.handler.mainBuffer.regions[-1] if braille.handler.mainBuffer.regions else None\\n\\t\\tif isinstance(region, braille.TextInfoRegion):\\n\\t\\t\\tbraille.handler._doCursorMove(region)\",\n \"def displayNative(self):\\n\\n\\t\\tcmd.hide(\\\"lines\\\", \\\"native\\\")\\n\\t\\tcmd.color(\\\"gray\\\", \\\"native & name CA\\\")\\n\\t\\t#cmd.zoom(\\\"nearby\\\")\",\n \"def generate_level(self):\\n for _ in range(AMOUNT_REGIONS_TO_DRAW):\\n self._generate_next_blocks()\",\n \"def run(self):\\n\\n self.window.run_command(\\\"show_panel\\\", {\\\"panel\\\": \\\"output.reg_replace\\\"})\",\n \"def getRegionPlotList(self, lRegions, bBorder = False):\\n\\t\\t\\n\\t\\tplotList = []\\n\\t\\tfor x in range(con.iMapWidth):\\n\\t\\t\\tfor y in range(con.iMapHeight):\\n\\t\\t\\t\\tif gc.getMap().plot(x, y).getRegionID() in lRegions:\\n\\t\\t\\t\\t\\tif not bBorder:\\n\\t\\t\\t\\t\\t\\tplotList.append((x, y))\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tfor x2 in range(x-1, x+2):\\n\\t\\t\\t\\t\\t\\t\\tfor y2 in range(y-1, y+2):\\n\\t\\t\\t\\t\\t\\t\\t\\tif (x2, y2) not in plotList: plotList.append((x2, y2))\\n\\t\\t\\n\\t\\treturn plotList\",\n \"def region_graph(t0, t1, t2, t3):\\r\\n medians0 = sorted(sub_saharan_africa_countries())\\r\\n t0.goto(-250, ((medians0[0])-50))\\r\\n t0.rt(90)\\r\\n for idx in range(1, len(medians0)):\\r\\n t0.pencolor(\\\"blue\\\")\\r\\n t0.pd()\\r\\n t0.setpos((-250+(idx*10.5)), ((medians0[idx])))\\r\\n\\r\\n medians1 = sorted(south_asia_countries())\\r\\n t1.goto(-250, ((medians1[0]) - 60))\\r\\n t1.rt(90)\\r\\n for idx in range(1, len(medians1)):\\r\\n t1.pencolor(\\\"red\\\")\\r\\n t1.pd()\\r\\n t1.setpos((-250 + (idx * 68.5)), (2*(medians1[idx])+10))\\r\\n\\r\\n medians2 = sorted(europe_central_asia_countries())\\r\\n t2.goto(-250, (medians2[0])+60)\\r\\n t2.rt(90)\\r\\n for idx in range(1, len(medians2)):\\r\\n t2.pencolor(\\\"green\\\")\\r\\n t2.pd()\\r\\n t2.setpos((-250 + (idx*10.19)), (2 * (medians2[idx]) + 10))\\r\\n\\r\\n medians3 = sorted(latin_america_countries())\\r\\n t3.goto(-250, (medians3[0]) + 20)\\r\\n t3.rt(90)\\r\\n for idx in range(1, len(medians3)):\\r\\n t3.pencolor(\\\"gold\\\")\\r\\n t3.pd()\\r\\n t3.setpos((-250 + (idx * 14.39)), (2 * (medians3[idx]) + 10))\\r\\n\\r\\n t0.pu()\\r\\n t0.goto(initialCoordinates())\\r\\n t1.pu()\\r\\n t1.goto(initialCoordinates())\\r\\n t2.pu()\\r\\n t2.goto(initialCoordinates())\\r\\n t3.pu()\\r\\n t3.goto(initialCoordinates())\\r\\n\\r\\n medians4 = sorted(middle_east_countries())\\r\\n t0.goto(-250, (medians4[0])-40)\\r\\n t0.rt(90)\\r\\n for idx in range(1, len(medians4)):\\r\\n t0.pencolor(\\\"BLACK\\\")\\r\\n t0.pd()\\r\\n t0.setpos((-250 + (idx * 26.3)), (2 * (medians4[idx]) + 10))\\r\\n t0.rt(180)\\r\\n\\r\\n medians5 = sorted(north_america_countries())\\r\\n t1.goto(-250, (medians5[0])+60)\\r\\n t1.rt(90)\\r\\n for idx in range(1, len(medians5)):\\r\\n t1.pencolor(\\\"YELLOW\\\")\\r\\n t1.pd()\\r\\n t1.setpos((-250 + (idx * 485.3)), (2 * (medians5[idx]) + 10))\\r\\n t1.rt(180)\\r\\n\\r\\n medians6 = sorted(east_asia_pacific_countries())\\r\\n t2.goto(-250, (medians6[0]))\\r\\n t2.rt(90)\\r\\n for idx in range(1, len(medians6)):\\r\\n t2.pencolor(\\\"purple\\\")\\r\\n t2.pd()\\r\\n t2.setpos((-250 + (idx * 16)), (2 * (medians6[idx]) + 10))\\r\\n t0.pu()\\r\\n t0.goto(initialCoordinates())\\r\\n t1.pu()\\r\\n t1.goto(initialCoordinates())\\r\\n t2.pu()\\r\\n t2.goto(initialCoordinates())\",\n \"def show(self):\\r\\n wlight.lightController.redraw()\",\n \"def dump(self, contents=False):\\n print(self)\\n for region in self.regions:\\n print(region)\\n hexdump(region.data, address=region.address)\",\n \"def __init__(self, *args, **kwargs):\\n _gdi_.RegionIterator_swiginit(self,_gdi_.new_RegionIterator(*args, **kwargs))\",\n \"def show_editor(self):\\r\\n self.frame.Show()\\r\\n self.frame.Raise()\",\n \"def get_regions(self):\\n return self._regions\",\n \"def AddRegions(self, **kwargs):\\n # Addregions use pixel coordinates. listRegions and SaveRegions use RA and Dec.\\n n_objs = 0\\n objs = []\\n # default shape is circle\\n if not 'shape' in kwargs:\\n kwargs['shape'] = ['circle']\\n for k in kwargs.keys():\\n n_objs = max(n_objs, len(kwargs[k]))\\n for j in range(n_objs):\\n temp = {}\\n for k in kwargs.keys():\\n try:\\n temp[k] = kwargs[k][j]\\n except IndexError:\\n if k == 'shape': \\n temp[k] = 'circle'\\n objs.append(temp)\\n self.all_objs = json.dumps(objs)\\n command = \\\"JS9.AddRegions({objs}, {{display:'{wid}{suffix}'}})\\\".format(objs=self.all_objs, wid=self.wid, suffix=self.suffix)\\n get_ipython().run_cell_magic('javascript', '', command)\",\n \"def closeRegions(regions):\\n for orig,table in regions.items():\\n for dest in table['neighbors']:\\n if not regions.has_key(dest):\\n regions[dest] = {'neighbors': set(),\\n 'value': 4}\\n regions[dest]['neighbors'].add(orig)\\n return regions\",\n \"def show_custom_graph(self):\\n pass\",\n \"def draw_pins():\\n\\n pass\",\n \"def __init__(self, machine):\\n super().__init__(machine)\\n self.features['has_segment_displays'] = True\",\n \"def selected(self):\\n\\t\\treturn [self.regions[int(i)]\\n\\t\\t\\tfor i in self.regionListing.hlist.info_selection()]\",\n \"def GetRegionVertices(self, *float, **kwargs):\\n ...\",\n \"def onShow(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65240884","0.6408818","0.633112","0.6262963","0.60573566","0.6022681","0.5926789","0.59011424","0.5846541","0.58321047","0.58177316","0.58080935","0.579175","0.57498974","0.574381","0.57271105","0.57197857","0.5711749","0.5662972","0.5655112","0.56491876","0.5622425","0.56209105","0.56059074","0.55292904","0.5516262","0.55055076","0.5467674","0.54446423","0.5437959","0.5433966","0.5423593","0.54166406","0.5414651","0.53995425","0.5398083","0.5395779","0.5387426","0.5385652","0.5383597","0.53689855","0.53468853","0.53460926","0.534266","0.5341873","0.5336265","0.53305393","0.5328057","0.53214234","0.53178257","0.5313034","0.53062683","0.5300189","0.5291474","0.5290336","0.52869856","0.5284048","0.52823746","0.52790594","0.5268943","0.5261732","0.5250759","0.52496815","0.5228468","0.52284473","0.5227895","0.5227312","0.52262247","0.52249503","0.521733","0.5216795","0.5215314","0.52133065","0.52124393","0.52103144","0.52091247","0.52051324","0.52048117","0.51984316","0.51970255","0.5192788","0.51917964","0.51908714","0.51898736","0.51858306","0.5178593","0.51777303","0.517518","0.5172809","0.5169568","0.51665676","0.51463366","0.5144836","0.5135942","0.5131873","0.5129562","0.5126475","0.5123548","0.51220477","0.5119143","0.51180035"],"string":"[\n \"0.65240884\",\n \"0.6408818\",\n \"0.633112\",\n \"0.6262963\",\n \"0.60573566\",\n \"0.6022681\",\n \"0.5926789\",\n \"0.59011424\",\n \"0.5846541\",\n \"0.58321047\",\n \"0.58177316\",\n \"0.58080935\",\n \"0.579175\",\n \"0.57498974\",\n \"0.574381\",\n \"0.57271105\",\n \"0.57197857\",\n \"0.5711749\",\n \"0.5662972\",\n \"0.5655112\",\n \"0.56491876\",\n \"0.5622425\",\n \"0.56209105\",\n \"0.56059074\",\n \"0.55292904\",\n \"0.5516262\",\n \"0.55055076\",\n \"0.5467674\",\n \"0.54446423\",\n \"0.5437959\",\n \"0.5433966\",\n \"0.5423593\",\n \"0.54166406\",\n \"0.5414651\",\n \"0.53995425\",\n \"0.5398083\",\n \"0.5395779\",\n \"0.5387426\",\n \"0.5385652\",\n \"0.5383597\",\n \"0.53689855\",\n \"0.53468853\",\n \"0.53460926\",\n \"0.534266\",\n \"0.5341873\",\n \"0.5336265\",\n \"0.53305393\",\n \"0.5328057\",\n \"0.53214234\",\n \"0.53178257\",\n \"0.5313034\",\n \"0.53062683\",\n \"0.5300189\",\n \"0.5291474\",\n \"0.5290336\",\n \"0.52869856\",\n \"0.5284048\",\n \"0.52823746\",\n \"0.52790594\",\n \"0.5268943\",\n \"0.5261732\",\n \"0.5250759\",\n \"0.52496815\",\n \"0.5228468\",\n \"0.52284473\",\n \"0.5227895\",\n \"0.5227312\",\n \"0.52262247\",\n \"0.52249503\",\n \"0.521733\",\n \"0.5216795\",\n \"0.5215314\",\n \"0.52133065\",\n \"0.52124393\",\n \"0.52103144\",\n \"0.52091247\",\n \"0.52051324\",\n \"0.52048117\",\n \"0.51984316\",\n \"0.51970255\",\n \"0.5192788\",\n \"0.51917964\",\n \"0.51908714\",\n \"0.51898736\",\n \"0.51858306\",\n \"0.5178593\",\n \"0.51777303\",\n \"0.517518\",\n \"0.5172809\",\n \"0.5169568\",\n \"0.51665676\",\n \"0.51463366\",\n \"0.5144836\",\n \"0.5135942\",\n \"0.5131873\",\n \"0.5129562\",\n \"0.5126475\",\n \"0.5123548\",\n \"0.51220477\",\n \"0.5119143\",\n \"0.51180035\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88989,"cells":{"query":{"kind":"string","value":"Construct a basic RNN cell. It is configured to be passed to a multi rnn cell wrapper."},"document":{"kind":"string","value":"def build_rnn_cell(type, num_units, dropout):\n cell = tf.nn.rnn_cell.BasicRNNCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result"},"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 create_rnn_cell(num_units,\n num_layers,\n num_residual_layers,\n dropout,\n mode,\n num_gpus,\n base_gpu=0,\n single_cell_fn=None,\n all_layer_outputs=False):\n cell_list = _cell_list(\n num_units=num_units,\n num_layers=num_layers,\n num_residual_layers=num_residual_layers,\n dropout=dropout,\n mode=mode,\n num_gpus=num_gpus,\n base_gpu=base_gpu,\n single_cell_fn=single_cell_fn)\n\n if len(cell_list) == 1: # Single layer.\n return cell_list[0]\n else: # Multi layers\n print(all_layer_outputs, \"all_layer_outputs\")\n\n if all_layer_outputs:\n return MultiRNNCell(cell_list)\n else:\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)","def build_multi_rnn(cells):\n return tf.nn.rnn_cell.MultiRNNCell(cells)","def __init__(self, rnn_cell, batch_size,\n input_size, num_outputs):\n super().__init__(name='RNNCellStateModel')\n self._rnn_cell = rnn_cell\n self._batch_size = batch_size\n self._input_size = input_size\n self._num_outputs = num_outputs","def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\n if is_train:\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\n return cell","def MakeFancyRNNCell(H, keep_prob, num_layers=1):\n cells = []\n for _ in range(num_layers):\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cells.append(cell)\n return tf.nn.rnn_cell.MultiRNNCell(cells)","def _create_rnn_cells(self, is_list=False):\n\n stacked_rnn = []\n for _ in range(self.num_layers):\n single_cell = self._rnn_single_cell()\n stacked_rnn.append(single_cell)\n\n if is_list:\n return stacked_rnn\n else:\n return tf.nn.rnn_cell.MultiRNNCell(\n cells=stacked_rnn,\n state_is_tuple=True)","def __call__(self, inputs, state, scope=None, *args, **kwargs):\r\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\r\n # Instead, it is up to subclasses to provide a proper build\r\n # method. See the class docstring for more details.\r\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\r\n *args, **kwargs)","def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\n if layer_type == \"layernorm_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\n else:\n if layer_type == \"lstm\":\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\n elif layer_type == \"gru\":\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_gru\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\n else:\n raise ValueError(\"Error: not supported rnn type:{}\".format(layer_type))\n\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, output_keep_prob=dropout_keep_prob)\n return cell","def build_rnn(cell, inputs):\n #_,initial_state = get_init_cell(batch_size, rnn_size)\n \n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name='final_state')\n\n return (output, final_state)","def __init__(self,\n num_units,\n num_dims=1,\n input_dims=None,\n output_dims=None,\n priority_dims=None,\n non_recurrent_dims=None,\n tied=False,\n cell_fn=None,\n non_recurrent_fn=None,\n state_is_tuple=True,\n output_is_tuple=True):\n if not state_is_tuple:\n logging.warning('%s: Using a concatenated state is slower and will '\n 'soon be deprecated. Use state_is_tuple=True.', self)\n if not output_is_tuple:\n logging.warning('%s: Using a concatenated output is slower and will '\n 'soon be deprecated. Use output_is_tuple=True.', self)\n\n if num_dims < 1:\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\n\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\n priority_dims, non_recurrent_dims,\n non_recurrent_fn or nn.relu, tied,\n num_units)\n\n self._state_is_tuple = state_is_tuple\n self._output_is_tuple = output_is_tuple\n\n if cell_fn is None:\n my_cell_fn = functools.partial(\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\n else:\n my_cell_fn = lambda: cell_fn(num_units)\n if tied:\n self._cells = [my_cell_fn()] * num_dims\n else:\n self._cells = [my_cell_fn() for _ in range(num_dims)]\n if not isinstance(self._cells[0], rnn.RNNCell):\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\n type(self._cells[0]))\n\n if self._output_is_tuple:\n self._output_size = tuple(self._cells[0].output_size\n for _ in self._config.outputs)\n else:\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\n\n if self._state_is_tuple:\n self._state_size = tuple(self._cells[0].state_size\n for _ in self._config.recurrents)\n else:\n self._state_size = self._cell_state_size() * len(self._config.recurrents)","def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\n readout_init, readout_apply = stax.Dense(num_outputs)\n\n def init_fun(key, input_shape):\n \"\"\"Initialize the components of the RNN.\n\n Args:\n key: Jax PRNGkey used to initialize the parameters.\n input_shape: tuple representing the input shape, should be\n (batch_size, sequence_length).\n\n Returns:\n shapes: set of tuples representing the shapes after applying\n the Embedding, RNN Cell, and Readout layers.\n network_params: tuple of network parameters, containing the\n embedding, RNN cell, and readout parameters.\n \"\"\"\n\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\n\n # Initialize the Embedding for the input tokens.\n emb_shape, emb_params = emb_init(emb_key, input_shape)\n\n # The cell is defined for a single update step, which is why we ignore\n # the sequence dimension (emb_shape[1]) here.\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\n\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\n\n shapes = (emb_shape, rnn_shape, output_shape)\n network_params = (emb_params, rnn_params, readout_params)\n\n return shapes, network_params\n\n def apply_fun(network_params, tokens):\n \"\"\"Applies the RNN on a batch of input sequences.\n\n Args:\n network_params: tuple of network parameters (see init_fun).\n tokens: batch of inputs, with shape (batch_size, sequence_length).\n\n Returns:\n outputs: network outputs, at every step along the sequence.\n \"\"\"\n emb_params, rnn_params, readout_params = network_params\n\n # Apply the embedding.\n inputs = emb_apply(emb_params, tokens)\n\n # Run the RNN.\n initial_states = cell.get_initial_state(rnn_params,\n batch_size=tokens.shape[0])\n return unroll.unroll_rnn(initial_states, inputs,\n functools.partial(cell.batch_apply, rnn_params),\n functools.partial(readout_apply, readout_params))\n\n return init_fun, apply_fun, emb_apply, readout_apply","def make_cell(self, unit_type, num_units, forget_bias, dropout,\n mode, residual_connection=False):\n\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\n dropout = dropout if mode == tf.contrib.learn.ModeKeys.TRAIN else 0.0\n\n # Cell Type\n if unit_type == \"lstm\":\n cell = tf.contrib.rnn.BasicLSTMCell(\n num_units,\n forget_bias=forget_bias)\n elif unit_type == \"gru\":\n cell = tf.contrib.rnn.GRUCell(num_units)\n elif unit_type == \"layer_norm_lstm\":\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units,\n forget_bias=forget_bias,\n layer_norm=True)\n else:\n raise ValueError(\"Unknown unit type %s!\" % unit_type)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n cell = tf.contrib.rnn.DropoutWrapper(\n cell=cell, input_keep_prob=(1.0 - dropout))\n\n # Residual\n if residual_connection:\n cell = tf.contrib.rnn.ResidualWrapper(cell)\n\n return cell","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(RCRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = ResidualCNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=2,\n )\n #self.rnn2 = BidirectionalGRU(\n # n_in=nb_in*2,\n # n_hidden=n_RNN_cell,\n # dropout=dropout_recurrent,\n # num_layers=1,\n #)\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.relu = nn.ReLU()\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def _create_rnn_cell(num_units, num_layers, mode):\n\n cell_list = []\n for i in range(num_layers):\n single_cell = STLSTMCell(name=\"stlstm\",\n num_units=num_units,\n st_activation=tf.nn.relu,\n st_kernel_initializer=tf.glorot_uniform_initializer(),\n st_num_layers=2,\n st_residual=True)\n cell_list.append(single_cell)\n\n return cell_list","def constructCell():\n\t\tself.weightGenerate()","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(CRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = CNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=n_layers_RNN,\n )\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def __init__(self, cell, attn_inputs, \n attn_size, attn_vec_size,\n output_size=None, input_size=None, \n state_is_tuple=True, attn_masks=None,\n merge_output_attn='linear',\n reuse=None):\n if not isinstance(cell, rnn.RNNCell):\n raise TypeError(\"The parameter cell is not RNNCell.\")\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\n raise ValueError(\"Cell returns tuple of states, but the flag \"\n \"state_is_tuple is not set. State size is: %s\"\n % str(cell.state_size))\n if not state_is_tuple:\n logging.warn(\n \"%s: Using a concatenated state is slower and will soon be \"\n \"deprecated. Use state_is_tuple=True.\", self)\n\n self._state_is_tuple = state_is_tuple\n\n if not state_is_tuple:\n raise NotImplementedError\n\n self._cell = cell\n self._input_size = input_size\n self._output_size = output_size\n if output_size is None:\n self._output_size = cell.output_size\n self._attn_size = attn_size\n self._reuse = reuse\n self._attn_inputs = attn_inputs\n self._attn_vec_size = attn_vec_size\n self.attn_masks = attn_masks\n self.merge_output_attn = merge_output_attn","def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\n cells = []\n for layer_size in rnn_cell_size:\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\n if attn_len and not cells:\n # Add attention wrapper to first layer.\n cell = tf.contrib.rnn.AttentionCellWrapper(\n cell, attn_len, state_is_tuple=True)\n cell = tf.contrib.rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return tf.contrib.rnn.MultiRNNCell(cells)","def __init__(self, input_size, hidden_size, output_size, model=\"gru\", n_layers=1):\n \n super(CharRNN, self).__init__()\n\n self.input_size = input_size\n self.hidden_size = hidden_size\n self.output_size = output_size\n self.n_layers = n_layers\n\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\n \n self.model = model\n if model.lower() == \"lstm\":\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\n else: # model is GRU\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\n\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer","def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\n is_batch_norm, is_bidirectional):\n if is_batch_norm:\n input_data = tf.keras.layers.BatchNormalization(\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\n rnn_layer = rnn_cell(\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\n name=\"rnn_{}\".format(layer_id))\n if is_bidirectional:\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\"sum\")\n\n return rnn_layer(input_data)","def build_rnn(cell, inputs):\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name=\"final_state\")\n\n return outputs, final_state","def _initialize_gru_cell(self, num_units):\n return gru_cell.LayerNormGRUCell(\n num_units,\n w_initializer=self.uniform_initializer,\n u_initializer=random_orthonormal_initializer,\n b_initializer=tf.constant_initializer(0.0))","def get_init_cell(batch_size, rnn_size):\n\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\n num_of_layers = 3\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name='initial_state')\n \n return (cell, initial_state)","def custom_rnn(cell, inputs, initial_state=None, dtype=None,\r\n sequence_length=None, scope=None):\r\n\r\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\r\n raise TypeError(\"cell must be an instance of RNNCell\")\r\n if not nest.is_sequence(inputs):\r\n raise TypeError(\"inputs must be a sequence\")\r\n if not inputs:\r\n raise ValueError(\"inputs must not be empty\")\r\n\r\n outputs = []\r\n states = []\r\n # Create a new scope in which the caching device is either\r\n # determined by the parent scope, or is set to place the cached\r\n # Variable using the same placement as for the rest of the RNN.\r\n with vs.variable_scope(scope or \"RNN\") as varscope:\r\n if varscope.caching_device is None:\r\n varscope.set_caching_device(lambda op: op.device)\r\n\r\n # Obtain the first sequence of the input\r\n first_input = inputs\r\n while nest.is_sequence(first_input):\r\n first_input = first_input[0]\r\n\r\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\r\n # TODO(lukaszkaiser): remove EmbeddingWrapper\r\n if first_input.get_shape().ndims != 1:\r\n\r\n input_shape = first_input.get_shape().with_rank_at_least(2)\r\n fixed_batch_size = input_shape[0]\r\n\r\n flat_inputs = nest.flatten(inputs)\r\n for flat_input in flat_inputs:\r\n input_shape = flat_input.get_shape().with_rank_at_least(2)\r\n batch_size, input_size = input_shape[0], input_shape[1:]\r\n fixed_batch_size.merge_with(batch_size)\r\n for i, size in enumerate(input_size):\r\n if size.value is None:\r\n raise ValueError(\r\n \"Input size (dimension %d of inputs) must be accessible via \"\r\n \"shape inference, but saw value None.\" % i)\r\n else:\r\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\r\n\r\n if fixed_batch_size.value:\r\n batch_size = fixed_batch_size.value\r\n else:\r\n batch_size = array_ops.shape(first_input)[0]\r\n if initial_state is not None:\r\n state = initial_state\r\n else:\r\n if not dtype:\r\n raise ValueError(\"If no initial_state is provided, \"\r\n \"dtype must be specified\")\r\n state = cell.zero_state(batch_size, dtype)\r\n\r\n if sequence_length is not None: # Prepare variables\r\n sequence_length = ops.convert_to_tensor(\r\n sequence_length, name=\"sequence_length\")\r\n if sequence_length.get_shape().ndims not in (None, 1):\r\n raise ValueError(\r\n \"sequence_length must be a vector of length batch_size\")\r\n def _create_zero_output(output_size):\r\n # convert int to TensorShape if necessary\r\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\r\n output = array_ops.zeros(\r\n array_ops.pack(size), _infer_state_dtype(dtype, state))\r\n shape = _state_size_with_prefix(\r\n output_size, prefix=[fixed_batch_size.value])\r\n output.set_shape(tensor_shape.TensorShape(shape))\r\n return output\r\n\r\n output_size = cell.output_size\r\n flat_output_size = nest.flatten(output_size)\r\n flat_zero_output = tuple(\r\n _create_zero_output(size) for size in flat_output_size)\r\n zero_output = nest.pack_sequence_as(structure=output_size,\r\n flat_sequence=flat_zero_output)\r\n\r\n sequence_length = math_ops.to_int32(sequence_length)\r\n min_sequence_length = math_ops.reduce_min(sequence_length)\r\n max_sequence_length = math_ops.reduce_max(sequence_length)\r\n\r\n for time, input_ in enumerate(inputs):\r\n if time > 0: varscope.reuse_variables()\r\n # pylint: disable=cell-var-from-loop\r\n call_cell = lambda: cell(input_, state)\r\n # pylint: enable=cell-var-from-loop\r\n if sequence_length is not None:\r\n (output, state) = _rnn_step(\r\n time=time,\r\n sequence_length=sequence_length,\r\n min_sequence_length=min_sequence_length,\r\n max_sequence_length=max_sequence_length,\r\n zero_output=zero_output,\r\n state=state,\r\n call_cell=call_cell,\r\n state_size=cell.state_size)\r\n else:\r\n (output, state) = call_cell()\r\n\r\n outputs.append(output)\r\n states.append(state)\r\n\r\n return (outputs, state, states)","def __init__(self, context, problem, update_rate=1, debug=False):\n tf.keras.layers.AbstractRNNCell.__init__(self)\n self.context = context\n self.problem = problem\n\n if hasattr(self.context, 'scale'):\n self.scale = self.context.scale\n else:\n self.scale = 1\n\n self.debug = debug\n\n # shape related information\n self.batch_size = self.context.batch_size\n self.dim_x = self.context.dim_x\n self.dim_z = self.context.dim_z\n self.dim_u = self.context.dim_u\n\n # rate at which observations are taken into account\n self.update_rate = tf.ones([], dtype=tf.float32) * update_rate\n\n self.filter_layers = []","def _single_cell(num_units,\n dropout,\n mode,\n residual_connection=False,\n device_str=None):\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\n\n # Cell Type\n utils.print_out(\" GRU\", new_line=False)\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n utils.print_out(\n \" %s, dropout=%g \" % (type(single_cell).__name__, dropout),\n new_line=False)\n\n # Residual\n if residual_connection:\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\n utils.print_out(\" %s\" % type(single_cell).__name__, new_line=False)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\n utils.print_out(\n \" %s, device=%s\" % (type(single_cell).__name__, device_str),\n new_line=False)\n\n return single_cell","def resnet10(shortcut_type, num_classes, in_channels):\n model = ResNet(BasicBlock, [1, 1, 1, 1], shortcut_type, num_classes, in_channels)\n return model","def create_model():\n\n class Net(nn.Cell):\n def construct(self, x, y):\n return x\n\n net = Net()\n model_simple = Model(net)\n\n return model_simple","def __init__(self, cell_index, stimulus_type, loss='poisson_loss', optimizer='sgd',\n weight_init='glorot_normal', l2_reg=0., mean_adapt=False):\n\n self.stim_shape = (40, 50, 50)\n\n # build the model (flatten the input, followed by a dense layer and\n # softplus activation)\n with notify('Building LN model'):\n self.model = Sequential()\n self.model.add(Flatten(input_shape=self.stim_shape))\n self.model.add(Dense(1, activation='softplus', init=weight_init,\n W_regularizer=l2(l2_reg)))\n\n # save architecture string (for markdown file)\n self.architecture = '\\n'.join(['l2 regularization: {}'.format(l2_reg),\n 'stimulus shape: {}'.format(self.stim_shape),\n 'weight initialization: {}'.format(weight_init)])\n\n # compile\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embedding = get_embed(input_data, vocab_size, rnn_size)\n outputs, final_state = build_rnn(cell, embedding)\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\n\n return logits, final_state","def rnn_cell(hprev, zt, name=None, reuse=False):\n nin = zt.shape[-1].value\n nout = hprev.shape[-1].value\n with tf.variable_scope(name, default_name=\"rnn\", values=[hprev, zt], reuse=reuse):\n wz = get_variable_wrap(\"kernel/input\", [nin, nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n wh = get_variable_wrap(\"kernel/hidden\", [nout, nout],dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n bh = get_variable_wrap(\"bias\", [nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n \n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)","def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\n cells = []\n for layer_size in rnn_cell_size:\n cell = rnn.LSTMBlockCell(layer_size)\n cell = rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return rnn.MultiRNNCell(cells)","def get_init_cell(batch_size, rnn_size):\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name=\"initial_state\")\n\n return cell, initial_state","def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\n # todo 1、获取嵌入层的输出\n embed = get_embed(input_data, vocab_size, embed_dim)\n # todo-2、获取 隐藏层的输出\n rnn_outputs, final_state, final_state1 = build_rnn(\n cell, embed, initial_state=initial_state)\n # 3、构建全连接，获取logits\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\n # [N, n-steps, num_classes]\n return logits, final_state, final_state1","def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\n residual_connection=False, device_str=None):\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\n dropout = dropout if mode == \"train\" else 0.0\n # Cell Type\n if unit_type == \"lstm\":\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\n\n elif unit_type == \"gru\":\n single_cell = tf.contrib.rnn.GRUCell(num_units)\n\n elif unit_type == \"layer_norm_lstm\":\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units,layer_norm=True)\n else:\n raise ValueError(\"Unknown unit type %s!\" % unit_type)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.contrib.rnn.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n\n # Residual\n if residual_connection:\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\n\n return single_cell","def __init__(self, layers, rnnType, seqLength=128, outputDim=None, activation=None, dropout=0.0):\n model = utils.buildRNN(layers, rnnType, dropout)\n super().__init__(torch.nn.Sequential(model), nnType='rnn')\n \n self.seqLength = seqLength\n if outputDim is not None:\n self.update(DNN([layers[-1]*seqLength, outputDim], [activation]).model)\n self.nnType = 'rnn-mlp'","def __init__(self,\n shape,\n kernel,\n depth,\n use_peepholes=False,\n cell_clip=None,\n initializer=None,\n forget_bias=1.0,\n activation=None,\n normalize=None,\n dropout=None,\n reuse=None):\n super(ConvLSTMCell, self).__init__(_reuse=reuse)\n\n tf_shape = tf.TensorShape(shape + [depth])\n self._output_size = tf_shape\n self._state_size = tf.nn.rnn_cell.LSTMStateTuple(tf_shape, tf_shape)\n\n self._kernel = kernel\n self._depth = depth\n self._use_peepholes = use_peepholes\n self._cell_clip = cell_clip\n self._initializer = initializer\n self._forget_bias = forget_bias\n self._activation = activation or tf.nn.tanh\n self._normalize = normalize\n self._dropout = dropout\n\n self._w_conv = None\n if self._use_peepholes:\n self._w_f_diag = None\n self._w_i_diag = None\n self._w_o_diag = None","def __init__(self, num_units,\n use_peepholes=False, cell_clip=None,\n initializer=None, num_proj=None, proj_clip=None,\n num_unit_shards=None, num_proj_shards=None,\n forget_bias=1.0, state_is_tuple=False,\n activation=None, trainable=None, name=None, dtype=None, residual_connection=False, **kwargs):\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n if not state_is_tuple:\n logging.warn(\"%s: Using a concatenated state is slower and will soon be \"\n \"deprecated. Use state_is_tuple=True.\", self)\n if num_unit_shards is not None or num_proj_shards is not None:\n logging.warn(\n \"%s: The num_unit_shards and proj_unit_shards parameters are \"\n \"depreca ted and will be removed in Jan 2017. \"\n \"Use a variable scope with a partitioner instead.\", self)\n if context.executing_eagerly() and context.num_gpus() > 0:\n logging.warn(\"%s: Note that this cell is not optimized for performance. \"\n \"Please use tf.contrib.cudnn_rnn.CudnnLSTM for better \"\n \"performance on GPU.\", self)\n self._num_units = num_units\n self._use_peepholes = use_peepholes\n self._cell_clip = cell_clip\n self._initializer = initializers.get(initializer)\n self._num_proj = num_proj\n self._proj_clip = proj_clip\n self._num_unit_shards = num_unit_shards\n self._num_proj_shards = num_proj_shards\n self._forget_bias = forget_bias\n self._state_is_tuple = state_is_tuple\n self.residual_connection = residual_connection\n self._kernel = None\n self._bias = None\n self._w_f_diag = None\n self._w_i_diag = None\n self._w_o_diag = None\n self._proj_kernel = None\n if activation:\n self._activation = activations.get(activation)\n else:\n self._activation = math_ops.tanh\n\n if num_proj:\n self.state_size = [num_proj, num_units]\n self._output_size = num_proj\n\n else:\n self._state_size = [num_units, num_units]\n self._output_size = num_units","def __init__(self, num_nodes, h_dim, out_dim, num_rels,\n num_bases=-1, num_hidden_layers=1, dropout=0.5, bias=False):\n super(RGCN, self).__init__()\n self.num_nodes = num_nodes\n self.h_dim = h_dim\n self.out_dim = out_dim\n self.num_rels = num_rels\n self.num_bases = num_bases\n self.num_hidden_layers = num_hidden_layers\n self.dropout = dropout\n self.bias = bias\n\n self.layers = nn.ModuleList()\n # create rgcn layers\n self.build_model()","def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\n if rnn_type.endswith('lstm'):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n elif rnn_type.endswith('gru'):\n cell = tc.rnn.GRUCell(num_units=hidden_size)\n elif rnn_type.endswith('rnn'):\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\n else:\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n if layer_num > 1:\n cell = tc.rnn.MultiRNNCell([cell] * layer_num, state_is_tuple=True)\n return cell","def __init__(self,\n num_units,\n use_peepholes=False,\n cell_clip=None,\n initializer=None,\n num_proj=None,\n proj_clip=None,\n num_unit_shards=None,\n num_proj_shards=None,\n forget_bias=1.0,\n state_is_tuple=True,\n activation=None,\n reuse=None):\n super(MaskedLSTMCell, self).__init__(\n num_units,\n use_peepholes=use_peepholes,\n cell_clip=cell_clip,\n initializer=initializer,\n num_proj=num_proj,\n proj_clip=proj_clip,\n num_unit_shards=num_unit_shards,\n num_proj_shards=num_proj_shards,\n forget_bias=forget_bias,\n state_is_tuple=state_is_tuple,\n activation=activation,\n reuse=reuse)","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embed = get_embed(input_data, vocab_size, embed_dim) \n output, final_state = build_rnn(cell, embed)\n \n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\n #final_state = tf.identity(final_state, name='final_state') \n return logits, final_state","def __init__(self,\n layer,\n train_batch=1,\n query_batch=1,\n num_steps=1,\n init_lr=0.2,\n initializer=tf.contrib.layers.xavier_initializer(),\n loss=batched_mse,\n flatten_output=True,\n reuse=None):\n super(Cell, self).__init__(_reuse=reuse)\n self._layer = layer\n self._train_batch = train_batch\n self._query_batch = query_batch\n self._num_steps = num_steps\n self._init_lr = init_lr\n self._initializer = initializer\n self._loss = loss\n self._flatten_output = flatten_output","def single_cell(\n cell_class,\n cell_params,\n dp_input_keep_prob=1.0,\n dp_output_keep_prob=1.0,\n recurrent_keep_prob=1.0,\n input_weight_keep_prob=1.0,\n recurrent_weight_keep_prob=1.0,\n weight_variational=False,\n dropout_seed=None,\n zoneout_prob=0.,\n training=True,\n residual_connections=False,\n awd_initializer=False,\n variational_recurrent=False, # in case they want to use DropoutWrapper\n dtype=None,\n):\n if awd_initializer:\n val = 1.0/math.sqrt(cell_params['num_units'])\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\n if recurrent_keep_prob < 1.0:\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\n if input_weight_keep_prob < 1.0:\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\n if recurrent_weight_keep_prob < 1.0:\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\n if weight_variational:\n cell_params['weight_variational'] = weight_variational # which is basically True\n if dropout_seed:\n cell_params['dropout_seed'] = dropout_seed\n\n\n cell = cell_class(**cell_params)\n if residual_connections:\n cell = ResidualWrapper(cell)\n if zoneout_prob > 0. and (\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\n ):\n raise ValueError(\n \"Currently applying both dropout and zoneout on the same cell.\"\n \"This is currently not supported.\"\n )\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\n cell = DropoutWrapper(\n cell,\n input_keep_prob=dp_input_keep_prob,\n output_keep_prob=dp_output_keep_prob,\n variational_recurrent=variational_recurrent,\n dtype=dtype,\n seed=dropout_seed\n )\n if zoneout_prob > 0.:\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\n return cell","def _rnn_cells(self) -> RNNCellTuple:\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))","def init_gru(rnn):\n\n def _concat_init(tensor, init_funcs):\n (length, fan_out) = tensor.shape\n fan_in = length // len(init_funcs)\n\n for (i, init_func) in enumerate(init_funcs):\n init_func(tensor[i * fan_in: (i + 1) * fan_in, :])\n\n def _inner_uniform(tensor):\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\n\n for i in range(rnn.num_layers):\n _concat_init(\n getattr(rnn, 'weight_ih_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, _inner_uniform]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\n\n _concat_init(\n getattr(rnn, 'weight_hh_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)","def lstm_cell():\n if 'reuse' in inspect.getargspec(\n tf.contrib.rnn.BasicLSTMCell.__init__).args:\n return tf.contrib.rnn.BasicLSTMCell(\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True,\n reuse=tf.get_variable_scope().reuse)\n else:\n return tf.contrib.rnn.BasicLSTMCell(\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True)","def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\n\t\treturn _mh.create_rnn_cell(\n\t\t\tunit_type=hparams.unit_type,\n\t\t\tnum_units=self.num_units,\n\t\t\tnum_layers=num_layers,\n\t\t\tnum_residual_layers=num_residual_layers,\n\t\t\tforget_bias=hparams.forget_bias,\n\t\t\tdropout=hparams.dropout,\n\t\t\tmode=self.mode)","def init_gru(rnn):\n \n def _concat_init(tensor, init_funcs):\n (length, fan_out) = tensor.shape\n fan_in = length // len(init_funcs)\n \n for (i, init_func) in enumerate(init_funcs):\n init_func(tensor[i * fan_in : (i + 1) * fan_in, :])\n \n def _inner_uniform(tensor):\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\n \n for i in range(rnn.num_layers):\n _concat_init(\n getattr(rnn, 'weight_ih_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, _inner_uniform]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\n\n _concat_init(\n getattr(rnn, 'weight_hh_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)","def setup_rnn_model(default_ctx,\n num_lstm_layer, \n num_hidden,\n batch_size,\n initializer,\n group2ctx=None, concat_decode=True,\n use_loss=False, buckets=None):\n max_len = n_steps\n max_rnn_exec = None\n rnn_sym = lstm_unroll(num_lstm_layer=num_lstm_layer,\n num_hidden=num_hidden)\n arg_names = rnn_sym.list_arguments()\n internals = rnn_sym.get_internals()\n\n input_shapes = {}\n for name in arg_names:\n if name.endswith(\"init_c\") or name.endswith(\"init_h\"):\n input_shapes[name] = (batch_size, num_hidden)\n elif name.endswith(\"data\"):\n input_shapes[name] = (batch_size,MAX_LEN)\n elif name == \"labels\":\n input_shapes[name] = (batch_size,MAX_LEN)\n elif name.endswith(\"label\"):\n input_shapes[name] = (batch_size, )\n else:\n pass\n\n arg_shape, out_shape, aux_shape = rnn_sym.infer_shape(**input_shapes)\n # bind arrays\n arg_arrays = []\n args_grad = {}\n for shape, name in zip(arg_shape, arg_names):\n group = internals[name].attr(\"ctx_group\")\n ctx = group2ctx[group] if group is not None else default_ctx\n arg_arrays.append(mx.nd.zeros(shape, ctx))\n if is_param_name(name):\n args_grad[name] = mx.nd.zeros(shape, ctx)\n if not name.startswith(\"t\"):\n print(\"%s group=%s, ctx=%s\" % (name, group, str(ctx)))\n \n #bind with shared executor\n rnn_exec = None\n rnn_exec = rnn_sym.bind(default_ctx, args=arg_arrays,\n args_grad=args_grad,\n grad_req=\"add\", group2ctx=group2ctx)\n max_rnn_exec = rnn_exec\n \n\n param_blocks = []\n arg_dict = dict(zip(arg_names, rnn_exec.arg_arrays))\n for i, name in enumerate(arg_names):\n if is_param_name(name):\n initializer(name, arg_dict[name])\n param_blocks.append((i, arg_dict[name], args_grad[name], name))\n else:\n assert name not in args_grad\n\n out_dict = dict(zip(rnn_sym.list_outputs(), rnn_exec.outputs))\n\n init_states = [LSTMState(c=arg_dict[\"l%d_init_c\" % i],\n h=arg_dict[\"l%d_init_h\" % i]) for i in range(num_lstm_layer)]\n\n seq_data = rnn_exec.arg_dict[\"data\"]\n # we don't need to store the last state \n last_states = None\n\n seq_outputs = [out_dict[\"sm_output\"]]\n seq_labels = [rnn_exec.arg_dict[\"labels\"]]\n\n model = LSTMModel(rnn_exec=rnn_exec, symbol=rnn_sym,\n init_states=init_states, last_states=last_states,\n seq_data=seq_data, seq_labels=seq_labels, seq_outputs=seq_outputs,\n param_blocks=param_blocks)\n return model","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):\n super(ModGRUCell, self).__init__()\n\n self.height, self.width = input_size\n self.input_dim = input_dim\n self.hidden_dim = hidden_dim\n\n self.kernel_size = kernel_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.bias = bias\n\n self.conv1 = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n out_channels=1,\n kernel_size=self.kernel_size,\n padding=self.padding,\n bias=self.bias)\n \n self.conv2 = nn.Conv2d(in_channels=self.input_dim,\n out_channels=self.hidden_dim,\n kernel_size=self.kernel_size,\n padding=self.padding,\n bias=self.bias)","def _create_cell(self,row_number,cell_number):\n cell = Cell(self)\n cell.x = cell_number * self.cell_width\n cell.y = row_number * self.cell_width\n cell.rect.x = cell.x\n cell.rect.y = cell.y\n return cell","def __init__(self, init_grid=None):\n\n self.height = len(init_grid)\n self.width = len(init_grid[0])\n\n self.grid = [[Cell(self, c) for c in row]\n for row in init_grid]\n\n self.g = nx.Graph()\n self.tangle()","def _build_pnasnet_base(\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\n start_cell_num):\n\n # Find where to place the reduction cells or stride normal cells\n reduction_indices = nasnet_utils.calc_reduction_layers(\n hparams.num_cells, hparams.num_reduction_layers)\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\n\n # Note: The None is prepended to match the behavior of _imagenet_stem()\n cell_outputs = [None, hidden_previous, hidden]\n net = hidden\n\n # Run the cells\n for cell_num in range(start_cell_num, hparams.num_cells):\n is_reduction = cell_num in reduction_indices\n stride = 2 if is_reduction else 1\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\n prev_layer = cell_outputs[-2]\n net = normal_cell(\n net,\n scope='cell_{}'.format(cell_num),\n filter_scaling=filter_scaling,\n stride=stride,\n prev_layer=prev_layer,\n cell_num=true_cell_num)\n true_cell_num += 1\n cell_outputs.append(net)\n\n # Final nonlinearity.\n # Note that we have dropped the final pooling, dropout and softmax layers\n # from the default pnasnet version.\n with tf.variable_scope('final_layer'):\n net = tf.nn.relu(net)\n return net","def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\n state_keep_prob=1.0, variational_recurrent=False,\n input_size=None, dtype=None, seed=None,\n dropout_state_filter_visitor=None):\n if not _like_rnncell(cell):\n raise TypeError(\"The parameter cell is not a RNNCell.\")\n if (dropout_state_filter_visitor is not None\n and not callable(dropout_state_filter_visitor)):\n raise TypeError(\"dropout_state_filter_visitor must be callable\")\n self._dropout_state_filter = (\n dropout_state_filter_visitor or _default_dropout_state_filter_visitor)\n with ops.name_scope(\"DropoutWrapperInit\"):\n def tensor_and_const_value(v):\n tensor_value = ops.convert_to_tensor(v)\n const_value = tensor_util.constant_value(tensor_value)\n return (tensor_value, const_value)\n for prob, attr in [(input_keep_prob, \"input_keep_prob\"),\n (state_keep_prob, \"state_keep_prob\"),\n (output_keep_prob, \"output_keep_prob\")]:\n tensor_prob, const_prob = tensor_and_const_value(prob)\n if const_prob is not None:\n if const_prob < 0 or const_prob > 1:\n raise ValueError(\"Parameter %s must be between 0 and 1: %d\"\n % (attr, const_prob))\n setattr(self, \"_%s\" % attr, float(const_prob))\n else:\n setattr(self, \"_%s\" % attr, tensor_prob)\n\n # Set cell, variational_recurrent, seed before running the code below\n self._cell = cell\n self._variational_recurrent = variational_recurrent\n self._seed = seed\n\n self._recurrent_input_noise = None\n self._recurrent_state_noise = None\n self._recurrent_output_noise = None\n\n if variational_recurrent:\n if dtype is None:\n raise ValueError(\n \"When variational_recurrent=True, dtype must be provided\")\n\n def convert_to_batch_shape(s):\n # Prepend a 1 for the batch dimension; for recurrent\n # variational dropout we use the same dropout mask for all\n # batch elements.\n return array_ops.concat(\n ([1], tensor_shape.TensorShape(s).as_list()), 0)\n\n def batch_noise(s, inner_seed):\n shape = convert_to_batch_shape(s)\n return random_ops.random_uniform(shape, seed=inner_seed, dtype=dtype)\n\n if (not isinstance(self._input_keep_prob, numbers.Real) or\n self._input_keep_prob < 1.0):\n if input_size is None:\n raise ValueError(\n \"When variational_recurrent=True and input_keep_prob < 1.0 or \"\n \"is unknown, input_size must be provided\")\n self._recurrent_input_noise = _enumerated_map_structure_up_to(\n input_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"input\", i)),\n input_size)\n self._recurrent_state_noise = _enumerated_map_structure_up_to(\n cell.state_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"state\", i)),\n cell.state_size)\n self._recurrent_output_noise = _enumerated_map_structure_up_to(\n cell.output_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"output\", i)),\n cell.output_size)","def rnn_cell_loop(self):\n\n\t\t# Set up initial state\n\t\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\t\t\t# Spike\n\t\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\t\t\t\t\t# State\n\t\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\n\t\tself.h = [self.h]\n\t\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\n\n\t\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\t\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\n\t\t# Apply the EI mask to the recurrent weights\n\t\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\n\n\t\t# Set up latency buffer if being used\n\t\tif par['use_latency']:\n\t\t\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\n\t\t\tself.state_buffer = deque(self.state_buffer)\n\t\t\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\n\t\t\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\n\n\t\t# Set up output record\n\t\tself.output = []\n\t\tself.syn_x = []\n\t\tself.syn_u = []\n\n\t\ty = 0.\n\t\tfor t in range(par['num_time_steps']):\n\t\t\tself.t = t \t\t# For latency calculations\n\n\t\t\tif par['cell_type'] == 'rate':\n\t\t\t\traise Exception('Rate cell not yet implemented.')\n\t\t\telif par['cell_type'] == 'adex':\n\t\t\t\tif t < 10:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\telse:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\t\t\t\tself.syn_x.append(syn_x)\n\t\t\t\tself.syn_u.append(syn_u)\n\n\t\t\telif par['cell_type'] == 'lif':\n\t\t\t\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\n\t\t# Stack records\n\t\tself.output = tf.stack(self.output, axis=0)\n\t\tself.h = tf.stack(self.h, axis=0)\n\t\tself.h_out = tf.stack(self.h_out, axis=0)\n\t\tself.syn_x = tf.stack(self.syn_x, axis=0)\n\t\tself.syn_u = tf.stack(self.syn_u, axis=0)","def _build_rnn(self, n_cells, hidden_layer_size, num_layers,\n batch_size, time_window, lr):\n\n x_anchor = tf.placeholder(shape=[batch_size, n_cells, time_window],\n dtype=tf.float32)\n x_pos = tf.placeholder(shape=[batch_size, n_cells, time_window],\n dtype=tf.float32)\n x_neg = tf.placeholder(shape=[batch_size, n_cells, time_window,],\n dtype=tf.float32)\n\n def embed_rnn(x_in):\n \"\"\"Gives RNN embedding of x_in.\"\"\"\n x_in_flat = tf.reshape(x_in, [batch_size*time_window, n_cells])\n w_in = tf.get_variable(\"w_in\", shape=[n_cells, hidden_layer_size],\n initializer=tf.random_normal_initializer())\n b_in = tf.get_variable(\"b_in\", shape=[hidden_layer_size],\n initializer=tf.random_normal_initializer())\n x_ld_flat = tf.matmul(x_in_flat, w_in) + b_in\n x_ld = tf.reshape(x_ld_flat, [batch_size, time_window, hidden_layer_size])\n\n # stacked LSTM cells\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_layer_size,\n forget_bias=0.0,\n state_is_tuple=True)\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers,\n state_is_tuple=True)\n\n # compute output\n initial_state = cell.zero_state(batch_size, tf.float32)\n outputs, _ = tf.nn.dynamic_rnn(cell, x_ld,\n initial_state=initial_state,\n time_major=False)\n\n # reconstruct and compute loss on last output only\n outputs_unp = tf.unpack(tf.transpose(outputs, [1, 0, 2]))\n embedding = outputs_unp[-1]\n\n return embedding\n\n def distance_squared(embed1, embed2):\n return tf.reduce_sum((embed1 - embed2)**2, 1)\n\n with tf.variable_scope(\"RNN\") as scope:\n\n # embed anchor, positive and negative examples.\n embed_anchor = embed_rnn(tf.transpose(x_anchor, [0, 2, 1]))\n # This enables reusing the RNN for anchor, pos and neg.\n scope.reuse_variables()\n # Check that we are reusing the same RNN using:\n # print(tf.get_variable_scope().reuse)\n embed_pos = embed_rnn(tf.transpose(x_pos, [0, 2, 1]))\n embed_neg = embed_rnn(tf.transpose(x_neg, [0, 2, 1]))\n\n # Loss for each point max(d(anchor, pos)^2 - d(anchor, neg)^2 + 1, 0)\n loss = tf.reduce_sum(tf.nn.relu(distance_squared(embed_anchor,\n embed_pos) -\n distance_squared(embed_anchor,\n embed_neg)\n + 1), 0)\n # train model\n train_step = tf.train.AdagradOptimizer(lr).minimize(loss)\n\n return (x_anchor, x_pos, x_neg, train_step, loss,\n embed_anchor, embed_pos, embed_neg)","def __init__(self,\n num_units,\n forget_bias=1.0,\n state_is_tuple=True,\n activation=None,\n reuse=None,\n name=None):\n super(MaskedBasicLSTMCell, self).__init__(\n num_units,\n forget_bias=forget_bias,\n state_is_tuple=state_is_tuple,\n activation=activation,\n reuse=reuse,\n name=name)","def build(self, input_tensors, is_training, lengths=None, hparams=None):\n input_tensor = input_tensors[-1]\n rnn_cell = tf.compat.v1.nn.rnn_cell.BasicRNNCell(\n num_units=self._output_size, activation=tf.nn.tanh)\n net, _ = tf.compat.v1.nn.dynamic_rnn(\n rnn_cell, input_tensor, sequence_length=lengths, dtype=tf.float32)\n\n if self._skip:\n net += _add_projection_if_needed(input_tensor, net)\n\n return input_tensors + [net]","def __init__(self, num_outputs, use_ground_truth, internal_cell):\n self._num_outputs = num_outputs\n self._use_ground_truth = use_ground_truth # boolean\n self._internal_cell = internal_cell # may be LSTM or GRU or anything","def __init__(\n self,\n input_size,\n hidden_size,\n nonlinearity='relu',\n num_layers=1,\n bidirectional=False,\n dropout=0,\n **kwargs\n ):\n mode = 'rnn_relu' if nonlinearity == 'relu' else 'rnn_tanh'\n super(RNN, self).__init__(\n mode, input_size, hidden_size,\n num_layers, bidirectional, dropout, **kwargs\n )","def __init__(\n self,\n input_tensor_spec,\n output_tensor_spec,\n conv_layer_params=None,\n input_fc_layer_params=(200, 100),\n lstm_size=(40,),\n output_fc_layer_params=(200, 100),\n activation_fn=tf.keras.activations.relu,\n name='ActorRnnNetwork',\n ):\n if len(tf.nest.flatten(input_tensor_spec)) > 1:\n raise ValueError('Only a single observation is supported by this network')\n\n input_layers = utils.mlp_layers(\n conv_layer_params,\n input_fc_layer_params,\n activation_fn=activation_fn,\n kernel_initializer=tf.compat.v1.keras.initializers.glorot_uniform(),\n name='input_mlp',\n )\n\n # Create RNN cell\n if len(lstm_size) == 1:\n cell = tf.keras.layers.LSTMCell(lstm_size[0])\n else:\n cell = tf.keras.layers.StackedRNNCells(\n [tf.keras.layers.LSTMCell(size) for size in lstm_size]\n )\n\n state_spec = tf.nest.map_structure(\n functools.partial(\n tensor_spec.TensorSpec, dtype=tf.float32, name='network_state_spec'\n ),\n list(cell.state_size),\n )\n\n output_layers = utils.mlp_layers(\n fc_layer_params=output_fc_layer_params, name='output'\n )\n\n flat_action_spec = tf.nest.flatten(output_tensor_spec)\n action_layers = [\n tf.keras.layers.Dense(\n single_action_spec.shape.num_elements(),\n activation=tf.keras.activations.tanh,\n kernel_initializer=tf.keras.initializers.RandomUniform(\n minval=-0.003, maxval=0.003\n ),\n name='action',\n )\n for single_action_spec in flat_action_spec\n ]\n\n super(ActorRnnNetwork, self).__init__(\n input_tensor_spec=input_tensor_spec, state_spec=state_spec, name=name\n )\n\n self._output_tensor_spec = output_tensor_spec\n self._flat_action_spec = flat_action_spec\n self._conv_layer_params = conv_layer_params\n self._input_layers = input_layers\n self._dynamic_unroll = dynamic_unroll_layer.DynamicUnroll(cell)\n self._output_layers = output_layers\n self._action_layers = action_layers","def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\n cells = []\n for i in range(layer_num):\n if rnn_type.endswith('lstm'):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n elif rnn_type.endswith('gru'):\n cell = tc.rnn.GRUCell(num_units=hidden_size)\n elif rnn_type.endswith('rnn'):\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\n else:\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\n return cells","def __init__(self, model, num_classes=-1, hidden_size=128, type='gru', **kwargs):\n super(CNNRNN, self).__init__(**kwargs)\n self.feats = model is None\n with self.name_scope():\n if model is not None:\n self.td = TimeDistributed(model.backbone)\n if type == 'lstm':\n self.rnn = mx.gluon.rnn.LSTM(hidden_size, layout=\"NTC\", bidirectional=True)\n else:\n self.rnn = mx.gluon.rnn.GRU(hidden_size, layout=\"NTC\", bidirectional=True)\n self.classes = None\n if num_classes == 0:\n self.classes = model.classes\n elif num_classes > 0:\n self.classes = nn.Dense(num_classes, flatten=True)","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\n super(ConvGRUCell, self).__init__()\n self.height, self.width = input_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.hidden_dim = hidden_dim\n self.bias = bias\n self.dtype = dtype\n\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)\n\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\n out_channels=self.hidden_dim, # for candidate neural memory\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)","def __init__(self, celltype, model=None, build_mode='lazy'):\n # Generate the NineLine class from the nineml file and initialise a\n # single cell from it\n if (isinstance(celltype, BiophysNineml) or isinstance(celltype, str)):\n self.celltype = CellMetaClass(celltype, build_mode=build_mode)\n else:\n self.celltype = celltype\n self.default_seg = self.celltype(model=model).source_section.name\n self._model = model\n self.genome_keys = []\n self.log_scales = []","def __call__(self, inputs, state, scope=None, debug=False):\n # B is batch size.\n\n # 1) Use read_ind to find memory location to read from\n # as input.\n\n # inputs.read_ind: (B, 1)\n # memory: (B, mem_size, embed_size)\n read_ind = tf.to_int32(inputs.read_ind)\n batch_size = tf.shape(read_ind)[0]\n if debug:\n print('batch size is', batch_size)\n print('read ind is', read_ind)\n mem_ind = tf.range(batch_size)\n\n # read_mem_ind: (B, 1)\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\n # read_ind: (B, 2)\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\n if debug:\n print('processed read ind is', read_ind)\n\n # inner_inputs: (B, embed_size)\n inner_inputs = tf.gather_nd(state.memory, read_ind)\n if debug:\n print('inner_inputs is', inner_inputs)\n\n inner_state = state.inner_state\n\n # 2) Run the inner RNNCell.\n \n # inner_outputs: (B, embed_size)\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\n\n if debug:\n print('inner_outputs is', inner_outputs)\n\n # 3) Compute logits for valid indices (using logit_masks\n # to mask out padded valid indices (-1)).\n \n # valid_indices: (B, max_n_valid_indices)\n valid_indices = tf.to_int32(inputs.valid_indices)\n if debug:\n print('valid_indices is', valid_indices)\n \n # Logit mask: (B, max_n_valid_indices)\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\n logit_masks = tf.cast(logit_masks, tf.float32)\n\n if debug:\n print('logit_masks is', logit_masks)\n\n # Normalize indices to be at least 0.\n valid_indices = tf.maximum(valid_indices, 0)\n\n # valid_indices: (B, max_n_valid_indices, 1)\n valid_indices = tf.expand_dims(valid_indices, -1)\n if debug:\n print('valid_indices is', valid_indices)\n print('mem_ind is', mem_ind)\n\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # valid_mem_ind: (B, 1, 1)\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\n if debug:\n print('valid_mem_ind is', valid_mem_ind)\n\n # valid_mem_ind: (B, max_n_valid_indices, 1)\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\n\n # valid_indices: (B, max_n_valid_indices, 2)\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\n # index into the right memory location.\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\n\n if debug:\n print('valid_indices is', valid_indices)\n\n # select all the valid slots. \n # valid_values: (B, max_n_valid_indices, embed_size)\n valid_values = tf.gather_nd(state.memory, valid_indices)\n if debug:\n print('valid_values is', valid_values)\n \n # expanded_inner_outputs: (B, 1, embed_size)\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\n if debug:\n print('expanded_inner_outputs is', expanded_inner_outputs)\n\n # valid_values: (B, embed_size, max_n_valid_indices)\n valid_values = tf.transpose(valid_values, [0, 2, 1])\n if debug:\n print('valid_values is', valid_values)\n\n # logits: (B, 1, max_n_valid_indices)\n logits = tf.matmul(expanded_inner_outputs, valid_values)\n \n if debug:\n print('logits is', logits)\n\n # logits: (B, max_n_valid_indices)\n logits = tf.squeeze(logits, axis=[1])\n if debug:\n print('logits is', logits)\n\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\n\n outputs = masked_logits\n # 4) Write the output of the inner RNN to a memory\n # location (write_ind), using write_masks to mask out\n # padded write_ind (-1).\n \n # write_ind: (B, 1)\n write_ind = tf.cast(inputs.write_ind, tf.int32)\n if debug:\n print('write_ind is', write_ind)\n\n # write mask: (B, 1)\n write_masks = tf.greater_equal(inputs.write_ind, 0)\n if debug:\n print('write_masks greater_equal', write_masks)\n\n write_masks = tf.cast(write_masks, tf.float32)\n\n # write mask: (B, 1, 1)\n write_masks = tf.expand_dims(write_masks, [-1])\n\n if debug:\n print('write_masks is', write_masks)\n\n # Normalize write_ind to be above 0.\n # write_ind: (B, 1)\n write_ind = tf.maximum(write_ind, 0)\n\n # write_mem_ind: (B, 1)\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # write_ind: (B, 2)\n # Second dimension is [b_i, write_index]\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\n if debug:\n print('write_ind is', write_ind)\n\n if debug:\n print('masked_logits is', masked_logits)\n print('memory is', state.memory)\n\n # write_mat: (B, mem_size, embed_size)\n write_mat = tf.scatter_nd(\n write_ind, inner_outputs, shape=tf.shape(state.memory))\n\n if debug:\n print('@' * 50)\n print('write_mat is', write_mat)\n print('write_mask is', write_masks)\n print('@' * 50)\n\n masked_write_mat = write_mat * write_masks\n new_memory = state.memory + masked_write_mat\n \n state = MemoryStateTuple(new_memory, new_inner_state)\n if debug:\n print('state is', state)\n \n return (outputs, state)","def resnet_9blocks(pretrained=False, **kwargs):\n return ResnetGenerator(\n 9, **kwargs\n )","def __init__(self,\n num_units,\n forget_bias=1.0,\n activation=None,\n reuse=None,\n layer_norm: bool=False,\n norm_shift: float=0.0,\n norm_gain: float=1.0, # layer normalization\n dropout_keep_prob_in: float = 1.0,\n dropout_keep_prob_h: float=1.0,\n dropout_keep_prob_out: float=1.0,\n dropout_keep_prob_gate: float=1.0,\n dropout_keep_prob_forget: float=1.0,\n dropout_prob_seed: int=None,\n variational_dropout: bool=False,\n recurrent_dropout: bool=False\n ):\n super(CustomLSTMCell, self).__init__(_reuse=reuse)\n self._num_units = num_units\n self._forget_bias = forget_bias\n self._activation = activation or math_ops.tanh\n\n self._layer_norm = layer_norm\n self._g = norm_gain\n self._b = norm_shift\n\n self._recurrent_dropout = recurrent_dropout\n self._variational_dropout = variational_dropout\n \n self._seed = dropout_prob_seed\n self._keep_prob_i = dropout_keep_prob_in\n self._keep_prob_g = dropout_keep_prob_gate\n self._keep_prob_f = dropout_keep_prob_forget\n self._keep_prob_o = dropout_keep_prob_out\n self._keep_prob_h = dropout_keep_prob_h","def resnet10(**kwargs):\n model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)\n return model","def get_rnn_cells(self):\n return [self.rnn]","def SimpleRNN(self):\n # Model.\n model = Sequential()\n model.add(SimpleRNN(2048, return_sequences=True,\n input_shape=self.input_shape,\n dropout=0.0))\n #model.add(Flatten()) #qiao_added\n # model.add(Dense(1024, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(2048, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Flatten())\n model.add(Dense(self.nb_classes, activation='softmax'))\n return model","def __call__(self, inputs, state, scope=None):\n if scope is not None:\n with vs.variable_scope(scope,\n custom_getter=self._rnn_get_variable) as scope:\n return super(RNNCell, self).__call__(inputs, state, scope=scope)\n else:\n scope_attrname = \"rnncell_scope\"\n scope = getattr(self, scope_attrname, None)\n if scope is None:\n scope = vs.variable_scope(vs.get_variable_scope(),\n custom_getter=self._rnn_get_variable)\n setattr(self, scope_attrname, scope)\n with scope:\n return super(RNNCell, self).__call__(inputs, state)","def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\n is_training=True, seed=None):\n if not isinstance(cell, tf.nn.rnn_cell.RNNCell):\n raise TypeError(\"The parameter cell is not a RNNCell.\")\n if (isinstance(input_keep_prob, float) and\n not (input_keep_prob >= 0.0 and input_keep_prob <= 1.0)):\n raise ValueError(\"Parameter input_keep_prob must be between 0 and 1: %d\"\n % input_keep_prob)\n if (isinstance(output_keep_prob, float) and\n not (output_keep_prob >= 0.0 and output_keep_prob <= 1.0)):\n raise ValueError(\"Parameter output_keep_prob must be between 0 and 1: %d\"\n % output_keep_prob)\n self._cell = cell\n self._input_keep_prob = input_keep_prob\n self._output_keep_prob = output_keep_prob\n self._seed = seed\n self._is_training = is_training","def __init__(self, name=\"conv_1d_lstm_cell\", **kwargs):\n super(Conv1DLSTMCell, self).__init__(conv_ndims=1, name=name, **kwargs)","def __init__(self, width=20, height=20):\n self.width = width\n self.height = height\n self.cells = []\n for y in range(self.height):\n for x in range(self.width):\n self.cells.append(Cell(x, y, [N, S, E, W]))","def n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs,\n activation, use_bi_direction, **kwargs): # NOQA\n\n argument.check_unexpected_kwargs(\n kwargs, train='train argument is not supported anymore. '\n 'Use chainer.using_config',\n use_cudnn='use_cudnn argument is not supported anymore. '\n 'Use chainer.using_config')\n argument.assert_kwargs_empty(kwargs)\n\n activation_list = ['tanh', 'relu']\n if activation not in activation_list:\n candidate = ','.join(activation_list)\n raise ValueError('Invalid activation: \"%s\". Please select from [%s]'\n % (activation, candidate))\n\n xp = cuda.get_array_module(hx)\n\n if xp is not numpy and chainer.should_use_cudnn('>=auto', 5000):\n states = get_random_state().create_dropout_states(dropout_ratio)\n lengths = [len(x) for x in xs]\n xs = chainer.functions.concat(xs, axis=0)\n\n rnn_mode = 'rnn_%s' % activation\n w = cudnn_rnn_weight_concat(\n n_layers, states, use_bi_direction, rnn_mode, ws, bs)\n\n if use_bi_direction:\n # Bi-directional RNN\n if activation == 'tanh':\n rnn = NStepBiRNNTanh\n elif activation == 'relu':\n rnn = NStepBiRNNReLU\n else:\n # Uni-directional RNN\n if activation == 'tanh':\n rnn = NStepRNNTanh\n elif activation == 'relu':\n rnn = NStepRNNReLU\n\n hy, ys = rnn(n_layers, states, lengths)(hx, w, xs)\n sections = numpy.cumsum(lengths[:-1])\n ys = chainer.functions.split_axis(ys, sections, 0)\n return hy, ys\n\n else:\n\n def f(x, h, c, w, b):\n xw, hw = w\n xb, hb = b\n rnn_in = linear.linear(x, xw, xb) + linear.linear(h, hw, hb)\n if activation == 'tanh':\n return tanh.tanh(rnn_in), None\n elif activation == 'relu':\n return relu.relu(rnn_in), None\n\n hy, _, ys = n_step_rnn_impl(\n f, n_layers, dropout_ratio, hx, None, ws, bs, xs, use_bi_direction)\n return hy, ys","def create_cells(self, N):\n self.cells = []\n r = 50 # Radius of cell locations from origin (0,0,0) in microns\n N = self._N\n for i in range(N):\n cell = BallAndStick()\n # When cells are created, the soma location is at (0,0,0) and\n # the dendrite extends along the X-axis.\n # First, at the origin, rotate about Z.\n cell.rotateZ(i * 2 * pi / N)\n # Then reposition\n x_loc = cos(i * 2 * pi / N) * r\n y_loc = sin(i * 2 * pi / N) * r\n cell.set_position(x_loc, y_loc, 0)\n self.cells.append(cell)","def __init__(\n self, channel_count: int, input_height_width: tuple, no_add: bool = False\n ):\n super().__init__()\n\n self.no_add: bool = no_add\n\n self.rm_block_1 = RMBlock(\n channel_count // 2,\n channel_count,\n input_height_width,\n 1,\n \"weight\",\n 1,\n )\n\n self.rm_block_2 = RMBlock(\n channel_count // 2,\n channel_count // 2,\n input_height_width,\n 3,\n \"weight\",\n 32,\n )\n\n self.rm_block_3 = RMBlock(\n channel_count,\n channel_count // 2,\n input_height_width,\n 1,\n \"weight\",\n 1,\n )","def __init__(self,\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\n in2hid: tuple, in2out: tuple,\n hid2hid: tuple, hid2out: tuple,\n hidden_biases: np.ndarray, output_biases: np.ndarray,\n rnn_array: np.ndarray, rnn_map: np.ndarray,\n activation,\n batch_size: int = 1,\n initial_read: np.ndarray = None,\n dtype=np.float64,\n ):\n # Storing the input arguments (needed later on)\n self.act_f = activation\n self.dtype = dtype\n self.rnn_idx: np.ndarray = rnn_idx\n self.n_inputs: int = len(input_idx)\n self.n_hidden: int = len(hidden_idx)\n self.n_rnn: int = len(rnn_idx)\n self.n_outputs: int = len(output_idx)\n self.bs: int = batch_size\n \n # Setup the rnn_map\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\n for i, m in enumerate(rnn_map):\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\n \n # Placeholders, initialized during reset\n self.rnn_state: np.ndarray = None # State of the RNNs\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\n self.output_act: np.ndarray = None # Activations of the output nodes\n \n # Do not create the hidden-related matrices if hidden-nodes do not exist\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\n if self.n_hidden > 0:\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\n self.rnn_array: np.ndarray = rnn_array\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\n \n # Fill in the biases\n if self.n_hidden > 0:\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\n \n # Put network to initial (default) state\n self.reset(initial_read=initial_read)","def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\n #====================================================================================#\n # ----------PROBLEM 2----------\n #====================================================================================#\n # YOUR CODE HERE\n # raise NotImplementedError\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\n ## step 1 - inputs are first embedded by an MLP\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\n # print(\"after build_mlp x = \", x)\n ## step 2 - passed to a GRU cell\n # as \"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\"hidden\", dtype=tf.float32)\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\n # after build_mlp x = Tensor(\"continuous_logits/continuous_logits/fc1/BiasAdd:0\", shape=(?, 1, 32), dtype=float32)\n # x = tf.squeeze(x, axis=1)\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\n # print(\"dynamic_rnn build_mlp x = \", x, \" h = \", h)\n return x, h","def add_model(self, inputs):\n size = self.config.hidden_size\n forget_bias = self.config.forget_bias\n input_cell = self.config.input_cell\n\n if input_cell == 'BasicLSTMCell':\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\n print 'Using Basic LSTM Cell \\n'\n\n elif input_cell == 'LSTMCell':\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\n print 'Using LSTM Cell \\n'\n\n elif input_cell == 'GRUCell':\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\n print 'Using GRU Cell \\n'\n\n else:\n print \"Please Specify a Correct Cell Type\"\n\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\n input_keep_prob=self.config.dropout)\n\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\n \n print 'Number of Hidden Layers ', self.config.num_layers\n \n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\n rnn_outputs = []\n state = self.initial_state\n\n with tf.variable_scope('RNNLM') as scope:\n for time_step in range(self.config.num_steps):\n if time_step > 0: scope.reuse_variables()\n (cell_output, state) = cell(inputs[:, time_step, :], state)\n rnn_outputs.append(cell_output)\n self.final_state = state\n\n return rnn_outputs","def __init__(self, cell_index, stimulus_type, conv_layers=[(12, 9, 9), (12, 9, 9)], dense_layer=64,\n loss='poisson_loss', optimizer='adam', weight_init='normal', l2_reg=0., dropout=0.5, mean_adapt=False):\n\n self.stim_shape = (40, 50, 50)\n\n # build the model\n with notify('Building convnet'):\n\n self.model = Sequential()\n\n # convolutional layers\n for ix, layer in enumerate(conv_layers):\n\n # get parameters for this layer\n num_filters, row_size, col_size = layer\n\n # convolutional layer\n if ix == 0:\n self.model.add(Convolution2D(num_filters, row_size, col_size,\n input_shape=self.stim_shape, init=weight_init,\n border_mode='same', subsample=(1,1),\n W_regularizer=l2(l2_reg), activation='relu'))\n\n else:\n self.model.add(Convolution2D(num_filters, row_size, col_size,\n input_shape=self.stim_shape, init=weight_init,\n border_mode='same', subsample=(1,1),\n W_regularizer=l2(l2_reg), activation='relu'))\n\n # max pooling layer\n self.model.add(MaxPooling2D(pool_size=(2, 2), ignore_border=True))\n\n # dropout\n self.model.add(Dropout(dropout))\n\n # flatten\n self.model.add(Flatten())\n\n # Add dense (affine) layer with relu activation\n self.model.add(Dense(dense_layer, init=weight_init, W_regularizer=l2(l2_reg), activation='relu'))\n self.model.add(Dropout(dropout))\n\n # Add a final dense (affine) layer with softplus activation\n self.model.add(Dense(1, init=weight_init, W_regularizer=l2(l2_reg), activation='softplus'))\n\n # save architecture string (for markdown file)\n self.architecture = '\\n'.join(['Convolutional layers {}'.format(conv_layers),\n '{} filters in the second (fully connected) layer'.format(dense_layer),\n 'weight initialization: {}'.format(weight_init),\n 'l2 regularization: {}'.format(l2_reg),\n 'stimulus shape: {}'.format(self.stim_shape)])\n\n # compile\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)","def __init__(self, name=\"conv_2d_lstm_cell\", **kwargs):\n super(Conv2DLSTMCell, self).__init__(conv_ndims=2, name=name, **kwargs)","def __init__(self, config, input_shp):\n\n # Run initialization for super class\n super(MyNetwork, self).__init__()\n\n # Store configuration\n self.config = config\n\n # Placeholder for layers\n self.layers = {}\n indim = input_shp[0]\n\n # Retrieve Conv, Act, Pool functions from configurations. We'll use\n # these for our code below.\n if config.conv2d == \"torch\":\n self.Conv2d = nn.Conv2d\n elif config.conv2d == \"custom\":\n self.Conv2d = ConvBlock\n self.Activation = getattr(nn, config.activation)\n self.Pool2d = getattr(nn, config.pool2d)\n self.Linear = nn.Linear\n\n # Resnet Blocks, similar to slide 73 of lecture 21. However, for\n # simplicity, we'll make is slightly different. Note that we used\n # nn.Sequential this time.\n self.convs = nn.Sequential()\n cur_h, cur_w = input_shp[-2:]\n for _i in range(config.num_conv_outer):\n #\n # NOTE THE NEW LAYER ON THESE LINES!\n #\n # We have a dedicated 1x1 layer to get more channels. Note also\n # that this is a pure linear convolution layer.\n outdim = config.nchannel_base * 2 ** _i\n self.convs.add_module(\n \"conv_{}_base\".format(_i), nn.Conv2d(indim, outdim, 1, 1, 0))\n indim = outdim\n for _j in range(config.num_conv_inner):\n # We now use our selected convolution layer. Note that our\n # resnet implementation will have a different call style to\n # vanilla conv2d of torch, so we'll just do an ugly if-else\n # here.\n if config.conv2d == \"torch\":\n self.convs.add_module(\n \"conv_{}_{}\".format(_i, _j),\n self.Conv2d(indim, outdim, config.ksize, 1, 1))\n self.convs.add_module(\n \"act_{}_{}\".format(_i, _j),\n self.Activation())\n cur_h = cur_h - (config.ksize - 1)\n cur_w = cur_w - (config.ksize - 1)\n elif config.conv2d == \"custom\":\n self.convs.add_module(\n \"conv_{}_{}\".format(_i, _j),\n self.Conv2d(indim, outdim, config.ksize, 1, self.Activation))\n self.convs.add_module(\n \"conv_{}_pool\".format(_i), self.Pool2d(2, 2))\n cur_h = cur_h // 2\n cur_w = cur_w // 2\n\n # Final output layer. We'll assume that conv layer outputs are global\n # average pooled\n self.output = nn.Linear(indim, config.num_class)\n\n print(self)","def __init__(self,cell1,site1,cell2,site2,color=None,label=None,linewidth=None,linetype=None):\n self.cell1 = np.array(cell1)\n self.site1 = site1\n self.cell2 = np.array(cell2)\n self.site2 = site2\n coordinate1 = None\n coordinate2 = None\n self.color = color\n self.label = label\n self.linewidth = linewidth\n self.linetype = linetype","def __init__(self, num_units, levels, forget_bias=1.0,\r\n state_is_tuple=True, activation=None, reuse=None, name=None):\r\n super(ON_LSTMCell, self).__init__(_reuse=reuse, name=name)\r\n if not state_is_tuple:\r\n logging.warn(\"%s: Using a concatenated state is slower and will soon be \"\r\n \"deprecated. Use state_is_tuple=True.\", self)\r\n\r\n # Inputs must be 2-dimensional.\r\n self.input_spec = base_layer.InputSpec(ndim=2)\r\n\r\n self._num_units = num_units\r\n self._levels = levels\r\n self._chunk_size = num_units // levels\r\n self._forget_bias = forget_bias\r\n self._state_is_tuple = state_is_tuple\r\n self._activation = activation or math_ops.tanh","def __init__(self, voc_size, layer_size=512, num_layers=3, embedding_layer_size=256, dropout=0.,\n controller_type='gru', **kwargs):\n super(RNN, self).__init__()\n\n self._layer_size = layer_size\n self._embedding_layer_size = embedding_layer_size\n self._num_layers = num_layers\n self._dropout = dropout\n self._controller_type = controller_type\n\n self._embedding = tnn.Embedding(voc_size, self._embedding_layer_size)\n\n if controller_type == 'gru':\n self._layer = tnn.GRU(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\n dropout=self._dropout)\n elif controller_type == 'lstm':\n self._layer = tnn.LSTM(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\n dropout=self._dropout)\n\n self._linear = tnn.Linear(self._layer_size, voc_size)","def get_rnn_cells(self) -> List[mx.rnn.BaseRNNCell]:\n return self.forward_rnn.get_rnn_cells() + self.reverse_rnn.get_rnn_cells()","def __init__(self, cell):\n self._cell = cell\n self._residual_fn = gnmt_residual_fn","def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\n is_training=False, cell_name=\"GRU\", bidirectional=False, swap_memory=False):\n batch_size = tf.shape(X)[0]\n if bidirectional:\n rnn_size /= 2\n\n def get_cell():\n if cell_name == \"GRU\": # GRU\n _cell = rnn_cell.GRUCell(rnn_size)\n elif cell_name == \"LSTM\": # LSTM\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\n else:\n raise ValueError(\"Unrecognized Cell Name: {0}\".format(cell_name))\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\n _initial_state = _cell.zero_state(batch_size, tf.float32)\n return _cell, _initial_state\n\n if bidirectional:\n with tf.variable_scope(\"forward\"):\n cell_fw, initial_state_fw = get_cell()\n with tf.variable_scope(\"backward\"):\n cell_bw, initial_state_bw = get_cell()\n return rnn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, X, sequence_length=seq_len,\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\n else:\n cell, initial_state = get_cell()\n return rnn.dynamic_rnn(\n cell, X, sequence_length=seq_len, initial_state=initial_state,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)","def get_init_cell(batch_size, rnn_size, keep_prob, lstm_layers=2):\n def build_cell(lstm_size, keep_prob):\n cell = tf.nn.rnn.BasicLSTMCell(num_units=lstm_size)\n drop = tf.nn.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob)\n return drop\n\n # 堆栈cell 构建多层隐藏层\n multi_cell = tf.nn.rnn.MultiRNNCell(\n [build_cell(rnn_size, keep_prob) for _ in range(lstm_layers)]\n )\n\n # todo 这里使用tf.identity(final_state同)是为了生成一个op操作符，断点继续训练时候要用。\n initial_state = multi_cell.zero_state(batch_size, tf.float32)\n initial_state1 = tf.identity(initial_state, name='initial_state')\n return multi_cell, initial_state, initial_state1","def __init__(self, num_nodes, num_features, num_timesteps_input,\n num_timesteps_output, gcn_type='normal', hidden_size=64, num_comps=10):\n super(KRNN, self).__init__()\n self.encoders = nn.ModuleList()\n self.decoders = nn.ModuleList()\n self.linears = nn.ModuleList()\n\n self.num_timesteps_output = num_timesteps_output\n\n for r in range(num_comps):\n self.encoders.append(\n nn.GRU(num_features, hidden_size)\n )\n self.decoders.append(\n nn.GRUCell(1, hidden_size)\n )\n self.linears.append(\n nn.Linear(hidden_size, 1)\n )\n\n self.embed = nn.Parameter(torch.FloatTensor(num_nodes, num_comps))\n self.embed.data.normal_()","def test_learnable_cell(self):\n genotype = '0|0|2|0|0|2|0|0 1|0|0|1|1|0|0|0 0|1|0|0|0|0|2|1--1 7'\n search_space = {'dil_conv_3x3', 'dil_conv_5x5', 'dil_conv_7x7',\n 'skip_connect', 'clinc_3x3', 'clinc_7x7', 'avg_pool_3x3', 'max_pool_3x3'}\n\n net = LearnableCell(3, genotype, search_space)\n x = torch.rand((16, 3, 32, 32))\n y = net(x)\n self.assertEqual(list(y.shape), [16, 7, 15, 15])","def SimpleDeepCell():\n cell = Cell()\n node = cell._get_hcell2()\n node[\"celltype\"] = \"mixed\"\n node[\"hash_pattern\"] = {\"*\": \"#\"}\n return cell","def build_gru_cell(num_units, dropout):\n cell = tf.nn.rnn_cell.GRUCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result","def _build_bdrnn_graph(self, hparams):\n\n sample = self.iterator.get_next()\n\n inputs, tgt_outputs, seq_len = sample\n\n # linear projection to state size\n #with tf.variable_scope(\"bdrnn_in\", dtype=tf.float32):\n # inputs = tf.layers.dense(inputs=inputs,\n # units=hparams.input_proj_size,\n # kernel_initializer=tf.glorot_uniform_initializer())\n\n lm_fw_cell = []\n lm_bw_cell = []\n lm_init_state_fw = []\n lm_init_state_bw = []\n if hparams.pretrained:\n with tf.variable_scope(\"lm_rnn\", dtype=tf.float32):\n # create lm\n with tf.variable_scope(\"fw\", dtype=tf.float32):\n lm_fw_cell = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=1,\n mode=self.mode)\n # build the cell so it is in the correct scope\n # NOTE: this is hard coded\n lm_fw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\n lm_init_state_fw = _get_initial_state([lm_fw_cell[0].state_size], tf.shape(inputs)[0], \"lm\")\n with tf.variable_scope(\"bw\", dtype=tf.float32):\n lm_bw_cell = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=1,\n mode=self.mode)\n # NOTE: this is hard coded\n lm_bw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\n lm_init_state_bw = _get_initial_state([lm_bw_cell[0].state_size], tf.shape(inputs)[0], \"lm\")\n\n lm_outputs, lm_states = tf.nn.bidirectional_dynamic_rnn(lm_fw_cell[0],\n lm_bw_cell[0],\n inputs,\n sequence_length=seq_len,\n initial_state_fw=lm_init_state_fw[0],\n initial_state_bw=lm_init_state_bw[0],\n dtype=tf.float32)\n # optionally fix the LM weights\n if hparams.fixed_lm:\n print(\"Fixing pretrained language models.\")\n lm_outputs = tf.stop_gradient(lm_outputs)\n lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1]], axis=-1)\n lm_outputs = tf.layers.dense(lm_outputs,\n 20,\n kernel_initializer=tf.glorot_uniform_initializer())\n lm_outputs = tf.concat([lm_outputs, inputs], axis=-1)\n\n\n #lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1], inputs], axis=-1)\n else:\n lm_outputs = tf.concat(lm_outputs, axis=-1)\n\n\n\n with tf.variable_scope(\"bdrnn\", dtype=tf.float32) as bdrnn_scope:\n # create bdrnn\n with tf.variable_scope(\"fw\", dtype=tf.float32):\n fw_cells = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=hparams.num_layers,\n mode=self.mode\n )\n init_state_fw = _get_initial_state([cell.state_size for cell in fw_cells],\n tf.shape(inputs)[0], \"initial_state_fw\")\n\n with tf.variable_scope(\"bw\", dtype=tf.float32):\n bw_cells = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=hparams.num_layers,\n mode=self.mode,\n )\n\n init_state_bw = _get_initial_state([cell.state_size for cell in bw_cells],\n tf.shape(inputs)[0], \"initial_state_bw\")\n # NOTE: this is commented because the lm cells and states are separated now\n #fw_cells = lm_fw_cell + fw_cells\n #bw_cells = lm_bw_cell + bw_cells\n #init_state_fw = lm_init_state_fw + init_state_fw\n #init_state_bw = lm_init_state_bw + init_state_bw\n\n # run bdrnn\n combined_outputs, output_state_fw, output_state_bw = \\\n tf.contrib.rnn.stack_bidirectional_dynamic_rnn(cells_fw=fw_cells,\n cells_bw=bw_cells,\n inputs=lm_outputs,\n sequence_length=seq_len,\n initial_states_fw=init_state_fw,\n initial_states_bw=init_state_bw,\n dtype=tf.float32,\n scope=bdrnn_scope)\n # outputs is a tuple (output_fw, output_bw)\n # output_fw/output_bw are tensors [batch_size, max_time, cell.output_size]\n # outputs_states is a tuple (output_state_fw, output_state_bw) containing final states for\n # forward and backward rnn\n\n # concatenate the outputs of each direction\n #combined_outputs = tf.concat([outputs[0], outputs[1]], axis=-1)\n\n with tf.variable_scope(\"bdrnn_out\", dtype=tf.float32):\n # dense output layers\n dense1 = tf.layers.dense(inputs=combined_outputs,\n units=hparams.num_dense_units,\n kernel_initializer=tf.glorot_uniform_initializer(),\n activation=tf.nn.relu,\n use_bias=True)\n drop1 = tf.layers.dropout(inputs=dense1,\n rate=hparams.dropout,\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\n dense2 = tf.layers.dense(inputs=drop1,\n units=hparams.num_dense_units,\n kernel_initializer=tf.glorot_uniform_initializer(),\n activation=tf.nn.relu,\n use_bias=True)\n drop2 = tf.layers.dropout(inputs=dense2,\n rate=hparams.dropout,\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\n\n logits = tf.layers.dense(inputs=drop2,\n units=hparams.num_labels,\n use_bias=False)\n\n # mask out entries longer than target sequence length\n mask = tf.sequence_mask(seq_len, dtype=tf.float32)\n\n crossent = tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,\n labels=tgt_outputs,\n name=\"crossent\")\n\n # divide loss by batch_size * mean(seq_len)\n loss = tf.reduce_sum(crossent*mask)/tf.cast(hparams.batch_size, tf.float32)\n\n metrics = []\n update_ops = []\n if self.mode == tf.contrib.learn.ModeKeys.EVAL:\n # mean eval loss\n loss, loss_update = tf.metrics.mean(values=loss)\n\n predictions = tf.argmax(input=logits, axis=-1)\n tgt_labels = tf.argmax(input=tgt_outputs, axis=-1)\n acc, acc_update = tf.metrics.accuracy(predictions=predictions,\n labels=tgt_labels,\n weights=mask)\n # confusion matrix\n targets_flat = tf.reshape(tgt_labels, [-1])\n predictions_flat = tf.reshape(predictions, [-1])\n mask_flat = tf.reshape(mask, [-1])\n cm, cm_update = streaming_confusion_matrix(labels=targets_flat,\n predictions=predictions_flat,\n num_classes=hparams.num_labels,\n weights=mask_flat)\n tf.add_to_collection(\"eval\", cm_summary(cm, hparams.num_labels))\n metrics = [acc, cm]\n update_ops = [loss_update, acc_update, cm_update]\n\n return logits, loss, metrics, update_ops","def __init__(self, sys, rcut, pad):\n self.sys = sys \n self.rcut = rcut \n self.pad = pad\n self.cell_list = CellList(self.sys.box, self.rcut + self.pad)","def __init__(self,\n cell_type: Text = \"lstm\",\n tiers: Dict[int:List[int]] = {1:[1]},\n window_sizes: List[int] = [1],\n strides: List[int] = [1],\n use_dense_layer_output : bool = False,\n dense_layer_args : Dict = {\"units\": None,\n \"activation\":None,#don't change this\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"bias_initializer\":'zeros',\n \"kernel_regularizer\":None,\n \"bias_regularizer\":None,\n \"activity_regularizer\":None,\n \"kernel_constraint\":None,\n \"bias_constraint\":None,\n },\n lstm_cell_args : Dict = {\"activation\":'tanh',\n \"recurrent_activation\":'hard_sigmoid',\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"recurrent_initializer\":'orthogonal',\n \"bias_initializer\":'zeros',\n \"unit_forget_bias\":True,\n \"kernel_regularizer\":None,\n \"recurrent_regularizer\":None,\n \"bias_regularizer\":None,\n \"kernel_constraint\":None,\n \"recurrent_constraint\":None,\n \"bias_constraint\":None,\n \"implementation\":1,\n },\n gru_cell_args : Dict = {\"activation\":'tanh',\n \"recurrent_activation\":'hard_sigmoid',\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"recurrent_initializer\":'orthogonal',\n \"bias_initializer\":'zeros',\n \"kernel_regularizer\":None,\n \"recurrent_regularizer\":None,\n \"bias_regularizer\":None,\n \"kernel_constraint\":None,\n \"recurrent_constraint\":None,\n \"bias_constraint\":None,\n \"implementation\":1,\n \"reset_after\":False,\n },\n adam_opt_args : Dict = {\"learning_rate\": None,\n \"epsilon\": None,\n \"beta_1\": None,\n \"beta_2\": None,\n },\n clip_norm : Optional[float] = None,\n dropout_training = 0,\n recurrent_dropout_training = 0,\n tens_to_log = None,\n checkpoint_path = None,\n predict_batch_size = 30,\n save_checkpoints_steps = 100,\n keep_checkpoint_max = 10,\n save_summary_steps = 10,\n logging_step = 10,\n ):\n \n if (len(tiers)!=len(window_sizes) or len(window_sizes)!=len(strides)):\n raise ValueError(\"Mismatch in network geometry specs. Need number of\"\n \" tiers = number of window size specs, or number of\"\n \" window specs = number of stride specs.\")\n \n \n self.cell_type = cell_type \n self.tiers = tiers, \n self.window_sizes = window_sizes,\n self.strides = strides,\n self.use_dense_layer_output = use_dense_layer_output\n self.dense_layer_args = dense_layer_args,\n self.lstm_cell_args = lstm_cell_args,\n self.gru_cell_args = gru_cell_args,\n self.adam_opt_args = adam_opt_args,\n self.clip_norm = clip_norm,\n self.dropout_training = 0,\n self.recurrent_dropout_training = recurrent_dropout_training,\n self.tens_to_log = tens_to_log,\n self.checkpoint_path = None,\n self.predict_batch_size = 30,\n self.save_checkpoints_steps = 100,\n self.keep_checkpoint_max = 10,\n self.save_summary_steps = 20,\n self.logging_step = 10","def build_nn_model(height, width, num_channels, num_res_blocks):\n input_network = Input(shape=(height, width, 1))\n tensor = Conv2D(num_channels, (3, 3), padding='same')(input_network)\n tensor = Activation('relu')(tensor)\n for _ in range(num_res_blocks):\n tensor = resblock(tensor, num_channels)\n tensor = Conv2D(1, (3, 3), padding='same')(tensor)\n tensor = Add()([tensor, input_network])\n model = Model(inputs=input_network, outputs=tensor)\n return model"],"string":"[\n \"def create_rnn_cell(num_units,\\n num_layers,\\n num_residual_layers,\\n dropout,\\n mode,\\n num_gpus,\\n base_gpu=0,\\n single_cell_fn=None,\\n all_layer_outputs=False):\\n cell_list = _cell_list(\\n num_units=num_units,\\n num_layers=num_layers,\\n num_residual_layers=num_residual_layers,\\n dropout=dropout,\\n mode=mode,\\n num_gpus=num_gpus,\\n base_gpu=base_gpu,\\n single_cell_fn=single_cell_fn)\\n\\n if len(cell_list) == 1: # Single layer.\\n return cell_list[0]\\n else: # Multi layers\\n print(all_layer_outputs, \\\"all_layer_outputs\\\")\\n\\n if all_layer_outputs:\\n return MultiRNNCell(cell_list)\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)\",\n \"def build_multi_rnn(cells):\\n return tf.nn.rnn_cell.MultiRNNCell(cells)\",\n \"def __init__(self, rnn_cell, batch_size,\\n input_size, num_outputs):\\n super().__init__(name='RNNCellStateModel')\\n self._rnn_cell = rnn_cell\\n self._batch_size = batch_size\\n self._input_size = input_size\\n self._num_outputs = num_outputs\",\n \"def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\\n if is_train:\\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\\n return cell\",\n \"def MakeFancyRNNCell(H, keep_prob, num_layers=1):\\n cells = []\\n for _ in range(num_layers):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cells.append(cell)\\n return tf.nn.rnn_cell.MultiRNNCell(cells)\",\n \"def _create_rnn_cells(self, is_list=False):\\n\\n stacked_rnn = []\\n for _ in range(self.num_layers):\\n single_cell = self._rnn_single_cell()\\n stacked_rnn.append(single_cell)\\n\\n if is_list:\\n return stacked_rnn\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(\\n cells=stacked_rnn,\\n state_is_tuple=True)\",\n \"def __call__(self, inputs, state, scope=None, *args, **kwargs):\\r\\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\\r\\n # Instead, it is up to subclasses to provide a proper build\\r\\n # method. See the class docstring for more details.\\r\\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\\r\\n *args, **kwargs)\",\n \"def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\\n if layer_type == \\\"layernorm_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\\n else:\\n if layer_type == \\\"lstm\\\":\\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\\n elif layer_type == \\\"gru\\\":\\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_gru\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\\n else:\\n raise ValueError(\\\"Error: not supported rnn type:{}\\\".format(layer_type))\\n\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, output_keep_prob=dropout_keep_prob)\\n return cell\",\n \"def build_rnn(cell, inputs):\\n #_,initial_state = get_init_cell(batch_size, rnn_size)\\n \\n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name='final_state')\\n\\n return (output, final_state)\",\n \"def __init__(self,\\n num_units,\\n num_dims=1,\\n input_dims=None,\\n output_dims=None,\\n priority_dims=None,\\n non_recurrent_dims=None,\\n tied=False,\\n cell_fn=None,\\n non_recurrent_fn=None,\\n state_is_tuple=True,\\n output_is_tuple=True):\\n if not state_is_tuple:\\n logging.warning('%s: Using a concatenated state is slower and will '\\n 'soon be deprecated. Use state_is_tuple=True.', self)\\n if not output_is_tuple:\\n logging.warning('%s: Using a concatenated output is slower and will '\\n 'soon be deprecated. Use output_is_tuple=True.', self)\\n\\n if num_dims < 1:\\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\\n\\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\\n priority_dims, non_recurrent_dims,\\n non_recurrent_fn or nn.relu, tied,\\n num_units)\\n\\n self._state_is_tuple = state_is_tuple\\n self._output_is_tuple = output_is_tuple\\n\\n if cell_fn is None:\\n my_cell_fn = functools.partial(\\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\\n else:\\n my_cell_fn = lambda: cell_fn(num_units)\\n if tied:\\n self._cells = [my_cell_fn()] * num_dims\\n else:\\n self._cells = [my_cell_fn() for _ in range(num_dims)]\\n if not isinstance(self._cells[0], rnn.RNNCell):\\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\\n type(self._cells[0]))\\n\\n if self._output_is_tuple:\\n self._output_size = tuple(self._cells[0].output_size\\n for _ in self._config.outputs)\\n else:\\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\\n\\n if self._state_is_tuple:\\n self._state_size = tuple(self._cells[0].state_size\\n for _ in self._config.recurrents)\\n else:\\n self._state_size = self._cell_state_size() * len(self._config.recurrents)\",\n \"def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\\n readout_init, readout_apply = stax.Dense(num_outputs)\\n\\n def init_fun(key, input_shape):\\n \\\"\\\"\\\"Initialize the components of the RNN.\\n\\n Args:\\n key: Jax PRNGkey used to initialize the parameters.\\n input_shape: tuple representing the input shape, should be\\n (batch_size, sequence_length).\\n\\n Returns:\\n shapes: set of tuples representing the shapes after applying\\n the Embedding, RNN Cell, and Readout layers.\\n network_params: tuple of network parameters, containing the\\n embedding, RNN cell, and readout parameters.\\n \\\"\\\"\\\"\\n\\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\\n\\n # Initialize the Embedding for the input tokens.\\n emb_shape, emb_params = emb_init(emb_key, input_shape)\\n\\n # The cell is defined for a single update step, which is why we ignore\\n # the sequence dimension (emb_shape[1]) here.\\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\\n\\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\\n\\n shapes = (emb_shape, rnn_shape, output_shape)\\n network_params = (emb_params, rnn_params, readout_params)\\n\\n return shapes, network_params\\n\\n def apply_fun(network_params, tokens):\\n \\\"\\\"\\\"Applies the RNN on a batch of input sequences.\\n\\n Args:\\n network_params: tuple of network parameters (see init_fun).\\n tokens: batch of inputs, with shape (batch_size, sequence_length).\\n\\n Returns:\\n outputs: network outputs, at every step along the sequence.\\n \\\"\\\"\\\"\\n emb_params, rnn_params, readout_params = network_params\\n\\n # Apply the embedding.\\n inputs = emb_apply(emb_params, tokens)\\n\\n # Run the RNN.\\n initial_states = cell.get_initial_state(rnn_params,\\n batch_size=tokens.shape[0])\\n return unroll.unroll_rnn(initial_states, inputs,\\n functools.partial(cell.batch_apply, rnn_params),\\n functools.partial(readout_apply, readout_params))\\n\\n return init_fun, apply_fun, emb_apply, readout_apply\",\n \"def make_cell(self, unit_type, num_units, forget_bias, dropout,\\n mode, residual_connection=False):\\n\\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\\n dropout = dropout if mode == tf.contrib.learn.ModeKeys.TRAIN else 0.0\\n\\n # Cell Type\\n if unit_type == \\\"lstm\\\":\\n cell = tf.contrib.rnn.BasicLSTMCell(\\n num_units,\\n forget_bias=forget_bias)\\n elif unit_type == \\\"gru\\\":\\n cell = tf.contrib.rnn.GRUCell(num_units)\\n elif unit_type == \\\"layer_norm_lstm\\\":\\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units,\\n forget_bias=forget_bias,\\n layer_norm=True)\\n else:\\n raise ValueError(\\\"Unknown unit type %s!\\\" % unit_type)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n cell = tf.contrib.rnn.DropoutWrapper(\\n cell=cell, input_keep_prob=(1.0 - dropout))\\n\\n # Residual\\n if residual_connection:\\n cell = tf.contrib.rnn.ResidualWrapper(cell)\\n\\n return cell\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(RCRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = ResidualCNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=2,\\n )\\n #self.rnn2 = BidirectionalGRU(\\n # n_in=nb_in*2,\\n # n_hidden=n_RNN_cell,\\n # dropout=dropout_recurrent,\\n # num_layers=1,\\n #)\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.relu = nn.ReLU()\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def _create_rnn_cell(num_units, num_layers, mode):\\n\\n cell_list = []\\n for i in range(num_layers):\\n single_cell = STLSTMCell(name=\\\"stlstm\\\",\\n num_units=num_units,\\n st_activation=tf.nn.relu,\\n st_kernel_initializer=tf.glorot_uniform_initializer(),\\n st_num_layers=2,\\n st_residual=True)\\n cell_list.append(single_cell)\\n\\n return cell_list\",\n \"def constructCell():\\n\\t\\tself.weightGenerate()\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(CRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = CNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=n_layers_RNN,\\n )\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def __init__(self, cell, attn_inputs, \\n attn_size, attn_vec_size,\\n output_size=None, input_size=None, \\n state_is_tuple=True, attn_masks=None,\\n merge_output_attn='linear',\\n reuse=None):\\n if not isinstance(cell, rnn.RNNCell):\\n raise TypeError(\\\"The parameter cell is not RNNCell.\\\")\\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\\n raise ValueError(\\\"Cell returns tuple of states, but the flag \\\"\\n \\\"state_is_tuple is not set. State size is: %s\\\"\\n % str(cell.state_size))\\n if not state_is_tuple:\\n logging.warn(\\n \\\"%s: Using a concatenated state is slower and will soon be \\\"\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\n\\n self._state_is_tuple = state_is_tuple\\n\\n if not state_is_tuple:\\n raise NotImplementedError\\n\\n self._cell = cell\\n self._input_size = input_size\\n self._output_size = output_size\\n if output_size is None:\\n self._output_size = cell.output_size\\n self._attn_size = attn_size\\n self._reuse = reuse\\n self._attn_inputs = attn_inputs\\n self._attn_vec_size = attn_vec_size\\n self.attn_masks = attn_masks\\n self.merge_output_attn = merge_output_attn\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\\n if attn_len and not cells:\\n # Add attention wrapper to first layer.\\n cell = tf.contrib.rnn.AttentionCellWrapper(\\n cell, attn_len, state_is_tuple=True)\\n cell = tf.contrib.rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return tf.contrib.rnn.MultiRNNCell(cells)\",\n \"def __init__(self, input_size, hidden_size, output_size, model=\\\"gru\\\", n_layers=1):\\n \\n super(CharRNN, self).__init__()\\n\\n self.input_size = input_size\\n self.hidden_size = hidden_size\\n self.output_size = output_size\\n self.n_layers = n_layers\\n\\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\\n \\n self.model = model\\n if model.lower() == \\\"lstm\\\":\\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\\n else: # model is GRU\\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\\n\\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer\",\n \"def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\\n is_batch_norm, is_bidirectional):\\n if is_batch_norm:\\n input_data = tf.keras.layers.BatchNormalization(\\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\\n rnn_layer = rnn_cell(\\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\\n name=\\\"rnn_{}\\\".format(layer_id))\\n if is_bidirectional:\\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\\\"sum\\\")\\n\\n return rnn_layer(input_data)\",\n \"def build_rnn(cell, inputs):\\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name=\\\"final_state\\\")\\n\\n return outputs, final_state\",\n \"def _initialize_gru_cell(self, num_units):\\n return gru_cell.LayerNormGRUCell(\\n num_units,\\n w_initializer=self.uniform_initializer,\\n u_initializer=random_orthonormal_initializer,\\n b_initializer=tf.constant_initializer(0.0))\",\n \"def get_init_cell(batch_size, rnn_size):\\n\\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\\n num_of_layers = 3\\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name='initial_state')\\n \\n return (cell, initial_state)\",\n \"def custom_rnn(cell, inputs, initial_state=None, dtype=None,\\r\\n sequence_length=None, scope=None):\\r\\n\\r\\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\\r\\n raise TypeError(\\\"cell must be an instance of RNNCell\\\")\\r\\n if not nest.is_sequence(inputs):\\r\\n raise TypeError(\\\"inputs must be a sequence\\\")\\r\\n if not inputs:\\r\\n raise ValueError(\\\"inputs must not be empty\\\")\\r\\n\\r\\n outputs = []\\r\\n states = []\\r\\n # Create a new scope in which the caching device is either\\r\\n # determined by the parent scope, or is set to place the cached\\r\\n # Variable using the same placement as for the rest of the RNN.\\r\\n with vs.variable_scope(scope or \\\"RNN\\\") as varscope:\\r\\n if varscope.caching_device is None:\\r\\n varscope.set_caching_device(lambda op: op.device)\\r\\n\\r\\n # Obtain the first sequence of the input\\r\\n first_input = inputs\\r\\n while nest.is_sequence(first_input):\\r\\n first_input = first_input[0]\\r\\n\\r\\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\\r\\n # TODO(lukaszkaiser): remove EmbeddingWrapper\\r\\n if first_input.get_shape().ndims != 1:\\r\\n\\r\\n input_shape = first_input.get_shape().with_rank_at_least(2)\\r\\n fixed_batch_size = input_shape[0]\\r\\n\\r\\n flat_inputs = nest.flatten(inputs)\\r\\n for flat_input in flat_inputs:\\r\\n input_shape = flat_input.get_shape().with_rank_at_least(2)\\r\\n batch_size, input_size = input_shape[0], input_shape[1:]\\r\\n fixed_batch_size.merge_with(batch_size)\\r\\n for i, size in enumerate(input_size):\\r\\n if size.value is None:\\r\\n raise ValueError(\\r\\n \\\"Input size (dimension %d of inputs) must be accessible via \\\"\\r\\n \\\"shape inference, but saw value None.\\\" % i)\\r\\n else:\\r\\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\\r\\n\\r\\n if fixed_batch_size.value:\\r\\n batch_size = fixed_batch_size.value\\r\\n else:\\r\\n batch_size = array_ops.shape(first_input)[0]\\r\\n if initial_state is not None:\\r\\n state = initial_state\\r\\n else:\\r\\n if not dtype:\\r\\n raise ValueError(\\\"If no initial_state is provided, \\\"\\r\\n \\\"dtype must be specified\\\")\\r\\n state = cell.zero_state(batch_size, dtype)\\r\\n\\r\\n if sequence_length is not None: # Prepare variables\\r\\n sequence_length = ops.convert_to_tensor(\\r\\n sequence_length, name=\\\"sequence_length\\\")\\r\\n if sequence_length.get_shape().ndims not in (None, 1):\\r\\n raise ValueError(\\r\\n \\\"sequence_length must be a vector of length batch_size\\\")\\r\\n def _create_zero_output(output_size):\\r\\n # convert int to TensorShape if necessary\\r\\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\\r\\n output = array_ops.zeros(\\r\\n array_ops.pack(size), _infer_state_dtype(dtype, state))\\r\\n shape = _state_size_with_prefix(\\r\\n output_size, prefix=[fixed_batch_size.value])\\r\\n output.set_shape(tensor_shape.TensorShape(shape))\\r\\n return output\\r\\n\\r\\n output_size = cell.output_size\\r\\n flat_output_size = nest.flatten(output_size)\\r\\n flat_zero_output = tuple(\\r\\n _create_zero_output(size) for size in flat_output_size)\\r\\n zero_output = nest.pack_sequence_as(structure=output_size,\\r\\n flat_sequence=flat_zero_output)\\r\\n\\r\\n sequence_length = math_ops.to_int32(sequence_length)\\r\\n min_sequence_length = math_ops.reduce_min(sequence_length)\\r\\n max_sequence_length = math_ops.reduce_max(sequence_length)\\r\\n\\r\\n for time, input_ in enumerate(inputs):\\r\\n if time > 0: varscope.reuse_variables()\\r\\n # pylint: disable=cell-var-from-loop\\r\\n call_cell = lambda: cell(input_, state)\\r\\n # pylint: enable=cell-var-from-loop\\r\\n if sequence_length is not None:\\r\\n (output, state) = _rnn_step(\\r\\n time=time,\\r\\n sequence_length=sequence_length,\\r\\n min_sequence_length=min_sequence_length,\\r\\n max_sequence_length=max_sequence_length,\\r\\n zero_output=zero_output,\\r\\n state=state,\\r\\n call_cell=call_cell,\\r\\n state_size=cell.state_size)\\r\\n else:\\r\\n (output, state) = call_cell()\\r\\n\\r\\n outputs.append(output)\\r\\n states.append(state)\\r\\n\\r\\n return (outputs, state, states)\",\n \"def __init__(self, context, problem, update_rate=1, debug=False):\\n tf.keras.layers.AbstractRNNCell.__init__(self)\\n self.context = context\\n self.problem = problem\\n\\n if hasattr(self.context, 'scale'):\\n self.scale = self.context.scale\\n else:\\n self.scale = 1\\n\\n self.debug = debug\\n\\n # shape related information\\n self.batch_size = self.context.batch_size\\n self.dim_x = self.context.dim_x\\n self.dim_z = self.context.dim_z\\n self.dim_u = self.context.dim_u\\n\\n # rate at which observations are taken into account\\n self.update_rate = tf.ones([], dtype=tf.float32) * update_rate\\n\\n self.filter_layers = []\",\n \"def _single_cell(num_units,\\n dropout,\\n mode,\\n residual_connection=False,\\n device_str=None):\\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\\n\\n # Cell Type\\n utils.print_out(\\\" GRU\\\", new_line=False)\\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n utils.print_out(\\n \\\" %s, dropout=%g \\\" % (type(single_cell).__name__, dropout),\\n new_line=False)\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\\n utils.print_out(\\\" %s\\\" % type(single_cell).__name__, new_line=False)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\\n utils.print_out(\\n \\\" %s, device=%s\\\" % (type(single_cell).__name__, device_str),\\n new_line=False)\\n\\n return single_cell\",\n \"def resnet10(shortcut_type, num_classes, in_channels):\\n model = ResNet(BasicBlock, [1, 1, 1, 1], shortcut_type, num_classes, in_channels)\\n return model\",\n \"def create_model():\\n\\n class Net(nn.Cell):\\n def construct(self, x, y):\\n return x\\n\\n net = Net()\\n model_simple = Model(net)\\n\\n return model_simple\",\n \"def __init__(self, cell_index, stimulus_type, loss='poisson_loss', optimizer='sgd',\\n weight_init='glorot_normal', l2_reg=0., mean_adapt=False):\\n\\n self.stim_shape = (40, 50, 50)\\n\\n # build the model (flatten the input, followed by a dense layer and\\n # softplus activation)\\n with notify('Building LN model'):\\n self.model = Sequential()\\n self.model.add(Flatten(input_shape=self.stim_shape))\\n self.model.add(Dense(1, activation='softplus', init=weight_init,\\n W_regularizer=l2(l2_reg)))\\n\\n # save architecture string (for markdown file)\\n self.architecture = '\\\\n'.join(['l2 regularization: {}'.format(l2_reg),\\n 'stimulus shape: {}'.format(self.stim_shape),\\n 'weight initialization: {}'.format(weight_init)])\\n\\n # compile\\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embedding = get_embed(input_data, vocab_size, rnn_size)\\n outputs, final_state = build_rnn(cell, embedding)\\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\\n\\n return logits, final_state\",\n \"def rnn_cell(hprev, zt, name=None, reuse=False):\\n nin = zt.shape[-1].value\\n nout = hprev.shape[-1].value\\n with tf.variable_scope(name, default_name=\\\"rnn\\\", values=[hprev, zt], reuse=reuse):\\n wz = get_variable_wrap(\\\"kernel/input\\\", [nin, nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n wh = get_variable_wrap(\\\"kernel/hidden\\\", [nout, nout],dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n bh = get_variable_wrap(\\\"bias\\\", [nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n \\n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = rnn.LSTMBlockCell(layer_size)\\n cell = rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return rnn.MultiRNNCell(cells)\",\n \"def get_init_cell(batch_size, rnn_size):\\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name=\\\"initial_state\\\")\\n\\n return cell, initial_state\",\n \"def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\\n # todo 1、获取嵌入层的输出\\n embed = get_embed(input_data, vocab_size, embed_dim)\\n # todo-2、获取 隐藏层的输出\\n rnn_outputs, final_state, final_state1 = build_rnn(\\n cell, embed, initial_state=initial_state)\\n # 3、构建全连接，获取logits\\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\\n # [N, n-steps, num_classes]\\n return logits, final_state, final_state1\",\n \"def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\\n residual_connection=False, device_str=None):\\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\\n dropout = dropout if mode == \\\"train\\\" else 0.0\\n # Cell Type\\n if unit_type == \\\"lstm\\\":\\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\\n\\n elif unit_type == \\\"gru\\\":\\n single_cell = tf.contrib.rnn.GRUCell(num_units)\\n\\n elif unit_type == \\\"layer_norm_lstm\\\":\\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units,layer_norm=True)\\n else:\\n raise ValueError(\\\"Unknown unit type %s!\\\" % unit_type)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.contrib.rnn.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\\n\\n return single_cell\",\n \"def __init__(self, layers, rnnType, seqLength=128, outputDim=None, activation=None, dropout=0.0):\\n model = utils.buildRNN(layers, rnnType, dropout)\\n super().__init__(torch.nn.Sequential(model), nnType='rnn')\\n \\n self.seqLength = seqLength\\n if outputDim is not None:\\n self.update(DNN([layers[-1]*seqLength, outputDim], [activation]).model)\\n self.nnType = 'rnn-mlp'\",\n \"def __init__(self,\\n shape,\\n kernel,\\n depth,\\n use_peepholes=False,\\n cell_clip=None,\\n initializer=None,\\n forget_bias=1.0,\\n activation=None,\\n normalize=None,\\n dropout=None,\\n reuse=None):\\n super(ConvLSTMCell, self).__init__(_reuse=reuse)\\n\\n tf_shape = tf.TensorShape(shape + [depth])\\n self._output_size = tf_shape\\n self._state_size = tf.nn.rnn_cell.LSTMStateTuple(tf_shape, tf_shape)\\n\\n self._kernel = kernel\\n self._depth = depth\\n self._use_peepholes = use_peepholes\\n self._cell_clip = cell_clip\\n self._initializer = initializer\\n self._forget_bias = forget_bias\\n self._activation = activation or tf.nn.tanh\\n self._normalize = normalize\\n self._dropout = dropout\\n\\n self._w_conv = None\\n if self._use_peepholes:\\n self._w_f_diag = None\\n self._w_i_diag = None\\n self._w_o_diag = None\",\n \"def __init__(self, num_units,\\n use_peepholes=False, cell_clip=None,\\n initializer=None, num_proj=None, proj_clip=None,\\n num_unit_shards=None, num_proj_shards=None,\\n forget_bias=1.0, state_is_tuple=False,\\n activation=None, trainable=None, name=None, dtype=None, residual_connection=False, **kwargs):\\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\\n if not state_is_tuple:\\n logging.warn(\\\"%s: Using a concatenated state is slower and will soon be \\\"\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\n if num_unit_shards is not None or num_proj_shards is not None:\\n logging.warn(\\n \\\"%s: The num_unit_shards and proj_unit_shards parameters are \\\"\\n \\\"depreca ted and will be removed in Jan 2017. \\\"\\n \\\"Use a variable scope with a partitioner instead.\\\", self)\\n if context.executing_eagerly() and context.num_gpus() > 0:\\n logging.warn(\\\"%s: Note that this cell is not optimized for performance. \\\"\\n \\\"Please use tf.contrib.cudnn_rnn.CudnnLSTM for better \\\"\\n \\\"performance on GPU.\\\", self)\\n self._num_units = num_units\\n self._use_peepholes = use_peepholes\\n self._cell_clip = cell_clip\\n self._initializer = initializers.get(initializer)\\n self._num_proj = num_proj\\n self._proj_clip = proj_clip\\n self._num_unit_shards = num_unit_shards\\n self._num_proj_shards = num_proj_shards\\n self._forget_bias = forget_bias\\n self._state_is_tuple = state_is_tuple\\n self.residual_connection = residual_connection\\n self._kernel = None\\n self._bias = None\\n self._w_f_diag = None\\n self._w_i_diag = None\\n self._w_o_diag = None\\n self._proj_kernel = None\\n if activation:\\n self._activation = activations.get(activation)\\n else:\\n self._activation = math_ops.tanh\\n\\n if num_proj:\\n self.state_size = [num_proj, num_units]\\n self._output_size = num_proj\\n\\n else:\\n self._state_size = [num_units, num_units]\\n self._output_size = num_units\",\n \"def __init__(self, num_nodes, h_dim, out_dim, num_rels,\\n num_bases=-1, num_hidden_layers=1, dropout=0.5, bias=False):\\n super(RGCN, self).__init__()\\n self.num_nodes = num_nodes\\n self.h_dim = h_dim\\n self.out_dim = out_dim\\n self.num_rels = num_rels\\n self.num_bases = num_bases\\n self.num_hidden_layers = num_hidden_layers\\n self.dropout = dropout\\n self.bias = bias\\n\\n self.layers = nn.ModuleList()\\n # create rgcn layers\\n self.build_model()\",\n \"def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\\n if rnn_type.endswith('lstm'):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n elif rnn_type.endswith('gru'):\\n cell = tc.rnn.GRUCell(num_units=hidden_size)\\n elif rnn_type.endswith('rnn'):\\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\\n else:\\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n if layer_num > 1:\\n cell = tc.rnn.MultiRNNCell([cell] * layer_num, state_is_tuple=True)\\n return cell\",\n \"def __init__(self,\\n num_units,\\n use_peepholes=False,\\n cell_clip=None,\\n initializer=None,\\n num_proj=None,\\n proj_clip=None,\\n num_unit_shards=None,\\n num_proj_shards=None,\\n forget_bias=1.0,\\n state_is_tuple=True,\\n activation=None,\\n reuse=None):\\n super(MaskedLSTMCell, self).__init__(\\n num_units,\\n use_peepholes=use_peepholes,\\n cell_clip=cell_clip,\\n initializer=initializer,\\n num_proj=num_proj,\\n proj_clip=proj_clip,\\n num_unit_shards=num_unit_shards,\\n num_proj_shards=num_proj_shards,\\n forget_bias=forget_bias,\\n state_is_tuple=state_is_tuple,\\n activation=activation,\\n reuse=reuse)\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embed = get_embed(input_data, vocab_size, embed_dim) \\n output, final_state = build_rnn(cell, embed)\\n \\n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\\n #final_state = tf.identity(final_state, name='final_state') \\n return logits, final_state\",\n \"def __init__(self,\\n layer,\\n train_batch=1,\\n query_batch=1,\\n num_steps=1,\\n init_lr=0.2,\\n initializer=tf.contrib.layers.xavier_initializer(),\\n loss=batched_mse,\\n flatten_output=True,\\n reuse=None):\\n super(Cell, self).__init__(_reuse=reuse)\\n self._layer = layer\\n self._train_batch = train_batch\\n self._query_batch = query_batch\\n self._num_steps = num_steps\\n self._init_lr = init_lr\\n self._initializer = initializer\\n self._loss = loss\\n self._flatten_output = flatten_output\",\n \"def single_cell(\\n cell_class,\\n cell_params,\\n dp_input_keep_prob=1.0,\\n dp_output_keep_prob=1.0,\\n recurrent_keep_prob=1.0,\\n input_weight_keep_prob=1.0,\\n recurrent_weight_keep_prob=1.0,\\n weight_variational=False,\\n dropout_seed=None,\\n zoneout_prob=0.,\\n training=True,\\n residual_connections=False,\\n awd_initializer=False,\\n variational_recurrent=False, # in case they want to use DropoutWrapper\\n dtype=None,\\n):\\n if awd_initializer:\\n val = 1.0/math.sqrt(cell_params['num_units'])\\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\\n if recurrent_keep_prob < 1.0:\\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\\n if input_weight_keep_prob < 1.0:\\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\\n if recurrent_weight_keep_prob < 1.0:\\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\\n if weight_variational:\\n cell_params['weight_variational'] = weight_variational # which is basically True\\n if dropout_seed:\\n cell_params['dropout_seed'] = dropout_seed\\n\\n\\n cell = cell_class(**cell_params)\\n if residual_connections:\\n cell = ResidualWrapper(cell)\\n if zoneout_prob > 0. and (\\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\\n ):\\n raise ValueError(\\n \\\"Currently applying both dropout and zoneout on the same cell.\\\"\\n \\\"This is currently not supported.\\\"\\n )\\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\\n cell = DropoutWrapper(\\n cell,\\n input_keep_prob=dp_input_keep_prob,\\n output_keep_prob=dp_output_keep_prob,\\n variational_recurrent=variational_recurrent,\\n dtype=dtype,\\n seed=dropout_seed\\n )\\n if zoneout_prob > 0.:\\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\\n return cell\",\n \"def _rnn_cells(self) -> RNNCellTuple:\\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))\",\n \"def init_gru(rnn):\\n\\n def _concat_init(tensor, init_funcs):\\n (length, fan_out) = tensor.shape\\n fan_in = length // len(init_funcs)\\n\\n for (i, init_func) in enumerate(init_funcs):\\n init_func(tensor[i * fan_in: (i + 1) * fan_in, :])\\n\\n def _inner_uniform(tensor):\\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\\n\\n for i in range(rnn.num_layers):\\n _concat_init(\\n getattr(rnn, 'weight_ih_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, _inner_uniform]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\\n\\n _concat_init(\\n getattr(rnn, 'weight_hh_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)\",\n \"def lstm_cell():\\n if 'reuse' in inspect.getargspec(\\n tf.contrib.rnn.BasicLSTMCell.__init__).args:\\n return tf.contrib.rnn.BasicLSTMCell(\\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True,\\n reuse=tf.get_variable_scope().reuse)\\n else:\\n return tf.contrib.rnn.BasicLSTMCell(\\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True)\",\n \"def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\\n\\t\\treturn _mh.create_rnn_cell(\\n\\t\\t\\tunit_type=hparams.unit_type,\\n\\t\\t\\tnum_units=self.num_units,\\n\\t\\t\\tnum_layers=num_layers,\\n\\t\\t\\tnum_residual_layers=num_residual_layers,\\n\\t\\t\\tforget_bias=hparams.forget_bias,\\n\\t\\t\\tdropout=hparams.dropout,\\n\\t\\t\\tmode=self.mode)\",\n \"def init_gru(rnn):\\n \\n def _concat_init(tensor, init_funcs):\\n (length, fan_out) = tensor.shape\\n fan_in = length // len(init_funcs)\\n \\n for (i, init_func) in enumerate(init_funcs):\\n init_func(tensor[i * fan_in : (i + 1) * fan_in, :])\\n \\n def _inner_uniform(tensor):\\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\\n \\n for i in range(rnn.num_layers):\\n _concat_init(\\n getattr(rnn, 'weight_ih_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, _inner_uniform]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\\n\\n _concat_init(\\n getattr(rnn, 'weight_hh_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)\",\n \"def setup_rnn_model(default_ctx,\\n num_lstm_layer, \\n num_hidden,\\n batch_size,\\n initializer,\\n group2ctx=None, concat_decode=True,\\n use_loss=False, buckets=None):\\n max_len = n_steps\\n max_rnn_exec = None\\n rnn_sym = lstm_unroll(num_lstm_layer=num_lstm_layer,\\n num_hidden=num_hidden)\\n arg_names = rnn_sym.list_arguments()\\n internals = rnn_sym.get_internals()\\n\\n input_shapes = {}\\n for name in arg_names:\\n if name.endswith(\\\"init_c\\\") or name.endswith(\\\"init_h\\\"):\\n input_shapes[name] = (batch_size, num_hidden)\\n elif name.endswith(\\\"data\\\"):\\n input_shapes[name] = (batch_size,MAX_LEN)\\n elif name == \\\"labels\\\":\\n input_shapes[name] = (batch_size,MAX_LEN)\\n elif name.endswith(\\\"label\\\"):\\n input_shapes[name] = (batch_size, )\\n else:\\n pass\\n\\n arg_shape, out_shape, aux_shape = rnn_sym.infer_shape(**input_shapes)\\n # bind arrays\\n arg_arrays = []\\n args_grad = {}\\n for shape, name in zip(arg_shape, arg_names):\\n group = internals[name].attr(\\\"ctx_group\\\")\\n ctx = group2ctx[group] if group is not None else default_ctx\\n arg_arrays.append(mx.nd.zeros(shape, ctx))\\n if is_param_name(name):\\n args_grad[name] = mx.nd.zeros(shape, ctx)\\n if not name.startswith(\\\"t\\\"):\\n print(\\\"%s group=%s, ctx=%s\\\" % (name, group, str(ctx)))\\n \\n #bind with shared executor\\n rnn_exec = None\\n rnn_exec = rnn_sym.bind(default_ctx, args=arg_arrays,\\n args_grad=args_grad,\\n grad_req=\\\"add\\\", group2ctx=group2ctx)\\n max_rnn_exec = rnn_exec\\n \\n\\n param_blocks = []\\n arg_dict = dict(zip(arg_names, rnn_exec.arg_arrays))\\n for i, name in enumerate(arg_names):\\n if is_param_name(name):\\n initializer(name, arg_dict[name])\\n param_blocks.append((i, arg_dict[name], args_grad[name], name))\\n else:\\n assert name not in args_grad\\n\\n out_dict = dict(zip(rnn_sym.list_outputs(), rnn_exec.outputs))\\n\\n init_states = [LSTMState(c=arg_dict[\\\"l%d_init_c\\\" % i],\\n h=arg_dict[\\\"l%d_init_h\\\" % i]) for i in range(num_lstm_layer)]\\n\\n seq_data = rnn_exec.arg_dict[\\\"data\\\"]\\n # we don't need to store the last state \\n last_states = None\\n\\n seq_outputs = [out_dict[\\\"sm_output\\\"]]\\n seq_labels = [rnn_exec.arg_dict[\\\"labels\\\"]]\\n\\n model = LSTMModel(rnn_exec=rnn_exec, symbol=rnn_sym,\\n init_states=init_states, last_states=last_states,\\n seq_data=seq_data, seq_labels=seq_labels, seq_outputs=seq_outputs,\\n param_blocks=param_blocks)\\n return model\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):\\n super(ModGRUCell, self).__init__()\\n\\n self.height, self.width = input_size\\n self.input_dim = input_dim\\n self.hidden_dim = hidden_dim\\n\\n self.kernel_size = kernel_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.bias = bias\\n\\n self.conv1 = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\\n out_channels=1,\\n kernel_size=self.kernel_size,\\n padding=self.padding,\\n bias=self.bias)\\n \\n self.conv2 = nn.Conv2d(in_channels=self.input_dim,\\n out_channels=self.hidden_dim,\\n kernel_size=self.kernel_size,\\n padding=self.padding,\\n bias=self.bias)\",\n \"def _create_cell(self,row_number,cell_number):\\n cell = Cell(self)\\n cell.x = cell_number * self.cell_width\\n cell.y = row_number * self.cell_width\\n cell.rect.x = cell.x\\n cell.rect.y = cell.y\\n return cell\",\n \"def __init__(self, init_grid=None):\\n\\n self.height = len(init_grid)\\n self.width = len(init_grid[0])\\n\\n self.grid = [[Cell(self, c) for c in row]\\n for row in init_grid]\\n\\n self.g = nx.Graph()\\n self.tangle()\",\n \"def _build_pnasnet_base(\\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\\n start_cell_num):\\n\\n # Find where to place the reduction cells or stride normal cells\\n reduction_indices = nasnet_utils.calc_reduction_layers(\\n hparams.num_cells, hparams.num_reduction_layers)\\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\\n\\n # Note: The None is prepended to match the behavior of _imagenet_stem()\\n cell_outputs = [None, hidden_previous, hidden]\\n net = hidden\\n\\n # Run the cells\\n for cell_num in range(start_cell_num, hparams.num_cells):\\n is_reduction = cell_num in reduction_indices\\n stride = 2 if is_reduction else 1\\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\\n prev_layer = cell_outputs[-2]\\n net = normal_cell(\\n net,\\n scope='cell_{}'.format(cell_num),\\n filter_scaling=filter_scaling,\\n stride=stride,\\n prev_layer=prev_layer,\\n cell_num=true_cell_num)\\n true_cell_num += 1\\n cell_outputs.append(net)\\n\\n # Final nonlinearity.\\n # Note that we have dropped the final pooling, dropout and softmax layers\\n # from the default pnasnet version.\\n with tf.variable_scope('final_layer'):\\n net = tf.nn.relu(net)\\n return net\",\n \"def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\\n state_keep_prob=1.0, variational_recurrent=False,\\n input_size=None, dtype=None, seed=None,\\n dropout_state_filter_visitor=None):\\n if not _like_rnncell(cell):\\n raise TypeError(\\\"The parameter cell is not a RNNCell.\\\")\\n if (dropout_state_filter_visitor is not None\\n and not callable(dropout_state_filter_visitor)):\\n raise TypeError(\\\"dropout_state_filter_visitor must be callable\\\")\\n self._dropout_state_filter = (\\n dropout_state_filter_visitor or _default_dropout_state_filter_visitor)\\n with ops.name_scope(\\\"DropoutWrapperInit\\\"):\\n def tensor_and_const_value(v):\\n tensor_value = ops.convert_to_tensor(v)\\n const_value = tensor_util.constant_value(tensor_value)\\n return (tensor_value, const_value)\\n for prob, attr in [(input_keep_prob, \\\"input_keep_prob\\\"),\\n (state_keep_prob, \\\"state_keep_prob\\\"),\\n (output_keep_prob, \\\"output_keep_prob\\\")]:\\n tensor_prob, const_prob = tensor_and_const_value(prob)\\n if const_prob is not None:\\n if const_prob < 0 or const_prob > 1:\\n raise ValueError(\\\"Parameter %s must be between 0 and 1: %d\\\"\\n % (attr, const_prob))\\n setattr(self, \\\"_%s\\\" % attr, float(const_prob))\\n else:\\n setattr(self, \\\"_%s\\\" % attr, tensor_prob)\\n\\n # Set cell, variational_recurrent, seed before running the code below\\n self._cell = cell\\n self._variational_recurrent = variational_recurrent\\n self._seed = seed\\n\\n self._recurrent_input_noise = None\\n self._recurrent_state_noise = None\\n self._recurrent_output_noise = None\\n\\n if variational_recurrent:\\n if dtype is None:\\n raise ValueError(\\n \\\"When variational_recurrent=True, dtype must be provided\\\")\\n\\n def convert_to_batch_shape(s):\\n # Prepend a 1 for the batch dimension; for recurrent\\n # variational dropout we use the same dropout mask for all\\n # batch elements.\\n return array_ops.concat(\\n ([1], tensor_shape.TensorShape(s).as_list()), 0)\\n\\n def batch_noise(s, inner_seed):\\n shape = convert_to_batch_shape(s)\\n return random_ops.random_uniform(shape, seed=inner_seed, dtype=dtype)\\n\\n if (not isinstance(self._input_keep_prob, numbers.Real) or\\n self._input_keep_prob < 1.0):\\n if input_size is None:\\n raise ValueError(\\n \\\"When variational_recurrent=True and input_keep_prob < 1.0 or \\\"\\n \\\"is unknown, input_size must be provided\\\")\\n self._recurrent_input_noise = _enumerated_map_structure_up_to(\\n input_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"input\\\", i)),\\n input_size)\\n self._recurrent_state_noise = _enumerated_map_structure_up_to(\\n cell.state_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"state\\\", i)),\\n cell.state_size)\\n self._recurrent_output_noise = _enumerated_map_structure_up_to(\\n cell.output_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"output\\\", i)),\\n cell.output_size)\",\n \"def rnn_cell_loop(self):\\n\\n\\t\\t# Set up initial state\\n\\t\\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\\t\\t\\t# Spike\\n\\t\\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\\t\\t\\t\\t\\t# State\\n\\t\\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\\n\\t\\tself.h = [self.h]\\n\\t\\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\\n\\n\\t\\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\t\\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\n\\t\\t# Apply the EI mask to the recurrent weights\\n\\t\\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\\n\\n\\t\\t# Set up latency buffer if being used\\n\\t\\tif par['use_latency']:\\n\\t\\t\\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\\n\\t\\t\\tself.state_buffer = deque(self.state_buffer)\\n\\t\\t\\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\\n\\t\\t\\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\\n\\n\\t\\t# Set up output record\\n\\t\\tself.output = []\\n\\t\\tself.syn_x = []\\n\\t\\tself.syn_u = []\\n\\n\\t\\ty = 0.\\n\\t\\tfor t in range(par['num_time_steps']):\\n\\t\\t\\tself.t = t \\t\\t# For latency calculations\\n\\n\\t\\t\\tif par['cell_type'] == 'rate':\\n\\t\\t\\t\\traise Exception('Rate cell not yet implemented.')\\n\\t\\t\\telif par['cell_type'] == 'adex':\\n\\t\\t\\t\\tif t < 10:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\t\\t\\t\\tself.syn_x.append(syn_x)\\n\\t\\t\\t\\tself.syn_u.append(syn_u)\\n\\n\\t\\t\\telif par['cell_type'] == 'lif':\\n\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\n\\t\\t# Stack records\\n\\t\\tself.output = tf.stack(self.output, axis=0)\\n\\t\\tself.h = tf.stack(self.h, axis=0)\\n\\t\\tself.h_out = tf.stack(self.h_out, axis=0)\\n\\t\\tself.syn_x = tf.stack(self.syn_x, axis=0)\\n\\t\\tself.syn_u = tf.stack(self.syn_u, axis=0)\",\n \"def _build_rnn(self, n_cells, hidden_layer_size, num_layers,\\n batch_size, time_window, lr):\\n\\n x_anchor = tf.placeholder(shape=[batch_size, n_cells, time_window],\\n dtype=tf.float32)\\n x_pos = tf.placeholder(shape=[batch_size, n_cells, time_window],\\n dtype=tf.float32)\\n x_neg = tf.placeholder(shape=[batch_size, n_cells, time_window,],\\n dtype=tf.float32)\\n\\n def embed_rnn(x_in):\\n \\\"\\\"\\\"Gives RNN embedding of x_in.\\\"\\\"\\\"\\n x_in_flat = tf.reshape(x_in, [batch_size*time_window, n_cells])\\n w_in = tf.get_variable(\\\"w_in\\\", shape=[n_cells, hidden_layer_size],\\n initializer=tf.random_normal_initializer())\\n b_in = tf.get_variable(\\\"b_in\\\", shape=[hidden_layer_size],\\n initializer=tf.random_normal_initializer())\\n x_ld_flat = tf.matmul(x_in_flat, w_in) + b_in\\n x_ld = tf.reshape(x_ld_flat, [batch_size, time_window, hidden_layer_size])\\n\\n # stacked LSTM cells\\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_layer_size,\\n forget_bias=0.0,\\n state_is_tuple=True)\\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers,\\n state_is_tuple=True)\\n\\n # compute output\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n outputs, _ = tf.nn.dynamic_rnn(cell, x_ld,\\n initial_state=initial_state,\\n time_major=False)\\n\\n # reconstruct and compute loss on last output only\\n outputs_unp = tf.unpack(tf.transpose(outputs, [1, 0, 2]))\\n embedding = outputs_unp[-1]\\n\\n return embedding\\n\\n def distance_squared(embed1, embed2):\\n return tf.reduce_sum((embed1 - embed2)**2, 1)\\n\\n with tf.variable_scope(\\\"RNN\\\") as scope:\\n\\n # embed anchor, positive and negative examples.\\n embed_anchor = embed_rnn(tf.transpose(x_anchor, [0, 2, 1]))\\n # This enables reusing the RNN for anchor, pos and neg.\\n scope.reuse_variables()\\n # Check that we are reusing the same RNN using:\\n # print(tf.get_variable_scope().reuse)\\n embed_pos = embed_rnn(tf.transpose(x_pos, [0, 2, 1]))\\n embed_neg = embed_rnn(tf.transpose(x_neg, [0, 2, 1]))\\n\\n # Loss for each point max(d(anchor, pos)^2 - d(anchor, neg)^2 + 1, 0)\\n loss = tf.reduce_sum(tf.nn.relu(distance_squared(embed_anchor,\\n embed_pos) -\\n distance_squared(embed_anchor,\\n embed_neg)\\n + 1), 0)\\n # train model\\n train_step = tf.train.AdagradOptimizer(lr).minimize(loss)\\n\\n return (x_anchor, x_pos, x_neg, train_step, loss,\\n embed_anchor, embed_pos, embed_neg)\",\n \"def __init__(self,\\n num_units,\\n forget_bias=1.0,\\n state_is_tuple=True,\\n activation=None,\\n reuse=None,\\n name=None):\\n super(MaskedBasicLSTMCell, self).__init__(\\n num_units,\\n forget_bias=forget_bias,\\n state_is_tuple=state_is_tuple,\\n activation=activation,\\n reuse=reuse,\\n name=name)\",\n \"def build(self, input_tensors, is_training, lengths=None, hparams=None):\\n input_tensor = input_tensors[-1]\\n rnn_cell = tf.compat.v1.nn.rnn_cell.BasicRNNCell(\\n num_units=self._output_size, activation=tf.nn.tanh)\\n net, _ = tf.compat.v1.nn.dynamic_rnn(\\n rnn_cell, input_tensor, sequence_length=lengths, dtype=tf.float32)\\n\\n if self._skip:\\n net += _add_projection_if_needed(input_tensor, net)\\n\\n return input_tensors + [net]\",\n \"def __init__(self, num_outputs, use_ground_truth, internal_cell):\\n self._num_outputs = num_outputs\\n self._use_ground_truth = use_ground_truth # boolean\\n self._internal_cell = internal_cell # may be LSTM or GRU or anything\",\n \"def __init__(\\n self,\\n input_size,\\n hidden_size,\\n nonlinearity='relu',\\n num_layers=1,\\n bidirectional=False,\\n dropout=0,\\n **kwargs\\n ):\\n mode = 'rnn_relu' if nonlinearity == 'relu' else 'rnn_tanh'\\n super(RNN, self).__init__(\\n mode, input_size, hidden_size,\\n num_layers, bidirectional, dropout, **kwargs\\n )\",\n \"def __init__(\\n self,\\n input_tensor_spec,\\n output_tensor_spec,\\n conv_layer_params=None,\\n input_fc_layer_params=(200, 100),\\n lstm_size=(40,),\\n output_fc_layer_params=(200, 100),\\n activation_fn=tf.keras.activations.relu,\\n name='ActorRnnNetwork',\\n ):\\n if len(tf.nest.flatten(input_tensor_spec)) > 1:\\n raise ValueError('Only a single observation is supported by this network')\\n\\n input_layers = utils.mlp_layers(\\n conv_layer_params,\\n input_fc_layer_params,\\n activation_fn=activation_fn,\\n kernel_initializer=tf.compat.v1.keras.initializers.glorot_uniform(),\\n name='input_mlp',\\n )\\n\\n # Create RNN cell\\n if len(lstm_size) == 1:\\n cell = tf.keras.layers.LSTMCell(lstm_size[0])\\n else:\\n cell = tf.keras.layers.StackedRNNCells(\\n [tf.keras.layers.LSTMCell(size) for size in lstm_size]\\n )\\n\\n state_spec = tf.nest.map_structure(\\n functools.partial(\\n tensor_spec.TensorSpec, dtype=tf.float32, name='network_state_spec'\\n ),\\n list(cell.state_size),\\n )\\n\\n output_layers = utils.mlp_layers(\\n fc_layer_params=output_fc_layer_params, name='output'\\n )\\n\\n flat_action_spec = tf.nest.flatten(output_tensor_spec)\\n action_layers = [\\n tf.keras.layers.Dense(\\n single_action_spec.shape.num_elements(),\\n activation=tf.keras.activations.tanh,\\n kernel_initializer=tf.keras.initializers.RandomUniform(\\n minval=-0.003, maxval=0.003\\n ),\\n name='action',\\n )\\n for single_action_spec in flat_action_spec\\n ]\\n\\n super(ActorRnnNetwork, self).__init__(\\n input_tensor_spec=input_tensor_spec, state_spec=state_spec, name=name\\n )\\n\\n self._output_tensor_spec = output_tensor_spec\\n self._flat_action_spec = flat_action_spec\\n self._conv_layer_params = conv_layer_params\\n self._input_layers = input_layers\\n self._dynamic_unroll = dynamic_unroll_layer.DynamicUnroll(cell)\\n self._output_layers = output_layers\\n self._action_layers = action_layers\",\n \"def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\\n cells = []\\n for i in range(layer_num):\\n if rnn_type.endswith('lstm'):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n elif rnn_type.endswith('gru'):\\n cell = tc.rnn.GRUCell(num_units=hidden_size)\\n elif rnn_type.endswith('rnn'):\\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\\n else:\\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\\n return cells\",\n \"def __init__(self, model, num_classes=-1, hidden_size=128, type='gru', **kwargs):\\n super(CNNRNN, self).__init__(**kwargs)\\n self.feats = model is None\\n with self.name_scope():\\n if model is not None:\\n self.td = TimeDistributed(model.backbone)\\n if type == 'lstm':\\n self.rnn = mx.gluon.rnn.LSTM(hidden_size, layout=\\\"NTC\\\", bidirectional=True)\\n else:\\n self.rnn = mx.gluon.rnn.GRU(hidden_size, layout=\\\"NTC\\\", bidirectional=True)\\n self.classes = None\\n if num_classes == 0:\\n self.classes = model.classes\\n elif num_classes > 0:\\n self.classes = nn.Dense(num_classes, flatten=True)\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\\n super(ConvGRUCell, self).__init__()\\n self.height, self.width = input_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.hidden_dim = hidden_dim\\n self.bias = bias\\n self.dtype = dtype\\n\\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\\n\\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\\n out_channels=self.hidden_dim, # for candidate neural memory\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\",\n \"def __init__(self, celltype, model=None, build_mode='lazy'):\\n # Generate the NineLine class from the nineml file and initialise a\\n # single cell from it\\n if (isinstance(celltype, BiophysNineml) or isinstance(celltype, str)):\\n self.celltype = CellMetaClass(celltype, build_mode=build_mode)\\n else:\\n self.celltype = celltype\\n self.default_seg = self.celltype(model=model).source_section.name\\n self._model = model\\n self.genome_keys = []\\n self.log_scales = []\",\n \"def __call__(self, inputs, state, scope=None, debug=False):\\n # B is batch size.\\n\\n # 1) Use read_ind to find memory location to read from\\n # as input.\\n\\n # inputs.read_ind: (B, 1)\\n # memory: (B, mem_size, embed_size)\\n read_ind = tf.to_int32(inputs.read_ind)\\n batch_size = tf.shape(read_ind)[0]\\n if debug:\\n print('batch size is', batch_size)\\n print('read ind is', read_ind)\\n mem_ind = tf.range(batch_size)\\n\\n # read_mem_ind: (B, 1)\\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n # read_ind: (B, 2)\\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\\n if debug:\\n print('processed read ind is', read_ind)\\n\\n # inner_inputs: (B, embed_size)\\n inner_inputs = tf.gather_nd(state.memory, read_ind)\\n if debug:\\n print('inner_inputs is', inner_inputs)\\n\\n inner_state = state.inner_state\\n\\n # 2) Run the inner RNNCell.\\n \\n # inner_outputs: (B, embed_size)\\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\\n\\n if debug:\\n print('inner_outputs is', inner_outputs)\\n\\n # 3) Compute logits for valid indices (using logit_masks\\n # to mask out padded valid indices (-1)).\\n \\n # valid_indices: (B, max_n_valid_indices)\\n valid_indices = tf.to_int32(inputs.valid_indices)\\n if debug:\\n print('valid_indices is', valid_indices)\\n \\n # Logit mask: (B, max_n_valid_indices)\\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\\n logit_masks = tf.cast(logit_masks, tf.float32)\\n\\n if debug:\\n print('logit_masks is', logit_masks)\\n\\n # Normalize indices to be at least 0.\\n valid_indices = tf.maximum(valid_indices, 0)\\n\\n # valid_indices: (B, max_n_valid_indices, 1)\\n valid_indices = tf.expand_dims(valid_indices, -1)\\n if debug:\\n print('valid_indices is', valid_indices)\\n print('mem_ind is', mem_ind)\\n\\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # valid_mem_ind: (B, 1, 1)\\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\\n if debug:\\n print('valid_mem_ind is', valid_mem_ind)\\n\\n # valid_mem_ind: (B, max_n_valid_indices, 1)\\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\\n\\n # valid_indices: (B, max_n_valid_indices, 2)\\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\\n # index into the right memory location.\\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\\n\\n if debug:\\n print('valid_indices is', valid_indices)\\n\\n # select all the valid slots. \\n # valid_values: (B, max_n_valid_indices, embed_size)\\n valid_values = tf.gather_nd(state.memory, valid_indices)\\n if debug:\\n print('valid_values is', valid_values)\\n \\n # expanded_inner_outputs: (B, 1, embed_size)\\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\\n if debug:\\n print('expanded_inner_outputs is', expanded_inner_outputs)\\n\\n # valid_values: (B, embed_size, max_n_valid_indices)\\n valid_values = tf.transpose(valid_values, [0, 2, 1])\\n if debug:\\n print('valid_values is', valid_values)\\n\\n # logits: (B, 1, max_n_valid_indices)\\n logits = tf.matmul(expanded_inner_outputs, valid_values)\\n \\n if debug:\\n print('logits is', logits)\\n\\n # logits: (B, max_n_valid_indices)\\n logits = tf.squeeze(logits, axis=[1])\\n if debug:\\n print('logits is', logits)\\n\\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\\n\\n outputs = masked_logits\\n # 4) Write the output of the inner RNN to a memory\\n # location (write_ind), using write_masks to mask out\\n # padded write_ind (-1).\\n \\n # write_ind: (B, 1)\\n write_ind = tf.cast(inputs.write_ind, tf.int32)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n # write mask: (B, 1)\\n write_masks = tf.greater_equal(inputs.write_ind, 0)\\n if debug:\\n print('write_masks greater_equal', write_masks)\\n\\n write_masks = tf.cast(write_masks, tf.float32)\\n\\n # write mask: (B, 1, 1)\\n write_masks = tf.expand_dims(write_masks, [-1])\\n\\n if debug:\\n print('write_masks is', write_masks)\\n\\n # Normalize write_ind to be above 0.\\n # write_ind: (B, 1)\\n write_ind = tf.maximum(write_ind, 0)\\n\\n # write_mem_ind: (B, 1)\\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # write_ind: (B, 2)\\n # Second dimension is [b_i, write_index]\\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n if debug:\\n print('masked_logits is', masked_logits)\\n print('memory is', state.memory)\\n\\n # write_mat: (B, mem_size, embed_size)\\n write_mat = tf.scatter_nd(\\n write_ind, inner_outputs, shape=tf.shape(state.memory))\\n\\n if debug:\\n print('@' * 50)\\n print('write_mat is', write_mat)\\n print('write_mask is', write_masks)\\n print('@' * 50)\\n\\n masked_write_mat = write_mat * write_masks\\n new_memory = state.memory + masked_write_mat\\n \\n state = MemoryStateTuple(new_memory, new_inner_state)\\n if debug:\\n print('state is', state)\\n \\n return (outputs, state)\",\n \"def resnet_9blocks(pretrained=False, **kwargs):\\n return ResnetGenerator(\\n 9, **kwargs\\n )\",\n \"def __init__(self,\\n num_units,\\n forget_bias=1.0,\\n activation=None,\\n reuse=None,\\n layer_norm: bool=False,\\n norm_shift: float=0.0,\\n norm_gain: float=1.0, # layer normalization\\n dropout_keep_prob_in: float = 1.0,\\n dropout_keep_prob_h: float=1.0,\\n dropout_keep_prob_out: float=1.0,\\n dropout_keep_prob_gate: float=1.0,\\n dropout_keep_prob_forget: float=1.0,\\n dropout_prob_seed: int=None,\\n variational_dropout: bool=False,\\n recurrent_dropout: bool=False\\n ):\\n super(CustomLSTMCell, self).__init__(_reuse=reuse)\\n self._num_units = num_units\\n self._forget_bias = forget_bias\\n self._activation = activation or math_ops.tanh\\n\\n self._layer_norm = layer_norm\\n self._g = norm_gain\\n self._b = norm_shift\\n\\n self._recurrent_dropout = recurrent_dropout\\n self._variational_dropout = variational_dropout\\n \\n self._seed = dropout_prob_seed\\n self._keep_prob_i = dropout_keep_prob_in\\n self._keep_prob_g = dropout_keep_prob_gate\\n self._keep_prob_f = dropout_keep_prob_forget\\n self._keep_prob_o = dropout_keep_prob_out\\n self._keep_prob_h = dropout_keep_prob_h\",\n \"def resnet10(**kwargs):\\n model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)\\n return model\",\n \"def get_rnn_cells(self):\\n return [self.rnn]\",\n \"def SimpleRNN(self):\\n # Model.\\n model = Sequential()\\n model.add(SimpleRNN(2048, return_sequences=True,\\n input_shape=self.input_shape,\\n dropout=0.0))\\n #model.add(Flatten()) #qiao_added\\n # model.add(Dense(1024, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(2048, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Flatten())\\n model.add(Dense(self.nb_classes, activation='softmax'))\\n return model\",\n \"def __call__(self, inputs, state, scope=None):\\n if scope is not None:\\n with vs.variable_scope(scope,\\n custom_getter=self._rnn_get_variable) as scope:\\n return super(RNNCell, self).__call__(inputs, state, scope=scope)\\n else:\\n scope_attrname = \\\"rnncell_scope\\\"\\n scope = getattr(self, scope_attrname, None)\\n if scope is None:\\n scope = vs.variable_scope(vs.get_variable_scope(),\\n custom_getter=self._rnn_get_variable)\\n setattr(self, scope_attrname, scope)\\n with scope:\\n return super(RNNCell, self).__call__(inputs, state)\",\n \"def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\\n is_training=True, seed=None):\\n if not isinstance(cell, tf.nn.rnn_cell.RNNCell):\\n raise TypeError(\\\"The parameter cell is not a RNNCell.\\\")\\n if (isinstance(input_keep_prob, float) and\\n not (input_keep_prob >= 0.0 and input_keep_prob <= 1.0)):\\n raise ValueError(\\\"Parameter input_keep_prob must be between 0 and 1: %d\\\"\\n % input_keep_prob)\\n if (isinstance(output_keep_prob, float) and\\n not (output_keep_prob >= 0.0 and output_keep_prob <= 1.0)):\\n raise ValueError(\\\"Parameter output_keep_prob must be between 0 and 1: %d\\\"\\n % output_keep_prob)\\n self._cell = cell\\n self._input_keep_prob = input_keep_prob\\n self._output_keep_prob = output_keep_prob\\n self._seed = seed\\n self._is_training = is_training\",\n \"def __init__(self, name=\\\"conv_1d_lstm_cell\\\", **kwargs):\\n super(Conv1DLSTMCell, self).__init__(conv_ndims=1, name=name, **kwargs)\",\n \"def __init__(self, width=20, height=20):\\n self.width = width\\n self.height = height\\n self.cells = []\\n for y in range(self.height):\\n for x in range(self.width):\\n self.cells.append(Cell(x, y, [N, S, E, W]))\",\n \"def n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs,\\n activation, use_bi_direction, **kwargs): # NOQA\\n\\n argument.check_unexpected_kwargs(\\n kwargs, train='train argument is not supported anymore. '\\n 'Use chainer.using_config',\\n use_cudnn='use_cudnn argument is not supported anymore. '\\n 'Use chainer.using_config')\\n argument.assert_kwargs_empty(kwargs)\\n\\n activation_list = ['tanh', 'relu']\\n if activation not in activation_list:\\n candidate = ','.join(activation_list)\\n raise ValueError('Invalid activation: \\\"%s\\\". Please select from [%s]'\\n % (activation, candidate))\\n\\n xp = cuda.get_array_module(hx)\\n\\n if xp is not numpy and chainer.should_use_cudnn('>=auto', 5000):\\n states = get_random_state().create_dropout_states(dropout_ratio)\\n lengths = [len(x) for x in xs]\\n xs = chainer.functions.concat(xs, axis=0)\\n\\n rnn_mode = 'rnn_%s' % activation\\n w = cudnn_rnn_weight_concat(\\n n_layers, states, use_bi_direction, rnn_mode, ws, bs)\\n\\n if use_bi_direction:\\n # Bi-directional RNN\\n if activation == 'tanh':\\n rnn = NStepBiRNNTanh\\n elif activation == 'relu':\\n rnn = NStepBiRNNReLU\\n else:\\n # Uni-directional RNN\\n if activation == 'tanh':\\n rnn = NStepRNNTanh\\n elif activation == 'relu':\\n rnn = NStepRNNReLU\\n\\n hy, ys = rnn(n_layers, states, lengths)(hx, w, xs)\\n sections = numpy.cumsum(lengths[:-1])\\n ys = chainer.functions.split_axis(ys, sections, 0)\\n return hy, ys\\n\\n else:\\n\\n def f(x, h, c, w, b):\\n xw, hw = w\\n xb, hb = b\\n rnn_in = linear.linear(x, xw, xb) + linear.linear(h, hw, hb)\\n if activation == 'tanh':\\n return tanh.tanh(rnn_in), None\\n elif activation == 'relu':\\n return relu.relu(rnn_in), None\\n\\n hy, _, ys = n_step_rnn_impl(\\n f, n_layers, dropout_ratio, hx, None, ws, bs, xs, use_bi_direction)\\n return hy, ys\",\n \"def create_cells(self, N):\\n self.cells = []\\n r = 50 # Radius of cell locations from origin (0,0,0) in microns\\n N = self._N\\n for i in range(N):\\n cell = BallAndStick()\\n # When cells are created, the soma location is at (0,0,0) and\\n # the dendrite extends along the X-axis.\\n # First, at the origin, rotate about Z.\\n cell.rotateZ(i * 2 * pi / N)\\n # Then reposition\\n x_loc = cos(i * 2 * pi / N) * r\\n y_loc = sin(i * 2 * pi / N) * r\\n cell.set_position(x_loc, y_loc, 0)\\n self.cells.append(cell)\",\n \"def __init__(\\n self, channel_count: int, input_height_width: tuple, no_add: bool = False\\n ):\\n super().__init__()\\n\\n self.no_add: bool = no_add\\n\\n self.rm_block_1 = RMBlock(\\n channel_count // 2,\\n channel_count,\\n input_height_width,\\n 1,\\n \\\"weight\\\",\\n 1,\\n )\\n\\n self.rm_block_2 = RMBlock(\\n channel_count // 2,\\n channel_count // 2,\\n input_height_width,\\n 3,\\n \\\"weight\\\",\\n 32,\\n )\\n\\n self.rm_block_3 = RMBlock(\\n channel_count,\\n channel_count // 2,\\n input_height_width,\\n 1,\\n \\\"weight\\\",\\n 1,\\n )\",\n \"def __init__(self,\\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\\n in2hid: tuple, in2out: tuple,\\n hid2hid: tuple, hid2out: tuple,\\n hidden_biases: np.ndarray, output_biases: np.ndarray,\\n rnn_array: np.ndarray, rnn_map: np.ndarray,\\n activation,\\n batch_size: int = 1,\\n initial_read: np.ndarray = None,\\n dtype=np.float64,\\n ):\\n # Storing the input arguments (needed later on)\\n self.act_f = activation\\n self.dtype = dtype\\n self.rnn_idx: np.ndarray = rnn_idx\\n self.n_inputs: int = len(input_idx)\\n self.n_hidden: int = len(hidden_idx)\\n self.n_rnn: int = len(rnn_idx)\\n self.n_outputs: int = len(output_idx)\\n self.bs: int = batch_size\\n \\n # Setup the rnn_map\\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\\n for i, m in enumerate(rnn_map):\\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\\n \\n # Placeholders, initialized during reset\\n self.rnn_state: np.ndarray = None # State of the RNNs\\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\\n self.output_act: np.ndarray = None # Activations of the output nodes\\n \\n # Do not create the hidden-related matrices if hidden-nodes do not exist\\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\\n if self.n_hidden > 0:\\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\\n self.rnn_array: np.ndarray = rnn_array\\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\\n \\n # Fill in the biases\\n if self.n_hidden > 0:\\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\\n \\n # Put network to initial (default) state\\n self.reset(initial_read=initial_read)\",\n \"def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\\n #====================================================================================#\\n # ----------PROBLEM 2----------\\n #====================================================================================#\\n # YOUR CODE HERE\\n # raise NotImplementedError\\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\\n ## step 1 - inputs are first embedded by an MLP\\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\\n # print(\\\"after build_mlp x = \\\", x)\\n ## step 2 - passed to a GRU cell\\n # as \\\"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\\\"hidden\\\", dtype=tf.float32)\\\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\\n # after build_mlp x = Tensor(\\\"continuous_logits/continuous_logits/fc1/BiasAdd:0\\\", shape=(?, 1, 32), dtype=float32)\\n # x = tf.squeeze(x, axis=1)\\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\\n # print(\\\"dynamic_rnn build_mlp x = \\\", x, \\\" h = \\\", h)\\n return x, h\",\n \"def add_model(self, inputs):\\n size = self.config.hidden_size\\n forget_bias = self.config.forget_bias\\n input_cell = self.config.input_cell\\n\\n if input_cell == 'BasicLSTMCell':\\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\\n print 'Using Basic LSTM Cell \\\\n'\\n\\n elif input_cell == 'LSTMCell':\\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\\n print 'Using LSTM Cell \\\\n'\\n\\n elif input_cell == 'GRUCell':\\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\\n print 'Using GRU Cell \\\\n'\\n\\n else:\\n print \\\"Please Specify a Correct Cell Type\\\"\\n\\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\\n input_keep_prob=self.config.dropout)\\n\\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\\n \\n print 'Number of Hidden Layers ', self.config.num_layers\\n \\n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\\n rnn_outputs = []\\n state = self.initial_state\\n\\n with tf.variable_scope('RNNLM') as scope:\\n for time_step in range(self.config.num_steps):\\n if time_step > 0: scope.reuse_variables()\\n (cell_output, state) = cell(inputs[:, time_step, :], state)\\n rnn_outputs.append(cell_output)\\n self.final_state = state\\n\\n return rnn_outputs\",\n \"def __init__(self, cell_index, stimulus_type, conv_layers=[(12, 9, 9), (12, 9, 9)], dense_layer=64,\\n loss='poisson_loss', optimizer='adam', weight_init='normal', l2_reg=0., dropout=0.5, mean_adapt=False):\\n\\n self.stim_shape = (40, 50, 50)\\n\\n # build the model\\n with notify('Building convnet'):\\n\\n self.model = Sequential()\\n\\n # convolutional layers\\n for ix, layer in enumerate(conv_layers):\\n\\n # get parameters for this layer\\n num_filters, row_size, col_size = layer\\n\\n # convolutional layer\\n if ix == 0:\\n self.model.add(Convolution2D(num_filters, row_size, col_size,\\n input_shape=self.stim_shape, init=weight_init,\\n border_mode='same', subsample=(1,1),\\n W_regularizer=l2(l2_reg), activation='relu'))\\n\\n else:\\n self.model.add(Convolution2D(num_filters, row_size, col_size,\\n input_shape=self.stim_shape, init=weight_init,\\n border_mode='same', subsample=(1,1),\\n W_regularizer=l2(l2_reg), activation='relu'))\\n\\n # max pooling layer\\n self.model.add(MaxPooling2D(pool_size=(2, 2), ignore_border=True))\\n\\n # dropout\\n self.model.add(Dropout(dropout))\\n\\n # flatten\\n self.model.add(Flatten())\\n\\n # Add dense (affine) layer with relu activation\\n self.model.add(Dense(dense_layer, init=weight_init, W_regularizer=l2(l2_reg), activation='relu'))\\n self.model.add(Dropout(dropout))\\n\\n # Add a final dense (affine) layer with softplus activation\\n self.model.add(Dense(1, init=weight_init, W_regularizer=l2(l2_reg), activation='softplus'))\\n\\n # save architecture string (for markdown file)\\n self.architecture = '\\\\n'.join(['Convolutional layers {}'.format(conv_layers),\\n '{} filters in the second (fully connected) layer'.format(dense_layer),\\n 'weight initialization: {}'.format(weight_init),\\n 'l2 regularization: {}'.format(l2_reg),\\n 'stimulus shape: {}'.format(self.stim_shape)])\\n\\n # compile\\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)\",\n \"def __init__(self, name=\\\"conv_2d_lstm_cell\\\", **kwargs):\\n super(Conv2DLSTMCell, self).__init__(conv_ndims=2, name=name, **kwargs)\",\n \"def __init__(self, config, input_shp):\\n\\n # Run initialization for super class\\n super(MyNetwork, self).__init__()\\n\\n # Store configuration\\n self.config = config\\n\\n # Placeholder for layers\\n self.layers = {}\\n indim = input_shp[0]\\n\\n # Retrieve Conv, Act, Pool functions from configurations. We'll use\\n # these for our code below.\\n if config.conv2d == \\\"torch\\\":\\n self.Conv2d = nn.Conv2d\\n elif config.conv2d == \\\"custom\\\":\\n self.Conv2d = ConvBlock\\n self.Activation = getattr(nn, config.activation)\\n self.Pool2d = getattr(nn, config.pool2d)\\n self.Linear = nn.Linear\\n\\n # Resnet Blocks, similar to slide 73 of lecture 21. However, for\\n # simplicity, we'll make is slightly different. Note that we used\\n # nn.Sequential this time.\\n self.convs = nn.Sequential()\\n cur_h, cur_w = input_shp[-2:]\\n for _i in range(config.num_conv_outer):\\n #\\n # NOTE THE NEW LAYER ON THESE LINES!\\n #\\n # We have a dedicated 1x1 layer to get more channels. Note also\\n # that this is a pure linear convolution layer.\\n outdim = config.nchannel_base * 2 ** _i\\n self.convs.add_module(\\n \\\"conv_{}_base\\\".format(_i), nn.Conv2d(indim, outdim, 1, 1, 0))\\n indim = outdim\\n for _j in range(config.num_conv_inner):\\n # We now use our selected convolution layer. Note that our\\n # resnet implementation will have a different call style to\\n # vanilla conv2d of torch, so we'll just do an ugly if-else\\n # here.\\n if config.conv2d == \\\"torch\\\":\\n self.convs.add_module(\\n \\\"conv_{}_{}\\\".format(_i, _j),\\n self.Conv2d(indim, outdim, config.ksize, 1, 1))\\n self.convs.add_module(\\n \\\"act_{}_{}\\\".format(_i, _j),\\n self.Activation())\\n cur_h = cur_h - (config.ksize - 1)\\n cur_w = cur_w - (config.ksize - 1)\\n elif config.conv2d == \\\"custom\\\":\\n self.convs.add_module(\\n \\\"conv_{}_{}\\\".format(_i, _j),\\n self.Conv2d(indim, outdim, config.ksize, 1, self.Activation))\\n self.convs.add_module(\\n \\\"conv_{}_pool\\\".format(_i), self.Pool2d(2, 2))\\n cur_h = cur_h // 2\\n cur_w = cur_w // 2\\n\\n # Final output layer. We'll assume that conv layer outputs are global\\n # average pooled\\n self.output = nn.Linear(indim, config.num_class)\\n\\n print(self)\",\n \"def __init__(self,cell1,site1,cell2,site2,color=None,label=None,linewidth=None,linetype=None):\\n self.cell1 = np.array(cell1)\\n self.site1 = site1\\n self.cell2 = np.array(cell2)\\n self.site2 = site2\\n coordinate1 = None\\n coordinate2 = None\\n self.color = color\\n self.label = label\\n self.linewidth = linewidth\\n self.linetype = linetype\",\n \"def __init__(self, num_units, levels, forget_bias=1.0,\\r\\n state_is_tuple=True, activation=None, reuse=None, name=None):\\r\\n super(ON_LSTMCell, self).__init__(_reuse=reuse, name=name)\\r\\n if not state_is_tuple:\\r\\n logging.warn(\\\"%s: Using a concatenated state is slower and will soon be \\\"\\r\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\r\\n\\r\\n # Inputs must be 2-dimensional.\\r\\n self.input_spec = base_layer.InputSpec(ndim=2)\\r\\n\\r\\n self._num_units = num_units\\r\\n self._levels = levels\\r\\n self._chunk_size = num_units // levels\\r\\n self._forget_bias = forget_bias\\r\\n self._state_is_tuple = state_is_tuple\\r\\n self._activation = activation or math_ops.tanh\",\n \"def __init__(self, voc_size, layer_size=512, num_layers=3, embedding_layer_size=256, dropout=0.,\\n controller_type='gru', **kwargs):\\n super(RNN, self).__init__()\\n\\n self._layer_size = layer_size\\n self._embedding_layer_size = embedding_layer_size\\n self._num_layers = num_layers\\n self._dropout = dropout\\n self._controller_type = controller_type\\n\\n self._embedding = tnn.Embedding(voc_size, self._embedding_layer_size)\\n\\n if controller_type == 'gru':\\n self._layer = tnn.GRU(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\\n dropout=self._dropout)\\n elif controller_type == 'lstm':\\n self._layer = tnn.LSTM(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\\n dropout=self._dropout)\\n\\n self._linear = tnn.Linear(self._layer_size, voc_size)\",\n \"def get_rnn_cells(self) -> List[mx.rnn.BaseRNNCell]:\\n return self.forward_rnn.get_rnn_cells() + self.reverse_rnn.get_rnn_cells()\",\n \"def __init__(self, cell):\\n self._cell = cell\\n self._residual_fn = gnmt_residual_fn\",\n \"def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\\n is_training=False, cell_name=\\\"GRU\\\", bidirectional=False, swap_memory=False):\\n batch_size = tf.shape(X)[0]\\n if bidirectional:\\n rnn_size /= 2\\n\\n def get_cell():\\n if cell_name == \\\"GRU\\\": # GRU\\n _cell = rnn_cell.GRUCell(rnn_size)\\n elif cell_name == \\\"LSTM\\\": # LSTM\\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\\n else:\\n raise ValueError(\\\"Unrecognized Cell Name: {0}\\\".format(cell_name))\\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\\n _initial_state = _cell.zero_state(batch_size, tf.float32)\\n return _cell, _initial_state\\n\\n if bidirectional:\\n with tf.variable_scope(\\\"forward\\\"):\\n cell_fw, initial_state_fw = get_cell()\\n with tf.variable_scope(\\\"backward\\\"):\\n cell_bw, initial_state_bw = get_cell()\\n return rnn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, X, sequence_length=seq_len,\\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\\n else:\\n cell, initial_state = get_cell()\\n return rnn.dynamic_rnn(\\n cell, X, sequence_length=seq_len, initial_state=initial_state,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\",\n \"def get_init_cell(batch_size, rnn_size, keep_prob, lstm_layers=2):\\n def build_cell(lstm_size, keep_prob):\\n cell = tf.nn.rnn.BasicLSTMCell(num_units=lstm_size)\\n drop = tf.nn.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob)\\n return drop\\n\\n # 堆栈cell 构建多层隐藏层\\n multi_cell = tf.nn.rnn.MultiRNNCell(\\n [build_cell(rnn_size, keep_prob) for _ in range(lstm_layers)]\\n )\\n\\n # todo 这里使用tf.identity(final_state同)是为了生成一个op操作符，断点继续训练时候要用。\\n initial_state = multi_cell.zero_state(batch_size, tf.float32)\\n initial_state1 = tf.identity(initial_state, name='initial_state')\\n return multi_cell, initial_state, initial_state1\",\n \"def __init__(self, num_nodes, num_features, num_timesteps_input,\\n num_timesteps_output, gcn_type='normal', hidden_size=64, num_comps=10):\\n super(KRNN, self).__init__()\\n self.encoders = nn.ModuleList()\\n self.decoders = nn.ModuleList()\\n self.linears = nn.ModuleList()\\n\\n self.num_timesteps_output = num_timesteps_output\\n\\n for r in range(num_comps):\\n self.encoders.append(\\n nn.GRU(num_features, hidden_size)\\n )\\n self.decoders.append(\\n nn.GRUCell(1, hidden_size)\\n )\\n self.linears.append(\\n nn.Linear(hidden_size, 1)\\n )\\n\\n self.embed = nn.Parameter(torch.FloatTensor(num_nodes, num_comps))\\n self.embed.data.normal_()\",\n \"def test_learnable_cell(self):\\n genotype = '0|0|2|0|0|2|0|0 1|0|0|1|1|0|0|0 0|1|0|0|0|0|2|1--1 7'\\n search_space = {'dil_conv_3x3', 'dil_conv_5x5', 'dil_conv_7x7',\\n 'skip_connect', 'clinc_3x3', 'clinc_7x7', 'avg_pool_3x3', 'max_pool_3x3'}\\n\\n net = LearnableCell(3, genotype, search_space)\\n x = torch.rand((16, 3, 32, 32))\\n y = net(x)\\n self.assertEqual(list(y.shape), [16, 7, 15, 15])\",\n \"def SimpleDeepCell():\\n cell = Cell()\\n node = cell._get_hcell2()\\n node[\\\"celltype\\\"] = \\\"mixed\\\"\\n node[\\\"hash_pattern\\\"] = {\\\"*\\\": \\\"#\\\"}\\n return cell\",\n \"def build_gru_cell(num_units, dropout):\\n cell = tf.nn.rnn_cell.GRUCell(num_units)\\n if dropout:\\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\\n output_keep_prob=1-dropout)\\n return result\",\n \"def _build_bdrnn_graph(self, hparams):\\n\\n sample = self.iterator.get_next()\\n\\n inputs, tgt_outputs, seq_len = sample\\n\\n # linear projection to state size\\n #with tf.variable_scope(\\\"bdrnn_in\\\", dtype=tf.float32):\\n # inputs = tf.layers.dense(inputs=inputs,\\n # units=hparams.input_proj_size,\\n # kernel_initializer=tf.glorot_uniform_initializer())\\n\\n lm_fw_cell = []\\n lm_bw_cell = []\\n lm_init_state_fw = []\\n lm_init_state_bw = []\\n if hparams.pretrained:\\n with tf.variable_scope(\\\"lm_rnn\\\", dtype=tf.float32):\\n # create lm\\n with tf.variable_scope(\\\"fw\\\", dtype=tf.float32):\\n lm_fw_cell = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=1,\\n mode=self.mode)\\n # build the cell so it is in the correct scope\\n # NOTE: this is hard coded\\n lm_fw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\\n lm_init_state_fw = _get_initial_state([lm_fw_cell[0].state_size], tf.shape(inputs)[0], \\\"lm\\\")\\n with tf.variable_scope(\\\"bw\\\", dtype=tf.float32):\\n lm_bw_cell = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=1,\\n mode=self.mode)\\n # NOTE: this is hard coded\\n lm_bw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\\n lm_init_state_bw = _get_initial_state([lm_bw_cell[0].state_size], tf.shape(inputs)[0], \\\"lm\\\")\\n\\n lm_outputs, lm_states = tf.nn.bidirectional_dynamic_rnn(lm_fw_cell[0],\\n lm_bw_cell[0],\\n inputs,\\n sequence_length=seq_len,\\n initial_state_fw=lm_init_state_fw[0],\\n initial_state_bw=lm_init_state_bw[0],\\n dtype=tf.float32)\\n # optionally fix the LM weights\\n if hparams.fixed_lm:\\n print(\\\"Fixing pretrained language models.\\\")\\n lm_outputs = tf.stop_gradient(lm_outputs)\\n lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1]], axis=-1)\\n lm_outputs = tf.layers.dense(lm_outputs,\\n 20,\\n kernel_initializer=tf.glorot_uniform_initializer())\\n lm_outputs = tf.concat([lm_outputs, inputs], axis=-1)\\n\\n\\n #lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1], inputs], axis=-1)\\n else:\\n lm_outputs = tf.concat(lm_outputs, axis=-1)\\n\\n\\n\\n with tf.variable_scope(\\\"bdrnn\\\", dtype=tf.float32) as bdrnn_scope:\\n # create bdrnn\\n with tf.variable_scope(\\\"fw\\\", dtype=tf.float32):\\n fw_cells = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=hparams.num_layers,\\n mode=self.mode\\n )\\n init_state_fw = _get_initial_state([cell.state_size for cell in fw_cells],\\n tf.shape(inputs)[0], \\\"initial_state_fw\\\")\\n\\n with tf.variable_scope(\\\"bw\\\", dtype=tf.float32):\\n bw_cells = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=hparams.num_layers,\\n mode=self.mode,\\n )\\n\\n init_state_bw = _get_initial_state([cell.state_size for cell in bw_cells],\\n tf.shape(inputs)[0], \\\"initial_state_bw\\\")\\n # NOTE: this is commented because the lm cells and states are separated now\\n #fw_cells = lm_fw_cell + fw_cells\\n #bw_cells = lm_bw_cell + bw_cells\\n #init_state_fw = lm_init_state_fw + init_state_fw\\n #init_state_bw = lm_init_state_bw + init_state_bw\\n\\n # run bdrnn\\n combined_outputs, output_state_fw, output_state_bw = \\\\\\n tf.contrib.rnn.stack_bidirectional_dynamic_rnn(cells_fw=fw_cells,\\n cells_bw=bw_cells,\\n inputs=lm_outputs,\\n sequence_length=seq_len,\\n initial_states_fw=init_state_fw,\\n initial_states_bw=init_state_bw,\\n dtype=tf.float32,\\n scope=bdrnn_scope)\\n # outputs is a tuple (output_fw, output_bw)\\n # output_fw/output_bw are tensors [batch_size, max_time, cell.output_size]\\n # outputs_states is a tuple (output_state_fw, output_state_bw) containing final states for\\n # forward and backward rnn\\n\\n # concatenate the outputs of each direction\\n #combined_outputs = tf.concat([outputs[0], outputs[1]], axis=-1)\\n\\n with tf.variable_scope(\\\"bdrnn_out\\\", dtype=tf.float32):\\n # dense output layers\\n dense1 = tf.layers.dense(inputs=combined_outputs,\\n units=hparams.num_dense_units,\\n kernel_initializer=tf.glorot_uniform_initializer(),\\n activation=tf.nn.relu,\\n use_bias=True)\\n drop1 = tf.layers.dropout(inputs=dense1,\\n rate=hparams.dropout,\\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\\n dense2 = tf.layers.dense(inputs=drop1,\\n units=hparams.num_dense_units,\\n kernel_initializer=tf.glorot_uniform_initializer(),\\n activation=tf.nn.relu,\\n use_bias=True)\\n drop2 = tf.layers.dropout(inputs=dense2,\\n rate=hparams.dropout,\\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\\n\\n logits = tf.layers.dense(inputs=drop2,\\n units=hparams.num_labels,\\n use_bias=False)\\n\\n # mask out entries longer than target sequence length\\n mask = tf.sequence_mask(seq_len, dtype=tf.float32)\\n\\n crossent = tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,\\n labels=tgt_outputs,\\n name=\\\"crossent\\\")\\n\\n # divide loss by batch_size * mean(seq_len)\\n loss = tf.reduce_sum(crossent*mask)/tf.cast(hparams.batch_size, tf.float32)\\n\\n metrics = []\\n update_ops = []\\n if self.mode == tf.contrib.learn.ModeKeys.EVAL:\\n # mean eval loss\\n loss, loss_update = tf.metrics.mean(values=loss)\\n\\n predictions = tf.argmax(input=logits, axis=-1)\\n tgt_labels = tf.argmax(input=tgt_outputs, axis=-1)\\n acc, acc_update = tf.metrics.accuracy(predictions=predictions,\\n labels=tgt_labels,\\n weights=mask)\\n # confusion matrix\\n targets_flat = tf.reshape(tgt_labels, [-1])\\n predictions_flat = tf.reshape(predictions, [-1])\\n mask_flat = tf.reshape(mask, [-1])\\n cm, cm_update = streaming_confusion_matrix(labels=targets_flat,\\n predictions=predictions_flat,\\n num_classes=hparams.num_labels,\\n weights=mask_flat)\\n tf.add_to_collection(\\\"eval\\\", cm_summary(cm, hparams.num_labels))\\n metrics = [acc, cm]\\n update_ops = [loss_update, acc_update, cm_update]\\n\\n return logits, loss, metrics, update_ops\",\n \"def __init__(self, sys, rcut, pad):\\n self.sys = sys \\n self.rcut = rcut \\n self.pad = pad\\n self.cell_list = CellList(self.sys.box, self.rcut + self.pad)\",\n \"def __init__(self,\\n cell_type: Text = \\\"lstm\\\",\\n tiers: Dict[int:List[int]] = {1:[1]},\\n window_sizes: List[int] = [1],\\n strides: List[int] = [1],\\n use_dense_layer_output : bool = False,\\n dense_layer_args : Dict = {\\\"units\\\": None,\\n \\\"activation\\\":None,#don't change this\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"kernel_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"activity_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n },\\n lstm_cell_args : Dict = {\\\"activation\\\":'tanh',\\n \\\"recurrent_activation\\\":'hard_sigmoid',\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"recurrent_initializer\\\":'orthogonal',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"unit_forget_bias\\\":True,\\n \\\"kernel_regularizer\\\":None,\\n \\\"recurrent_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"recurrent_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n \\\"implementation\\\":1,\\n },\\n gru_cell_args : Dict = {\\\"activation\\\":'tanh',\\n \\\"recurrent_activation\\\":'hard_sigmoid',\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"recurrent_initializer\\\":'orthogonal',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"kernel_regularizer\\\":None,\\n \\\"recurrent_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"recurrent_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n \\\"implementation\\\":1,\\n \\\"reset_after\\\":False,\\n },\\n adam_opt_args : Dict = {\\\"learning_rate\\\": None,\\n \\\"epsilon\\\": None,\\n \\\"beta_1\\\": None,\\n \\\"beta_2\\\": None,\\n },\\n clip_norm : Optional[float] = None,\\n dropout_training = 0,\\n recurrent_dropout_training = 0,\\n tens_to_log = None,\\n checkpoint_path = None,\\n predict_batch_size = 30,\\n save_checkpoints_steps = 100,\\n keep_checkpoint_max = 10,\\n save_summary_steps = 10,\\n logging_step = 10,\\n ):\\n \\n if (len(tiers)!=len(window_sizes) or len(window_sizes)!=len(strides)):\\n raise ValueError(\\\"Mismatch in network geometry specs. Need number of\\\"\\n \\\" tiers = number of window size specs, or number of\\\"\\n \\\" window specs = number of stride specs.\\\")\\n \\n \\n self.cell_type = cell_type \\n self.tiers = tiers, \\n self.window_sizes = window_sizes,\\n self.strides = strides,\\n self.use_dense_layer_output = use_dense_layer_output\\n self.dense_layer_args = dense_layer_args,\\n self.lstm_cell_args = lstm_cell_args,\\n self.gru_cell_args = gru_cell_args,\\n self.adam_opt_args = adam_opt_args,\\n self.clip_norm = clip_norm,\\n self.dropout_training = 0,\\n self.recurrent_dropout_training = recurrent_dropout_training,\\n self.tens_to_log = tens_to_log,\\n self.checkpoint_path = None,\\n self.predict_batch_size = 30,\\n self.save_checkpoints_steps = 100,\\n self.keep_checkpoint_max = 10,\\n self.save_summary_steps = 20,\\n self.logging_step = 10\",\n \"def build_nn_model(height, width, num_channels, num_res_blocks):\\n input_network = Input(shape=(height, width, 1))\\n tensor = Conv2D(num_channels, (3, 3), padding='same')(input_network)\\n tensor = Activation('relu')(tensor)\\n for _ in range(num_res_blocks):\\n tensor = resblock(tensor, num_channels)\\n tensor = Conv2D(1, (3, 3), padding='same')(tensor)\\n tensor = Add()([tensor, input_network])\\n model = Model(inputs=input_network, outputs=tensor)\\n return model\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71335816","0.6953759","0.6925032","0.6800048","0.6565086","0.65646267","0.637898","0.6358356","0.6312413","0.62985456","0.629002","0.6288718","0.62280524","0.61890537","0.6145752","0.612748","0.6081028","0.60306144","0.6012887","0.5991209","0.59855443","0.5976973","0.5976567","0.5926054","0.59158695","0.5912674","0.5909625","0.5880559","0.586689","0.58545476","0.58398384","0.5833907","0.5832688","0.5827593","0.5825152","0.58201474","0.5807638","0.5779451","0.57727915","0.57687336","0.5753339","0.57336617","0.573202","0.5710577","0.5696505","0.5687429","0.5651093","0.5646016","0.5645977","0.56262434","0.5593324","0.55825114","0.5581316","0.55780977","0.55729055","0.55722076","0.5547882","0.55469763","0.54980177","0.5493477","0.54885197","0.54826","0.54547745","0.545268","0.544694","0.54307437","0.5422569","0.5420577","0.54172933","0.540799","0.5386754","0.53860074","0.5385738","0.5366739","0.53610885","0.5357189","0.5341775","0.5335187","0.5325059","0.53246915","0.5318758","0.5318467","0.53108305","0.52984655","0.52892375","0.52863884","0.5285091","0.52804196","0.52774066","0.5271098","0.5263409","0.5249389","0.52468777","0.5233789","0.52289647","0.5225242","0.5224347","0.5223053","0.5219627","0.51953286"],"string":"[\n \"0.71335816\",\n \"0.6953759\",\n \"0.6925032\",\n \"0.6800048\",\n \"0.6565086\",\n \"0.65646267\",\n \"0.637898\",\n \"0.6358356\",\n \"0.6312413\",\n \"0.62985456\",\n \"0.629002\",\n \"0.6288718\",\n \"0.62280524\",\n \"0.61890537\",\n \"0.6145752\",\n \"0.612748\",\n \"0.6081028\",\n \"0.60306144\",\n \"0.6012887\",\n \"0.5991209\",\n \"0.59855443\",\n \"0.5976973\",\n \"0.5976567\",\n \"0.5926054\",\n \"0.59158695\",\n \"0.5912674\",\n \"0.5909625\",\n \"0.5880559\",\n \"0.586689\",\n \"0.58545476\",\n \"0.58398384\",\n \"0.5833907\",\n \"0.5832688\",\n \"0.5827593\",\n \"0.5825152\",\n \"0.58201474\",\n \"0.5807638\",\n \"0.5779451\",\n \"0.57727915\",\n \"0.57687336\",\n \"0.5753339\",\n \"0.57336617\",\n \"0.573202\",\n \"0.5710577\",\n \"0.5696505\",\n \"0.5687429\",\n \"0.5651093\",\n \"0.5646016\",\n \"0.5645977\",\n \"0.56262434\",\n \"0.5593324\",\n \"0.55825114\",\n \"0.5581316\",\n \"0.55780977\",\n \"0.55729055\",\n \"0.55722076\",\n \"0.5547882\",\n \"0.55469763\",\n \"0.54980177\",\n \"0.5493477\",\n \"0.54885197\",\n \"0.54826\",\n \"0.54547745\",\n \"0.545268\",\n \"0.544694\",\n \"0.54307437\",\n \"0.5422569\",\n \"0.5420577\",\n \"0.54172933\",\n \"0.540799\",\n \"0.5386754\",\n \"0.53860074\",\n \"0.5385738\",\n \"0.5366739\",\n \"0.53610885\",\n \"0.5357189\",\n \"0.5341775\",\n \"0.5335187\",\n \"0.5325059\",\n \"0.53246915\",\n \"0.5318758\",\n \"0.5318467\",\n \"0.53108305\",\n \"0.52984655\",\n \"0.52892375\",\n \"0.52863884\",\n \"0.5285091\",\n \"0.52804196\",\n \"0.52774066\",\n \"0.5271098\",\n \"0.5263409\",\n \"0.5249389\",\n \"0.52468777\",\n \"0.5233789\",\n \"0.52289647\",\n \"0.5225242\",\n \"0.5224347\",\n \"0.5223053\",\n \"0.5219627\",\n \"0.51953286\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6650443"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":88990,"cells":{"query":{"kind":"string","value":"Construct a basic RNN cell. It is configured to be passed to a multi rnn cell wrapper."},"document":{"kind":"string","value":"def build_lstm_cell(num_units, dropout):\n cell = tf.nn.rnn_cell.LSTMCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result"},"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 create_rnn_cell(num_units,\n num_layers,\n num_residual_layers,\n dropout,\n mode,\n num_gpus,\n base_gpu=0,\n single_cell_fn=None,\n all_layer_outputs=False):\n cell_list = _cell_list(\n num_units=num_units,\n num_layers=num_layers,\n num_residual_layers=num_residual_layers,\n dropout=dropout,\n mode=mode,\n num_gpus=num_gpus,\n base_gpu=base_gpu,\n single_cell_fn=single_cell_fn)\n\n if len(cell_list) == 1: # Single layer.\n return cell_list[0]\n else: # Multi layers\n print(all_layer_outputs, \"all_layer_outputs\")\n\n if all_layer_outputs:\n return MultiRNNCell(cell_list)\n else:\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)","def build_multi_rnn(cells):\n return tf.nn.rnn_cell.MultiRNNCell(cells)","def __init__(self, rnn_cell, batch_size,\n input_size, num_outputs):\n super().__init__(name='RNNCellStateModel')\n self._rnn_cell = rnn_cell\n self._batch_size = batch_size\n self._input_size = input_size\n self._num_outputs = num_outputs","def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\n if is_train:\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\n return cell","def build_rnn_cell(type, num_units, dropout):\n cell = tf.nn.rnn_cell.BasicRNNCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result","def MakeFancyRNNCell(H, keep_prob, num_layers=1):\n cells = []\n for _ in range(num_layers):\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cells.append(cell)\n return tf.nn.rnn_cell.MultiRNNCell(cells)","def _create_rnn_cells(self, is_list=False):\n\n stacked_rnn = []\n for _ in range(self.num_layers):\n single_cell = self._rnn_single_cell()\n stacked_rnn.append(single_cell)\n\n if is_list:\n return stacked_rnn\n else:\n return tf.nn.rnn_cell.MultiRNNCell(\n cells=stacked_rnn,\n state_is_tuple=True)","def __call__(self, inputs, state, scope=None, *args, **kwargs):\r\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\r\n # Instead, it is up to subclasses to provide a proper build\r\n # method. See the class docstring for more details.\r\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\r\n *args, **kwargs)","def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\n if layer_type == \"layernorm_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\n else:\n if layer_type == \"lstm\":\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\n elif layer_type == \"gru\":\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_gru\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\n else:\n raise ValueError(\"Error: not supported rnn type:{}\".format(layer_type))\n\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, output_keep_prob=dropout_keep_prob)\n return cell","def build_rnn(cell, inputs):\n #_,initial_state = get_init_cell(batch_size, rnn_size)\n \n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name='final_state')\n\n return (output, final_state)","def __init__(self,\n num_units,\n num_dims=1,\n input_dims=None,\n output_dims=None,\n priority_dims=None,\n non_recurrent_dims=None,\n tied=False,\n cell_fn=None,\n non_recurrent_fn=None,\n state_is_tuple=True,\n output_is_tuple=True):\n if not state_is_tuple:\n logging.warning('%s: Using a concatenated state is slower and will '\n 'soon be deprecated. Use state_is_tuple=True.', self)\n if not output_is_tuple:\n logging.warning('%s: Using a concatenated output is slower and will '\n 'soon be deprecated. Use output_is_tuple=True.', self)\n\n if num_dims < 1:\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\n\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\n priority_dims, non_recurrent_dims,\n non_recurrent_fn or nn.relu, tied,\n num_units)\n\n self._state_is_tuple = state_is_tuple\n self._output_is_tuple = output_is_tuple\n\n if cell_fn is None:\n my_cell_fn = functools.partial(\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\n else:\n my_cell_fn = lambda: cell_fn(num_units)\n if tied:\n self._cells = [my_cell_fn()] * num_dims\n else:\n self._cells = [my_cell_fn() for _ in range(num_dims)]\n if not isinstance(self._cells[0], rnn.RNNCell):\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\n type(self._cells[0]))\n\n if self._output_is_tuple:\n self._output_size = tuple(self._cells[0].output_size\n for _ in self._config.outputs)\n else:\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\n\n if self._state_is_tuple:\n self._state_size = tuple(self._cells[0].state_size\n for _ in self._config.recurrents)\n else:\n self._state_size = self._cell_state_size() * len(self._config.recurrents)","def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\n readout_init, readout_apply = stax.Dense(num_outputs)\n\n def init_fun(key, input_shape):\n \"\"\"Initialize the components of the RNN.\n\n Args:\n key: Jax PRNGkey used to initialize the parameters.\n input_shape: tuple representing the input shape, should be\n (batch_size, sequence_length).\n\n Returns:\n shapes: set of tuples representing the shapes after applying\n the Embedding, RNN Cell, and Readout layers.\n network_params: tuple of network parameters, containing the\n embedding, RNN cell, and readout parameters.\n \"\"\"\n\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\n\n # Initialize the Embedding for the input tokens.\n emb_shape, emb_params = emb_init(emb_key, input_shape)\n\n # The cell is defined for a single update step, which is why we ignore\n # the sequence dimension (emb_shape[1]) here.\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\n\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\n\n shapes = (emb_shape, rnn_shape, output_shape)\n network_params = (emb_params, rnn_params, readout_params)\n\n return shapes, network_params\n\n def apply_fun(network_params, tokens):\n \"\"\"Applies the RNN on a batch of input sequences.\n\n Args:\n network_params: tuple of network parameters (see init_fun).\n tokens: batch of inputs, with shape (batch_size, sequence_length).\n\n Returns:\n outputs: network outputs, at every step along the sequence.\n \"\"\"\n emb_params, rnn_params, readout_params = network_params\n\n # Apply the embedding.\n inputs = emb_apply(emb_params, tokens)\n\n # Run the RNN.\n initial_states = cell.get_initial_state(rnn_params,\n batch_size=tokens.shape[0])\n return unroll.unroll_rnn(initial_states, inputs,\n functools.partial(cell.batch_apply, rnn_params),\n functools.partial(readout_apply, readout_params))\n\n return init_fun, apply_fun, emb_apply, readout_apply","def make_cell(self, unit_type, num_units, forget_bias, dropout,\n mode, residual_connection=False):\n\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\n dropout = dropout if mode == tf.contrib.learn.ModeKeys.TRAIN else 0.0\n\n # Cell Type\n if unit_type == \"lstm\":\n cell = tf.contrib.rnn.BasicLSTMCell(\n num_units,\n forget_bias=forget_bias)\n elif unit_type == \"gru\":\n cell = tf.contrib.rnn.GRUCell(num_units)\n elif unit_type == \"layer_norm_lstm\":\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units,\n forget_bias=forget_bias,\n layer_norm=True)\n else:\n raise ValueError(\"Unknown unit type %s!\" % unit_type)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n cell = tf.contrib.rnn.DropoutWrapper(\n cell=cell, input_keep_prob=(1.0 - dropout))\n\n # Residual\n if residual_connection:\n cell = tf.contrib.rnn.ResidualWrapper(cell)\n\n return cell","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(RCRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = ResidualCNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=2,\n )\n #self.rnn2 = BidirectionalGRU(\n # n_in=nb_in*2,\n # n_hidden=n_RNN_cell,\n # dropout=dropout_recurrent,\n # num_layers=1,\n #)\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.relu = nn.ReLU()\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def _create_rnn_cell(num_units, num_layers, mode):\n\n cell_list = []\n for i in range(num_layers):\n single_cell = STLSTMCell(name=\"stlstm\",\n num_units=num_units,\n st_activation=tf.nn.relu,\n st_kernel_initializer=tf.glorot_uniform_initializer(),\n st_num_layers=2,\n st_residual=True)\n cell_list.append(single_cell)\n\n return cell_list","def constructCell():\n\t\tself.weightGenerate()","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(CRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = CNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=n_layers_RNN,\n )\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def __init__(self, cell, attn_inputs, \n attn_size, attn_vec_size,\n output_size=None, input_size=None, \n state_is_tuple=True, attn_masks=None,\n merge_output_attn='linear',\n reuse=None):\n if not isinstance(cell, rnn.RNNCell):\n raise TypeError(\"The parameter cell is not RNNCell.\")\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\n raise ValueError(\"Cell returns tuple of states, but the flag \"\n \"state_is_tuple is not set. State size is: %s\"\n % str(cell.state_size))\n if not state_is_tuple:\n logging.warn(\n \"%s: Using a concatenated state is slower and will soon be \"\n \"deprecated. Use state_is_tuple=True.\", self)\n\n self._state_is_tuple = state_is_tuple\n\n if not state_is_tuple:\n raise NotImplementedError\n\n self._cell = cell\n self._input_size = input_size\n self._output_size = output_size\n if output_size is None:\n self._output_size = cell.output_size\n self._attn_size = attn_size\n self._reuse = reuse\n self._attn_inputs = attn_inputs\n self._attn_vec_size = attn_vec_size\n self.attn_masks = attn_masks\n self.merge_output_attn = merge_output_attn","def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\n cells = []\n for layer_size in rnn_cell_size:\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\n if attn_len and not cells:\n # Add attention wrapper to first layer.\n cell = tf.contrib.rnn.AttentionCellWrapper(\n cell, attn_len, state_is_tuple=True)\n cell = tf.contrib.rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return tf.contrib.rnn.MultiRNNCell(cells)","def __init__(self, input_size, hidden_size, output_size, model=\"gru\", n_layers=1):\n \n super(CharRNN, self).__init__()\n\n self.input_size = input_size\n self.hidden_size = hidden_size\n self.output_size = output_size\n self.n_layers = n_layers\n\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\n \n self.model = model\n if model.lower() == \"lstm\":\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\n else: # model is GRU\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\n\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer","def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\n is_batch_norm, is_bidirectional):\n if is_batch_norm:\n input_data = tf.keras.layers.BatchNormalization(\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\n rnn_layer = rnn_cell(\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\n name=\"rnn_{}\".format(layer_id))\n if is_bidirectional:\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\"sum\")\n\n return rnn_layer(input_data)","def build_rnn(cell, inputs):\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name=\"final_state\")\n\n return outputs, final_state","def get_init_cell(batch_size, rnn_size):\n\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\n num_of_layers = 3\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name='initial_state')\n \n return (cell, initial_state)","def _initialize_gru_cell(self, num_units):\n return gru_cell.LayerNormGRUCell(\n num_units,\n w_initializer=self.uniform_initializer,\n u_initializer=random_orthonormal_initializer,\n b_initializer=tf.constant_initializer(0.0))","def custom_rnn(cell, inputs, initial_state=None, dtype=None,\r\n sequence_length=None, scope=None):\r\n\r\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\r\n raise TypeError(\"cell must be an instance of RNNCell\")\r\n if not nest.is_sequence(inputs):\r\n raise TypeError(\"inputs must be a sequence\")\r\n if not inputs:\r\n raise ValueError(\"inputs must not be empty\")\r\n\r\n outputs = []\r\n states = []\r\n # Create a new scope in which the caching device is either\r\n # determined by the parent scope, or is set to place the cached\r\n # Variable using the same placement as for the rest of the RNN.\r\n with vs.variable_scope(scope or \"RNN\") as varscope:\r\n if varscope.caching_device is None:\r\n varscope.set_caching_device(lambda op: op.device)\r\n\r\n # Obtain the first sequence of the input\r\n first_input = inputs\r\n while nest.is_sequence(first_input):\r\n first_input = first_input[0]\r\n\r\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\r\n # TODO(lukaszkaiser): remove EmbeddingWrapper\r\n if first_input.get_shape().ndims != 1:\r\n\r\n input_shape = first_input.get_shape().with_rank_at_least(2)\r\n fixed_batch_size = input_shape[0]\r\n\r\n flat_inputs = nest.flatten(inputs)\r\n for flat_input in flat_inputs:\r\n input_shape = flat_input.get_shape().with_rank_at_least(2)\r\n batch_size, input_size = input_shape[0], input_shape[1:]\r\n fixed_batch_size.merge_with(batch_size)\r\n for i, size in enumerate(input_size):\r\n if size.value is None:\r\n raise ValueError(\r\n \"Input size (dimension %d of inputs) must be accessible via \"\r\n \"shape inference, but saw value None.\" % i)\r\n else:\r\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\r\n\r\n if fixed_batch_size.value:\r\n batch_size = fixed_batch_size.value\r\n else:\r\n batch_size = array_ops.shape(first_input)[0]\r\n if initial_state is not None:\r\n state = initial_state\r\n else:\r\n if not dtype:\r\n raise ValueError(\"If no initial_state is provided, \"\r\n \"dtype must be specified\")\r\n state = cell.zero_state(batch_size, dtype)\r\n\r\n if sequence_length is not None: # Prepare variables\r\n sequence_length = ops.convert_to_tensor(\r\n sequence_length, name=\"sequence_length\")\r\n if sequence_length.get_shape().ndims not in (None, 1):\r\n raise ValueError(\r\n \"sequence_length must be a vector of length batch_size\")\r\n def _create_zero_output(output_size):\r\n # convert int to TensorShape if necessary\r\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\r\n output = array_ops.zeros(\r\n array_ops.pack(size), _infer_state_dtype(dtype, state))\r\n shape = _state_size_with_prefix(\r\n output_size, prefix=[fixed_batch_size.value])\r\n output.set_shape(tensor_shape.TensorShape(shape))\r\n return output\r\n\r\n output_size = cell.output_size\r\n flat_output_size = nest.flatten(output_size)\r\n flat_zero_output = tuple(\r\n _create_zero_output(size) for size in flat_output_size)\r\n zero_output = nest.pack_sequence_as(structure=output_size,\r\n flat_sequence=flat_zero_output)\r\n\r\n sequence_length = math_ops.to_int32(sequence_length)\r\n min_sequence_length = math_ops.reduce_min(sequence_length)\r\n max_sequence_length = math_ops.reduce_max(sequence_length)\r\n\r\n for time, input_ in enumerate(inputs):\r\n if time > 0: varscope.reuse_variables()\r\n # pylint: disable=cell-var-from-loop\r\n call_cell = lambda: cell(input_, state)\r\n # pylint: enable=cell-var-from-loop\r\n if sequence_length is not None:\r\n (output, state) = _rnn_step(\r\n time=time,\r\n sequence_length=sequence_length,\r\n min_sequence_length=min_sequence_length,\r\n max_sequence_length=max_sequence_length,\r\n zero_output=zero_output,\r\n state=state,\r\n call_cell=call_cell,\r\n state_size=cell.state_size)\r\n else:\r\n (output, state) = call_cell()\r\n\r\n outputs.append(output)\r\n states.append(state)\r\n\r\n return (outputs, state, states)","def __init__(self, context, problem, update_rate=1, debug=False):\n tf.keras.layers.AbstractRNNCell.__init__(self)\n self.context = context\n self.problem = problem\n\n if hasattr(self.context, 'scale'):\n self.scale = self.context.scale\n else:\n self.scale = 1\n\n self.debug = debug\n\n # shape related information\n self.batch_size = self.context.batch_size\n self.dim_x = self.context.dim_x\n self.dim_z = self.context.dim_z\n self.dim_u = self.context.dim_u\n\n # rate at which observations are taken into account\n self.update_rate = tf.ones([], dtype=tf.float32) * update_rate\n\n self.filter_layers = []","def _single_cell(num_units,\n dropout,\n mode,\n residual_connection=False,\n device_str=None):\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\n\n # Cell Type\n utils.print_out(\" GRU\", new_line=False)\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n utils.print_out(\n \" %s, dropout=%g \" % (type(single_cell).__name__, dropout),\n new_line=False)\n\n # Residual\n if residual_connection:\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\n utils.print_out(\" %s\" % type(single_cell).__name__, new_line=False)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\n utils.print_out(\n \" %s, device=%s\" % (type(single_cell).__name__, device_str),\n new_line=False)\n\n return single_cell","def resnet10(shortcut_type, num_classes, in_channels):\n model = ResNet(BasicBlock, [1, 1, 1, 1], shortcut_type, num_classes, in_channels)\n return model","def create_model():\n\n class Net(nn.Cell):\n def construct(self, x, y):\n return x\n\n net = Net()\n model_simple = Model(net)\n\n return model_simple","def __init__(self, cell_index, stimulus_type, loss='poisson_loss', optimizer='sgd',\n weight_init='glorot_normal', l2_reg=0., mean_adapt=False):\n\n self.stim_shape = (40, 50, 50)\n\n # build the model (flatten the input, followed by a dense layer and\n # softplus activation)\n with notify('Building LN model'):\n self.model = Sequential()\n self.model.add(Flatten(input_shape=self.stim_shape))\n self.model.add(Dense(1, activation='softplus', init=weight_init,\n W_regularizer=l2(l2_reg)))\n\n # save architecture string (for markdown file)\n self.architecture = '\\n'.join(['l2 regularization: {}'.format(l2_reg),\n 'stimulus shape: {}'.format(self.stim_shape),\n 'weight initialization: {}'.format(weight_init)])\n\n # compile\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embedding = get_embed(input_data, vocab_size, rnn_size)\n outputs, final_state = build_rnn(cell, embedding)\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\n\n return logits, final_state","def rnn_cell(hprev, zt, name=None, reuse=False):\n nin = zt.shape[-1].value\n nout = hprev.shape[-1].value\n with tf.variable_scope(name, default_name=\"rnn\", values=[hprev, zt], reuse=reuse):\n wz = get_variable_wrap(\"kernel/input\", [nin, nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n wh = get_variable_wrap(\"kernel/hidden\", [nout, nout],dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n bh = get_variable_wrap(\"bias\", [nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n \n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)","def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\n cells = []\n for layer_size in rnn_cell_size:\n cell = rnn.LSTMBlockCell(layer_size)\n cell = rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return rnn.MultiRNNCell(cells)","def get_init_cell(batch_size, rnn_size):\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name=\"initial_state\")\n\n return cell, initial_state","def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\n # todo 1、获取嵌入层的输出\n embed = get_embed(input_data, vocab_size, embed_dim)\n # todo-2、获取 隐藏层的输出\n rnn_outputs, final_state, final_state1 = build_rnn(\n cell, embed, initial_state=initial_state)\n # 3、构建全连接，获取logits\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\n # [N, n-steps, num_classes]\n return logits, final_state, final_state1","def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\n residual_connection=False, device_str=None):\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\n dropout = dropout if mode == \"train\" else 0.0\n # Cell Type\n if unit_type == \"lstm\":\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\n\n elif unit_type == \"gru\":\n single_cell = tf.contrib.rnn.GRUCell(num_units)\n\n elif unit_type == \"layer_norm_lstm\":\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units,layer_norm=True)\n else:\n raise ValueError(\"Unknown unit type %s!\" % unit_type)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.contrib.rnn.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n\n # Residual\n if residual_connection:\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\n\n return single_cell","def __init__(self, layers, rnnType, seqLength=128, outputDim=None, activation=None, dropout=0.0):\n model = utils.buildRNN(layers, rnnType, dropout)\n super().__init__(torch.nn.Sequential(model), nnType='rnn')\n \n self.seqLength = seqLength\n if outputDim is not None:\n self.update(DNN([layers[-1]*seqLength, outputDim], [activation]).model)\n self.nnType = 'rnn-mlp'","def __init__(self,\n shape,\n kernel,\n depth,\n use_peepholes=False,\n cell_clip=None,\n initializer=None,\n forget_bias=1.0,\n activation=None,\n normalize=None,\n dropout=None,\n reuse=None):\n super(ConvLSTMCell, self).__init__(_reuse=reuse)\n\n tf_shape = tf.TensorShape(shape + [depth])\n self._output_size = tf_shape\n self._state_size = tf.nn.rnn_cell.LSTMStateTuple(tf_shape, tf_shape)\n\n self._kernel = kernel\n self._depth = depth\n self._use_peepholes = use_peepholes\n self._cell_clip = cell_clip\n self._initializer = initializer\n self._forget_bias = forget_bias\n self._activation = activation or tf.nn.tanh\n self._normalize = normalize\n self._dropout = dropout\n\n self._w_conv = None\n if self._use_peepholes:\n self._w_f_diag = None\n self._w_i_diag = None\n self._w_o_diag = None","def __init__(self, num_units,\n use_peepholes=False, cell_clip=None,\n initializer=None, num_proj=None, proj_clip=None,\n num_unit_shards=None, num_proj_shards=None,\n forget_bias=1.0, state_is_tuple=False,\n activation=None, trainable=None, name=None, dtype=None, residual_connection=False, **kwargs):\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n if not state_is_tuple:\n logging.warn(\"%s: Using a concatenated state is slower and will soon be \"\n \"deprecated. Use state_is_tuple=True.\", self)\n if num_unit_shards is not None or num_proj_shards is not None:\n logging.warn(\n \"%s: The num_unit_shards and proj_unit_shards parameters are \"\n \"depreca ted and will be removed in Jan 2017. \"\n \"Use a variable scope with a partitioner instead.\", self)\n if context.executing_eagerly() and context.num_gpus() > 0:\n logging.warn(\"%s: Note that this cell is not optimized for performance. \"\n \"Please use tf.contrib.cudnn_rnn.CudnnLSTM for better \"\n \"performance on GPU.\", self)\n self._num_units = num_units\n self._use_peepholes = use_peepholes\n self._cell_clip = cell_clip\n self._initializer = initializers.get(initializer)\n self._num_proj = num_proj\n self._proj_clip = proj_clip\n self._num_unit_shards = num_unit_shards\n self._num_proj_shards = num_proj_shards\n self._forget_bias = forget_bias\n self._state_is_tuple = state_is_tuple\n self.residual_connection = residual_connection\n self._kernel = None\n self._bias = None\n self._w_f_diag = None\n self._w_i_diag = None\n self._w_o_diag = None\n self._proj_kernel = None\n if activation:\n self._activation = activations.get(activation)\n else:\n self._activation = math_ops.tanh\n\n if num_proj:\n self.state_size = [num_proj, num_units]\n self._output_size = num_proj\n\n else:\n self._state_size = [num_units, num_units]\n self._output_size = num_units","def __init__(self, num_nodes, h_dim, out_dim, num_rels,\n num_bases=-1, num_hidden_layers=1, dropout=0.5, bias=False):\n super(RGCN, self).__init__()\n self.num_nodes = num_nodes\n self.h_dim = h_dim\n self.out_dim = out_dim\n self.num_rels = num_rels\n self.num_bases = num_bases\n self.num_hidden_layers = num_hidden_layers\n self.dropout = dropout\n self.bias = bias\n\n self.layers = nn.ModuleList()\n # create rgcn layers\n self.build_model()","def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\n if rnn_type.endswith('lstm'):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n elif rnn_type.endswith('gru'):\n cell = tc.rnn.GRUCell(num_units=hidden_size)\n elif rnn_type.endswith('rnn'):\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\n else:\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n if layer_num > 1:\n cell = tc.rnn.MultiRNNCell([cell] * layer_num, state_is_tuple=True)\n return cell","def __init__(self,\n num_units,\n use_peepholes=False,\n cell_clip=None,\n initializer=None,\n num_proj=None,\n proj_clip=None,\n num_unit_shards=None,\n num_proj_shards=None,\n forget_bias=1.0,\n state_is_tuple=True,\n activation=None,\n reuse=None):\n super(MaskedLSTMCell, self).__init__(\n num_units,\n use_peepholes=use_peepholes,\n cell_clip=cell_clip,\n initializer=initializer,\n num_proj=num_proj,\n proj_clip=proj_clip,\n num_unit_shards=num_unit_shards,\n num_proj_shards=num_proj_shards,\n forget_bias=forget_bias,\n state_is_tuple=state_is_tuple,\n activation=activation,\n reuse=reuse)","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embed = get_embed(input_data, vocab_size, embed_dim) \n output, final_state = build_rnn(cell, embed)\n \n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\n #final_state = tf.identity(final_state, name='final_state') \n return logits, final_state","def __init__(self,\n layer,\n train_batch=1,\n query_batch=1,\n num_steps=1,\n init_lr=0.2,\n initializer=tf.contrib.layers.xavier_initializer(),\n loss=batched_mse,\n flatten_output=True,\n reuse=None):\n super(Cell, self).__init__(_reuse=reuse)\n self._layer = layer\n self._train_batch = train_batch\n self._query_batch = query_batch\n self._num_steps = num_steps\n self._init_lr = init_lr\n self._initializer = initializer\n self._loss = loss\n self._flatten_output = flatten_output","def single_cell(\n cell_class,\n cell_params,\n dp_input_keep_prob=1.0,\n dp_output_keep_prob=1.0,\n recurrent_keep_prob=1.0,\n input_weight_keep_prob=1.0,\n recurrent_weight_keep_prob=1.0,\n weight_variational=False,\n dropout_seed=None,\n zoneout_prob=0.,\n training=True,\n residual_connections=False,\n awd_initializer=False,\n variational_recurrent=False, # in case they want to use DropoutWrapper\n dtype=None,\n):\n if awd_initializer:\n val = 1.0/math.sqrt(cell_params['num_units'])\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\n if recurrent_keep_prob < 1.0:\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\n if input_weight_keep_prob < 1.0:\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\n if recurrent_weight_keep_prob < 1.0:\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\n if weight_variational:\n cell_params['weight_variational'] = weight_variational # which is basically True\n if dropout_seed:\n cell_params['dropout_seed'] = dropout_seed\n\n\n cell = cell_class(**cell_params)\n if residual_connections:\n cell = ResidualWrapper(cell)\n if zoneout_prob > 0. and (\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\n ):\n raise ValueError(\n \"Currently applying both dropout and zoneout on the same cell.\"\n \"This is currently not supported.\"\n )\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\n cell = DropoutWrapper(\n cell,\n input_keep_prob=dp_input_keep_prob,\n output_keep_prob=dp_output_keep_prob,\n variational_recurrent=variational_recurrent,\n dtype=dtype,\n seed=dropout_seed\n )\n if zoneout_prob > 0.:\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\n return cell","def _rnn_cells(self) -> RNNCellTuple:\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))","def init_gru(rnn):\n\n def _concat_init(tensor, init_funcs):\n (length, fan_out) = tensor.shape\n fan_in = length // len(init_funcs)\n\n for (i, init_func) in enumerate(init_funcs):\n init_func(tensor[i * fan_in: (i + 1) * fan_in, :])\n\n def _inner_uniform(tensor):\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\n\n for i in range(rnn.num_layers):\n _concat_init(\n getattr(rnn, 'weight_ih_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, _inner_uniform]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\n\n _concat_init(\n getattr(rnn, 'weight_hh_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)","def lstm_cell():\n if 'reuse' in inspect.getargspec(\n tf.contrib.rnn.BasicLSTMCell.__init__).args:\n return tf.contrib.rnn.BasicLSTMCell(\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True,\n reuse=tf.get_variable_scope().reuse)\n else:\n return tf.contrib.rnn.BasicLSTMCell(\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True)","def init_gru(rnn):\n \n def _concat_init(tensor, init_funcs):\n (length, fan_out) = tensor.shape\n fan_in = length // len(init_funcs)\n \n for (i, init_func) in enumerate(init_funcs):\n init_func(tensor[i * fan_in : (i + 1) * fan_in, :])\n \n def _inner_uniform(tensor):\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\n \n for i in range(rnn.num_layers):\n _concat_init(\n getattr(rnn, 'weight_ih_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, _inner_uniform]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\n\n _concat_init(\n getattr(rnn, 'weight_hh_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)","def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\n\t\treturn _mh.create_rnn_cell(\n\t\t\tunit_type=hparams.unit_type,\n\t\t\tnum_units=self.num_units,\n\t\t\tnum_layers=num_layers,\n\t\t\tnum_residual_layers=num_residual_layers,\n\t\t\tforget_bias=hparams.forget_bias,\n\t\t\tdropout=hparams.dropout,\n\t\t\tmode=self.mode)","def setup_rnn_model(default_ctx,\n num_lstm_layer, \n num_hidden,\n batch_size,\n initializer,\n group2ctx=None, concat_decode=True,\n use_loss=False, buckets=None):\n max_len = n_steps\n max_rnn_exec = None\n rnn_sym = lstm_unroll(num_lstm_layer=num_lstm_layer,\n num_hidden=num_hidden)\n arg_names = rnn_sym.list_arguments()\n internals = rnn_sym.get_internals()\n\n input_shapes = {}\n for name in arg_names:\n if name.endswith(\"init_c\") or name.endswith(\"init_h\"):\n input_shapes[name] = (batch_size, num_hidden)\n elif name.endswith(\"data\"):\n input_shapes[name] = (batch_size,MAX_LEN)\n elif name == \"labels\":\n input_shapes[name] = (batch_size,MAX_LEN)\n elif name.endswith(\"label\"):\n input_shapes[name] = (batch_size, )\n else:\n pass\n\n arg_shape, out_shape, aux_shape = rnn_sym.infer_shape(**input_shapes)\n # bind arrays\n arg_arrays = []\n args_grad = {}\n for shape, name in zip(arg_shape, arg_names):\n group = internals[name].attr(\"ctx_group\")\n ctx = group2ctx[group] if group is not None else default_ctx\n arg_arrays.append(mx.nd.zeros(shape, ctx))\n if is_param_name(name):\n args_grad[name] = mx.nd.zeros(shape, ctx)\n if not name.startswith(\"t\"):\n print(\"%s group=%s, ctx=%s\" % (name, group, str(ctx)))\n \n #bind with shared executor\n rnn_exec = None\n rnn_exec = rnn_sym.bind(default_ctx, args=arg_arrays,\n args_grad=args_grad,\n grad_req=\"add\", group2ctx=group2ctx)\n max_rnn_exec = rnn_exec\n \n\n param_blocks = []\n arg_dict = dict(zip(arg_names, rnn_exec.arg_arrays))\n for i, name in enumerate(arg_names):\n if is_param_name(name):\n initializer(name, arg_dict[name])\n param_blocks.append((i, arg_dict[name], args_grad[name], name))\n else:\n assert name not in args_grad\n\n out_dict = dict(zip(rnn_sym.list_outputs(), rnn_exec.outputs))\n\n init_states = [LSTMState(c=arg_dict[\"l%d_init_c\" % i],\n h=arg_dict[\"l%d_init_h\" % i]) for i in range(num_lstm_layer)]\n\n seq_data = rnn_exec.arg_dict[\"data\"]\n # we don't need to store the last state \n last_states = None\n\n seq_outputs = [out_dict[\"sm_output\"]]\n seq_labels = [rnn_exec.arg_dict[\"labels\"]]\n\n model = LSTMModel(rnn_exec=rnn_exec, symbol=rnn_sym,\n init_states=init_states, last_states=last_states,\n seq_data=seq_data, seq_labels=seq_labels, seq_outputs=seq_outputs,\n param_blocks=param_blocks)\n return model","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):\n super(ModGRUCell, self).__init__()\n\n self.height, self.width = input_size\n self.input_dim = input_dim\n self.hidden_dim = hidden_dim\n\n self.kernel_size = kernel_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.bias = bias\n\n self.conv1 = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n out_channels=1,\n kernel_size=self.kernel_size,\n padding=self.padding,\n bias=self.bias)\n \n self.conv2 = nn.Conv2d(in_channels=self.input_dim,\n out_channels=self.hidden_dim,\n kernel_size=self.kernel_size,\n padding=self.padding,\n bias=self.bias)","def __init__(self, init_grid=None):\n\n self.height = len(init_grid)\n self.width = len(init_grid[0])\n\n self.grid = [[Cell(self, c) for c in row]\n for row in init_grid]\n\n self.g = nx.Graph()\n self.tangle()","def _create_cell(self,row_number,cell_number):\n cell = Cell(self)\n cell.x = cell_number * self.cell_width\n cell.y = row_number * self.cell_width\n cell.rect.x = cell.x\n cell.rect.y = cell.y\n return cell","def _build_pnasnet_base(\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\n start_cell_num):\n\n # Find where to place the reduction cells or stride normal cells\n reduction_indices = nasnet_utils.calc_reduction_layers(\n hparams.num_cells, hparams.num_reduction_layers)\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\n\n # Note: The None is prepended to match the behavior of _imagenet_stem()\n cell_outputs = [None, hidden_previous, hidden]\n net = hidden\n\n # Run the cells\n for cell_num in range(start_cell_num, hparams.num_cells):\n is_reduction = cell_num in reduction_indices\n stride = 2 if is_reduction else 1\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\n prev_layer = cell_outputs[-2]\n net = normal_cell(\n net,\n scope='cell_{}'.format(cell_num),\n filter_scaling=filter_scaling,\n stride=stride,\n prev_layer=prev_layer,\n cell_num=true_cell_num)\n true_cell_num += 1\n cell_outputs.append(net)\n\n # Final nonlinearity.\n # Note that we have dropped the final pooling, dropout and softmax layers\n # from the default pnasnet version.\n with tf.variable_scope('final_layer'):\n net = tf.nn.relu(net)\n return net","def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\n state_keep_prob=1.0, variational_recurrent=False,\n input_size=None, dtype=None, seed=None,\n dropout_state_filter_visitor=None):\n if not _like_rnncell(cell):\n raise TypeError(\"The parameter cell is not a RNNCell.\")\n if (dropout_state_filter_visitor is not None\n and not callable(dropout_state_filter_visitor)):\n raise TypeError(\"dropout_state_filter_visitor must be callable\")\n self._dropout_state_filter = (\n dropout_state_filter_visitor or _default_dropout_state_filter_visitor)\n with ops.name_scope(\"DropoutWrapperInit\"):\n def tensor_and_const_value(v):\n tensor_value = ops.convert_to_tensor(v)\n const_value = tensor_util.constant_value(tensor_value)\n return (tensor_value, const_value)\n for prob, attr in [(input_keep_prob, \"input_keep_prob\"),\n (state_keep_prob, \"state_keep_prob\"),\n (output_keep_prob, \"output_keep_prob\")]:\n tensor_prob, const_prob = tensor_and_const_value(prob)\n if const_prob is not None:\n if const_prob < 0 or const_prob > 1:\n raise ValueError(\"Parameter %s must be between 0 and 1: %d\"\n % (attr, const_prob))\n setattr(self, \"_%s\" % attr, float(const_prob))\n else:\n setattr(self, \"_%s\" % attr, tensor_prob)\n\n # Set cell, variational_recurrent, seed before running the code below\n self._cell = cell\n self._variational_recurrent = variational_recurrent\n self._seed = seed\n\n self._recurrent_input_noise = None\n self._recurrent_state_noise = None\n self._recurrent_output_noise = None\n\n if variational_recurrent:\n if dtype is None:\n raise ValueError(\n \"When variational_recurrent=True, dtype must be provided\")\n\n def convert_to_batch_shape(s):\n # Prepend a 1 for the batch dimension; for recurrent\n # variational dropout we use the same dropout mask for all\n # batch elements.\n return array_ops.concat(\n ([1], tensor_shape.TensorShape(s).as_list()), 0)\n\n def batch_noise(s, inner_seed):\n shape = convert_to_batch_shape(s)\n return random_ops.random_uniform(shape, seed=inner_seed, dtype=dtype)\n\n if (not isinstance(self._input_keep_prob, numbers.Real) or\n self._input_keep_prob < 1.0):\n if input_size is None:\n raise ValueError(\n \"When variational_recurrent=True and input_keep_prob < 1.0 or \"\n \"is unknown, input_size must be provided\")\n self._recurrent_input_noise = _enumerated_map_structure_up_to(\n input_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"input\", i)),\n input_size)\n self._recurrent_state_noise = _enumerated_map_structure_up_to(\n cell.state_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"state\", i)),\n cell.state_size)\n self._recurrent_output_noise = _enumerated_map_structure_up_to(\n cell.output_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"output\", i)),\n cell.output_size)","def rnn_cell_loop(self):\n\n\t\t# Set up initial state\n\t\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\t\t\t# Spike\n\t\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\t\t\t\t\t# State\n\t\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\n\t\tself.h = [self.h]\n\t\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\n\n\t\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\t\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\n\t\t# Apply the EI mask to the recurrent weights\n\t\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\n\n\t\t# Set up latency buffer if being used\n\t\tif par['use_latency']:\n\t\t\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\n\t\t\tself.state_buffer = deque(self.state_buffer)\n\t\t\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\n\t\t\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\n\n\t\t# Set up output record\n\t\tself.output = []\n\t\tself.syn_x = []\n\t\tself.syn_u = []\n\n\t\ty = 0.\n\t\tfor t in range(par['num_time_steps']):\n\t\t\tself.t = t \t\t# For latency calculations\n\n\t\t\tif par['cell_type'] == 'rate':\n\t\t\t\traise Exception('Rate cell not yet implemented.')\n\t\t\telif par['cell_type'] == 'adex':\n\t\t\t\tif t < 10:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\telse:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\t\t\t\tself.syn_x.append(syn_x)\n\t\t\t\tself.syn_u.append(syn_u)\n\n\t\t\telif par['cell_type'] == 'lif':\n\t\t\t\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\n\t\t# Stack records\n\t\tself.output = tf.stack(self.output, axis=0)\n\t\tself.h = tf.stack(self.h, axis=0)\n\t\tself.h_out = tf.stack(self.h_out, axis=0)\n\t\tself.syn_x = tf.stack(self.syn_x, axis=0)\n\t\tself.syn_u = tf.stack(self.syn_u, axis=0)","def _build_rnn(self, n_cells, hidden_layer_size, num_layers,\n batch_size, time_window, lr):\n\n x_anchor = tf.placeholder(shape=[batch_size, n_cells, time_window],\n dtype=tf.float32)\n x_pos = tf.placeholder(shape=[batch_size, n_cells, time_window],\n dtype=tf.float32)\n x_neg = tf.placeholder(shape=[batch_size, n_cells, time_window,],\n dtype=tf.float32)\n\n def embed_rnn(x_in):\n \"\"\"Gives RNN embedding of x_in.\"\"\"\n x_in_flat = tf.reshape(x_in, [batch_size*time_window, n_cells])\n w_in = tf.get_variable(\"w_in\", shape=[n_cells, hidden_layer_size],\n initializer=tf.random_normal_initializer())\n b_in = tf.get_variable(\"b_in\", shape=[hidden_layer_size],\n initializer=tf.random_normal_initializer())\n x_ld_flat = tf.matmul(x_in_flat, w_in) + b_in\n x_ld = tf.reshape(x_ld_flat, [batch_size, time_window, hidden_layer_size])\n\n # stacked LSTM cells\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_layer_size,\n forget_bias=0.0,\n state_is_tuple=True)\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers,\n state_is_tuple=True)\n\n # compute output\n initial_state = cell.zero_state(batch_size, tf.float32)\n outputs, _ = tf.nn.dynamic_rnn(cell, x_ld,\n initial_state=initial_state,\n time_major=False)\n\n # reconstruct and compute loss on last output only\n outputs_unp = tf.unpack(tf.transpose(outputs, [1, 0, 2]))\n embedding = outputs_unp[-1]\n\n return embedding\n\n def distance_squared(embed1, embed2):\n return tf.reduce_sum((embed1 - embed2)**2, 1)\n\n with tf.variable_scope(\"RNN\") as scope:\n\n # embed anchor, positive and negative examples.\n embed_anchor = embed_rnn(tf.transpose(x_anchor, [0, 2, 1]))\n # This enables reusing the RNN for anchor, pos and neg.\n scope.reuse_variables()\n # Check that we are reusing the same RNN using:\n # print(tf.get_variable_scope().reuse)\n embed_pos = embed_rnn(tf.transpose(x_pos, [0, 2, 1]))\n embed_neg = embed_rnn(tf.transpose(x_neg, [0, 2, 1]))\n\n # Loss for each point max(d(anchor, pos)^2 - d(anchor, neg)^2 + 1, 0)\n loss = tf.reduce_sum(tf.nn.relu(distance_squared(embed_anchor,\n embed_pos) -\n distance_squared(embed_anchor,\n embed_neg)\n + 1), 0)\n # train model\n train_step = tf.train.AdagradOptimizer(lr).minimize(loss)\n\n return (x_anchor, x_pos, x_neg, train_step, loss,\n embed_anchor, embed_pos, embed_neg)","def __init__(self,\n num_units,\n forget_bias=1.0,\n state_is_tuple=True,\n activation=None,\n reuse=None,\n name=None):\n super(MaskedBasicLSTMCell, self).__init__(\n num_units,\n forget_bias=forget_bias,\n state_is_tuple=state_is_tuple,\n activation=activation,\n reuse=reuse,\n name=name)","def build(self, input_tensors, is_training, lengths=None, hparams=None):\n input_tensor = input_tensors[-1]\n rnn_cell = tf.compat.v1.nn.rnn_cell.BasicRNNCell(\n num_units=self._output_size, activation=tf.nn.tanh)\n net, _ = tf.compat.v1.nn.dynamic_rnn(\n rnn_cell, input_tensor, sequence_length=lengths, dtype=tf.float32)\n\n if self._skip:\n net += _add_projection_if_needed(input_tensor, net)\n\n return input_tensors + [net]","def __init__(self, num_outputs, use_ground_truth, internal_cell):\n self._num_outputs = num_outputs\n self._use_ground_truth = use_ground_truth # boolean\n self._internal_cell = internal_cell # may be LSTM or GRU or anything","def __init__(\n self,\n input_size,\n hidden_size,\n nonlinearity='relu',\n num_layers=1,\n bidirectional=False,\n dropout=0,\n **kwargs\n ):\n mode = 'rnn_relu' if nonlinearity == 'relu' else 'rnn_tanh'\n super(RNN, self).__init__(\n mode, input_size, hidden_size,\n num_layers, bidirectional, dropout, **kwargs\n )","def __init__(\n self,\n input_tensor_spec,\n output_tensor_spec,\n conv_layer_params=None,\n input_fc_layer_params=(200, 100),\n lstm_size=(40,),\n output_fc_layer_params=(200, 100),\n activation_fn=tf.keras.activations.relu,\n name='ActorRnnNetwork',\n ):\n if len(tf.nest.flatten(input_tensor_spec)) > 1:\n raise ValueError('Only a single observation is supported by this network')\n\n input_layers = utils.mlp_layers(\n conv_layer_params,\n input_fc_layer_params,\n activation_fn=activation_fn,\n kernel_initializer=tf.compat.v1.keras.initializers.glorot_uniform(),\n name='input_mlp',\n )\n\n # Create RNN cell\n if len(lstm_size) == 1:\n cell = tf.keras.layers.LSTMCell(lstm_size[0])\n else:\n cell = tf.keras.layers.StackedRNNCells(\n [tf.keras.layers.LSTMCell(size) for size in lstm_size]\n )\n\n state_spec = tf.nest.map_structure(\n functools.partial(\n tensor_spec.TensorSpec, dtype=tf.float32, name='network_state_spec'\n ),\n list(cell.state_size),\n )\n\n output_layers = utils.mlp_layers(\n fc_layer_params=output_fc_layer_params, name='output'\n )\n\n flat_action_spec = tf.nest.flatten(output_tensor_spec)\n action_layers = [\n tf.keras.layers.Dense(\n single_action_spec.shape.num_elements(),\n activation=tf.keras.activations.tanh,\n kernel_initializer=tf.keras.initializers.RandomUniform(\n minval=-0.003, maxval=0.003\n ),\n name='action',\n )\n for single_action_spec in flat_action_spec\n ]\n\n super(ActorRnnNetwork, self).__init__(\n input_tensor_spec=input_tensor_spec, state_spec=state_spec, name=name\n )\n\n self._output_tensor_spec = output_tensor_spec\n self._flat_action_spec = flat_action_spec\n self._conv_layer_params = conv_layer_params\n self._input_layers = input_layers\n self._dynamic_unroll = dynamic_unroll_layer.DynamicUnroll(cell)\n self._output_layers = output_layers\n self._action_layers = action_layers","def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\n cells = []\n for i in range(layer_num):\n if rnn_type.endswith('lstm'):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n elif rnn_type.endswith('gru'):\n cell = tc.rnn.GRUCell(num_units=hidden_size)\n elif rnn_type.endswith('rnn'):\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\n else:\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\n return cells","def __init__(self, model, num_classes=-1, hidden_size=128, type='gru', **kwargs):\n super(CNNRNN, self).__init__(**kwargs)\n self.feats = model is None\n with self.name_scope():\n if model is not None:\n self.td = TimeDistributed(model.backbone)\n if type == 'lstm':\n self.rnn = mx.gluon.rnn.LSTM(hidden_size, layout=\"NTC\", bidirectional=True)\n else:\n self.rnn = mx.gluon.rnn.GRU(hidden_size, layout=\"NTC\", bidirectional=True)\n self.classes = None\n if num_classes == 0:\n self.classes = model.classes\n elif num_classes > 0:\n self.classes = nn.Dense(num_classes, flatten=True)","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\n super(ConvGRUCell, self).__init__()\n self.height, self.width = input_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.hidden_dim = hidden_dim\n self.bias = bias\n self.dtype = dtype\n\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)\n\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\n out_channels=self.hidden_dim, # for candidate neural memory\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)","def __init__(self, celltype, model=None, build_mode='lazy'):\n # Generate the NineLine class from the nineml file and initialise a\n # single cell from it\n if (isinstance(celltype, BiophysNineml) or isinstance(celltype, str)):\n self.celltype = CellMetaClass(celltype, build_mode=build_mode)\n else:\n self.celltype = celltype\n self.default_seg = self.celltype(model=model).source_section.name\n self._model = model\n self.genome_keys = []\n self.log_scales = []","def __call__(self, inputs, state, scope=None, debug=False):\n # B is batch size.\n\n # 1) Use read_ind to find memory location to read from\n # as input.\n\n # inputs.read_ind: (B, 1)\n # memory: (B, mem_size, embed_size)\n read_ind = tf.to_int32(inputs.read_ind)\n batch_size = tf.shape(read_ind)[0]\n if debug:\n print('batch size is', batch_size)\n print('read ind is', read_ind)\n mem_ind = tf.range(batch_size)\n\n # read_mem_ind: (B, 1)\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\n # read_ind: (B, 2)\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\n if debug:\n print('processed read ind is', read_ind)\n\n # inner_inputs: (B, embed_size)\n inner_inputs = tf.gather_nd(state.memory, read_ind)\n if debug:\n print('inner_inputs is', inner_inputs)\n\n inner_state = state.inner_state\n\n # 2) Run the inner RNNCell.\n \n # inner_outputs: (B, embed_size)\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\n\n if debug:\n print('inner_outputs is', inner_outputs)\n\n # 3) Compute logits for valid indices (using logit_masks\n # to mask out padded valid indices (-1)).\n \n # valid_indices: (B, max_n_valid_indices)\n valid_indices = tf.to_int32(inputs.valid_indices)\n if debug:\n print('valid_indices is', valid_indices)\n \n # Logit mask: (B, max_n_valid_indices)\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\n logit_masks = tf.cast(logit_masks, tf.float32)\n\n if debug:\n print('logit_masks is', logit_masks)\n\n # Normalize indices to be at least 0.\n valid_indices = tf.maximum(valid_indices, 0)\n\n # valid_indices: (B, max_n_valid_indices, 1)\n valid_indices = tf.expand_dims(valid_indices, -1)\n if debug:\n print('valid_indices is', valid_indices)\n print('mem_ind is', mem_ind)\n\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # valid_mem_ind: (B, 1, 1)\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\n if debug:\n print('valid_mem_ind is', valid_mem_ind)\n\n # valid_mem_ind: (B, max_n_valid_indices, 1)\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\n\n # valid_indices: (B, max_n_valid_indices, 2)\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\n # index into the right memory location.\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\n\n if debug:\n print('valid_indices is', valid_indices)\n\n # select all the valid slots. \n # valid_values: (B, max_n_valid_indices, embed_size)\n valid_values = tf.gather_nd(state.memory, valid_indices)\n if debug:\n print('valid_values is', valid_values)\n \n # expanded_inner_outputs: (B, 1, embed_size)\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\n if debug:\n print('expanded_inner_outputs is', expanded_inner_outputs)\n\n # valid_values: (B, embed_size, max_n_valid_indices)\n valid_values = tf.transpose(valid_values, [0, 2, 1])\n if debug:\n print('valid_values is', valid_values)\n\n # logits: (B, 1, max_n_valid_indices)\n logits = tf.matmul(expanded_inner_outputs, valid_values)\n \n if debug:\n print('logits is', logits)\n\n # logits: (B, max_n_valid_indices)\n logits = tf.squeeze(logits, axis=[1])\n if debug:\n print('logits is', logits)\n\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\n\n outputs = masked_logits\n # 4) Write the output of the inner RNN to a memory\n # location (write_ind), using write_masks to mask out\n # padded write_ind (-1).\n \n # write_ind: (B, 1)\n write_ind = tf.cast(inputs.write_ind, tf.int32)\n if debug:\n print('write_ind is', write_ind)\n\n # write mask: (B, 1)\n write_masks = tf.greater_equal(inputs.write_ind, 0)\n if debug:\n print('write_masks greater_equal', write_masks)\n\n write_masks = tf.cast(write_masks, tf.float32)\n\n # write mask: (B, 1, 1)\n write_masks = tf.expand_dims(write_masks, [-1])\n\n if debug:\n print('write_masks is', write_masks)\n\n # Normalize write_ind to be above 0.\n # write_ind: (B, 1)\n write_ind = tf.maximum(write_ind, 0)\n\n # write_mem_ind: (B, 1)\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # write_ind: (B, 2)\n # Second dimension is [b_i, write_index]\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\n if debug:\n print('write_ind is', write_ind)\n\n if debug:\n print('masked_logits is', masked_logits)\n print('memory is', state.memory)\n\n # write_mat: (B, mem_size, embed_size)\n write_mat = tf.scatter_nd(\n write_ind, inner_outputs, shape=tf.shape(state.memory))\n\n if debug:\n print('@' * 50)\n print('write_mat is', write_mat)\n print('write_mask is', write_masks)\n print('@' * 50)\n\n masked_write_mat = write_mat * write_masks\n new_memory = state.memory + masked_write_mat\n \n state = MemoryStateTuple(new_memory, new_inner_state)\n if debug:\n print('state is', state)\n \n return (outputs, state)","def resnet_9blocks(pretrained=False, **kwargs):\n return ResnetGenerator(\n 9, **kwargs\n )","def __init__(self,\n num_units,\n forget_bias=1.0,\n activation=None,\n reuse=None,\n layer_norm: bool=False,\n norm_shift: float=0.0,\n norm_gain: float=1.0, # layer normalization\n dropout_keep_prob_in: float = 1.0,\n dropout_keep_prob_h: float=1.0,\n dropout_keep_prob_out: float=1.0,\n dropout_keep_prob_gate: float=1.0,\n dropout_keep_prob_forget: float=1.0,\n dropout_prob_seed: int=None,\n variational_dropout: bool=False,\n recurrent_dropout: bool=False\n ):\n super(CustomLSTMCell, self).__init__(_reuse=reuse)\n self._num_units = num_units\n self._forget_bias = forget_bias\n self._activation = activation or math_ops.tanh\n\n self._layer_norm = layer_norm\n self._g = norm_gain\n self._b = norm_shift\n\n self._recurrent_dropout = recurrent_dropout\n self._variational_dropout = variational_dropout\n \n self._seed = dropout_prob_seed\n self._keep_prob_i = dropout_keep_prob_in\n self._keep_prob_g = dropout_keep_prob_gate\n self._keep_prob_f = dropout_keep_prob_forget\n self._keep_prob_o = dropout_keep_prob_out\n self._keep_prob_h = dropout_keep_prob_h","def resnet10(**kwargs):\n model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)\n return model","def get_rnn_cells(self):\n return [self.rnn]","def SimpleRNN(self):\n # Model.\n model = Sequential()\n model.add(SimpleRNN(2048, return_sequences=True,\n input_shape=self.input_shape,\n dropout=0.0))\n #model.add(Flatten()) #qiao_added\n # model.add(Dense(1024, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(2048, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Flatten())\n model.add(Dense(self.nb_classes, activation='softmax'))\n return model","def __call__(self, inputs, state, scope=None):\n if scope is not None:\n with vs.variable_scope(scope,\n custom_getter=self._rnn_get_variable) as scope:\n return super(RNNCell, self).__call__(inputs, state, scope=scope)\n else:\n scope_attrname = \"rnncell_scope\"\n scope = getattr(self, scope_attrname, None)\n if scope is None:\n scope = vs.variable_scope(vs.get_variable_scope(),\n custom_getter=self._rnn_get_variable)\n setattr(self, scope_attrname, scope)\n with scope:\n return super(RNNCell, self).__call__(inputs, state)","def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\n is_training=True, seed=None):\n if not isinstance(cell, tf.nn.rnn_cell.RNNCell):\n raise TypeError(\"The parameter cell is not a RNNCell.\")\n if (isinstance(input_keep_prob, float) and\n not (input_keep_prob >= 0.0 and input_keep_prob <= 1.0)):\n raise ValueError(\"Parameter input_keep_prob must be between 0 and 1: %d\"\n % input_keep_prob)\n if (isinstance(output_keep_prob, float) and\n not (output_keep_prob >= 0.0 and output_keep_prob <= 1.0)):\n raise ValueError(\"Parameter output_keep_prob must be between 0 and 1: %d\"\n % output_keep_prob)\n self._cell = cell\n self._input_keep_prob = input_keep_prob\n self._output_keep_prob = output_keep_prob\n self._seed = seed\n self._is_training = is_training","def __init__(self, name=\"conv_1d_lstm_cell\", **kwargs):\n super(Conv1DLSTMCell, self).__init__(conv_ndims=1, name=name, **kwargs)","def __init__(self, width=20, height=20):\n self.width = width\n self.height = height\n self.cells = []\n for y in range(self.height):\n for x in range(self.width):\n self.cells.append(Cell(x, y, [N, S, E, W]))","def n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs,\n activation, use_bi_direction, **kwargs): # NOQA\n\n argument.check_unexpected_kwargs(\n kwargs, train='train argument is not supported anymore. '\n 'Use chainer.using_config',\n use_cudnn='use_cudnn argument is not supported anymore. '\n 'Use chainer.using_config')\n argument.assert_kwargs_empty(kwargs)\n\n activation_list = ['tanh', 'relu']\n if activation not in activation_list:\n candidate = ','.join(activation_list)\n raise ValueError('Invalid activation: \"%s\". Please select from [%s]'\n % (activation, candidate))\n\n xp = cuda.get_array_module(hx)\n\n if xp is not numpy and chainer.should_use_cudnn('>=auto', 5000):\n states = get_random_state().create_dropout_states(dropout_ratio)\n lengths = [len(x) for x in xs]\n xs = chainer.functions.concat(xs, axis=0)\n\n rnn_mode = 'rnn_%s' % activation\n w = cudnn_rnn_weight_concat(\n n_layers, states, use_bi_direction, rnn_mode, ws, bs)\n\n if use_bi_direction:\n # Bi-directional RNN\n if activation == 'tanh':\n rnn = NStepBiRNNTanh\n elif activation == 'relu':\n rnn = NStepBiRNNReLU\n else:\n # Uni-directional RNN\n if activation == 'tanh':\n rnn = NStepRNNTanh\n elif activation == 'relu':\n rnn = NStepRNNReLU\n\n hy, ys = rnn(n_layers, states, lengths)(hx, w, xs)\n sections = numpy.cumsum(lengths[:-1])\n ys = chainer.functions.split_axis(ys, sections, 0)\n return hy, ys\n\n else:\n\n def f(x, h, c, w, b):\n xw, hw = w\n xb, hb = b\n rnn_in = linear.linear(x, xw, xb) + linear.linear(h, hw, hb)\n if activation == 'tanh':\n return tanh.tanh(rnn_in), None\n elif activation == 'relu':\n return relu.relu(rnn_in), None\n\n hy, _, ys = n_step_rnn_impl(\n f, n_layers, dropout_ratio, hx, None, ws, bs, xs, use_bi_direction)\n return hy, ys","def create_cells(self, N):\n self.cells = []\n r = 50 # Radius of cell locations from origin (0,0,0) in microns\n N = self._N\n for i in range(N):\n cell = BallAndStick()\n # When cells are created, the soma location is at (0,0,0) and\n # the dendrite extends along the X-axis.\n # First, at the origin, rotate about Z.\n cell.rotateZ(i * 2 * pi / N)\n # Then reposition\n x_loc = cos(i * 2 * pi / N) * r\n y_loc = sin(i * 2 * pi / N) * r\n cell.set_position(x_loc, y_loc, 0)\n self.cells.append(cell)","def __init__(self,\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\n in2hid: tuple, in2out: tuple,\n hid2hid: tuple, hid2out: tuple,\n hidden_biases: np.ndarray, output_biases: np.ndarray,\n rnn_array: np.ndarray, rnn_map: np.ndarray,\n activation,\n batch_size: int = 1,\n initial_read: np.ndarray = None,\n dtype=np.float64,\n ):\n # Storing the input arguments (needed later on)\n self.act_f = activation\n self.dtype = dtype\n self.rnn_idx: np.ndarray = rnn_idx\n self.n_inputs: int = len(input_idx)\n self.n_hidden: int = len(hidden_idx)\n self.n_rnn: int = len(rnn_idx)\n self.n_outputs: int = len(output_idx)\n self.bs: int = batch_size\n \n # Setup the rnn_map\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\n for i, m in enumerate(rnn_map):\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\n \n # Placeholders, initialized during reset\n self.rnn_state: np.ndarray = None # State of the RNNs\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\n self.output_act: np.ndarray = None # Activations of the output nodes\n \n # Do not create the hidden-related matrices if hidden-nodes do not exist\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\n if self.n_hidden > 0:\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\n self.rnn_array: np.ndarray = rnn_array\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\n \n # Fill in the biases\n if self.n_hidden > 0:\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\n \n # Put network to initial (default) state\n self.reset(initial_read=initial_read)","def __init__(\n self, channel_count: int, input_height_width: tuple, no_add: bool = False\n ):\n super().__init__()\n\n self.no_add: bool = no_add\n\n self.rm_block_1 = RMBlock(\n channel_count // 2,\n channel_count,\n input_height_width,\n 1,\n \"weight\",\n 1,\n )\n\n self.rm_block_2 = RMBlock(\n channel_count // 2,\n channel_count // 2,\n input_height_width,\n 3,\n \"weight\",\n 32,\n )\n\n self.rm_block_3 = RMBlock(\n channel_count,\n channel_count // 2,\n input_height_width,\n 1,\n \"weight\",\n 1,\n )","def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\n #====================================================================================#\n # ----------PROBLEM 2----------\n #====================================================================================#\n # YOUR CODE HERE\n # raise NotImplementedError\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\n ## step 1 - inputs are first embedded by an MLP\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\n # print(\"after build_mlp x = \", x)\n ## step 2 - passed to a GRU cell\n # as \"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\"hidden\", dtype=tf.float32)\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\n # after build_mlp x = Tensor(\"continuous_logits/continuous_logits/fc1/BiasAdd:0\", shape=(?, 1, 32), dtype=float32)\n # x = tf.squeeze(x, axis=1)\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\n # print(\"dynamic_rnn build_mlp x = \", x, \" h = \", h)\n return x, h","def add_model(self, inputs):\n size = self.config.hidden_size\n forget_bias = self.config.forget_bias\n input_cell = self.config.input_cell\n\n if input_cell == 'BasicLSTMCell':\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\n print 'Using Basic LSTM Cell \\n'\n\n elif input_cell == 'LSTMCell':\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\n print 'Using LSTM Cell \\n'\n\n elif input_cell == 'GRUCell':\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\n print 'Using GRU Cell \\n'\n\n else:\n print \"Please Specify a Correct Cell Type\"\n\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\n input_keep_prob=self.config.dropout)\n\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\n \n print 'Number of Hidden Layers ', self.config.num_layers\n \n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\n rnn_outputs = []\n state = self.initial_state\n\n with tf.variable_scope('RNNLM') as scope:\n for time_step in range(self.config.num_steps):\n if time_step > 0: scope.reuse_variables()\n (cell_output, state) = cell(inputs[:, time_step, :], state)\n rnn_outputs.append(cell_output)\n self.final_state = state\n\n return rnn_outputs","def __init__(self, cell_index, stimulus_type, conv_layers=[(12, 9, 9), (12, 9, 9)], dense_layer=64,\n loss='poisson_loss', optimizer='adam', weight_init='normal', l2_reg=0., dropout=0.5, mean_adapt=False):\n\n self.stim_shape = (40, 50, 50)\n\n # build the model\n with notify('Building convnet'):\n\n self.model = Sequential()\n\n # convolutional layers\n for ix, layer in enumerate(conv_layers):\n\n # get parameters for this layer\n num_filters, row_size, col_size = layer\n\n # convolutional layer\n if ix == 0:\n self.model.add(Convolution2D(num_filters, row_size, col_size,\n input_shape=self.stim_shape, init=weight_init,\n border_mode='same', subsample=(1,1),\n W_regularizer=l2(l2_reg), activation='relu'))\n\n else:\n self.model.add(Convolution2D(num_filters, row_size, col_size,\n input_shape=self.stim_shape, init=weight_init,\n border_mode='same', subsample=(1,1),\n W_regularizer=l2(l2_reg), activation='relu'))\n\n # max pooling layer\n self.model.add(MaxPooling2D(pool_size=(2, 2), ignore_border=True))\n\n # dropout\n self.model.add(Dropout(dropout))\n\n # flatten\n self.model.add(Flatten())\n\n # Add dense (affine) layer with relu activation\n self.model.add(Dense(dense_layer, init=weight_init, W_regularizer=l2(l2_reg), activation='relu'))\n self.model.add(Dropout(dropout))\n\n # Add a final dense (affine) layer with softplus activation\n self.model.add(Dense(1, init=weight_init, W_regularizer=l2(l2_reg), activation='softplus'))\n\n # save architecture string (for markdown file)\n self.architecture = '\\n'.join(['Convolutional layers {}'.format(conv_layers),\n '{} filters in the second (fully connected) layer'.format(dense_layer),\n 'weight initialization: {}'.format(weight_init),\n 'l2 regularization: {}'.format(l2_reg),\n 'stimulus shape: {}'.format(self.stim_shape)])\n\n # compile\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)","def __init__(self, name=\"conv_2d_lstm_cell\", **kwargs):\n super(Conv2DLSTMCell, self).__init__(conv_ndims=2, name=name, **kwargs)","def __init__(self, config, input_shp):\n\n # Run initialization for super class\n super(MyNetwork, self).__init__()\n\n # Store configuration\n self.config = config\n\n # Placeholder for layers\n self.layers = {}\n indim = input_shp[0]\n\n # Retrieve Conv, Act, Pool functions from configurations. We'll use\n # these for our code below.\n if config.conv2d == \"torch\":\n self.Conv2d = nn.Conv2d\n elif config.conv2d == \"custom\":\n self.Conv2d = ConvBlock\n self.Activation = getattr(nn, config.activation)\n self.Pool2d = getattr(nn, config.pool2d)\n self.Linear = nn.Linear\n\n # Resnet Blocks, similar to slide 73 of lecture 21. However, for\n # simplicity, we'll make is slightly different. Note that we used\n # nn.Sequential this time.\n self.convs = nn.Sequential()\n cur_h, cur_w = input_shp[-2:]\n for _i in range(config.num_conv_outer):\n #\n # NOTE THE NEW LAYER ON THESE LINES!\n #\n # We have a dedicated 1x1 layer to get more channels. Note also\n # that this is a pure linear convolution layer.\n outdim = config.nchannel_base * 2 ** _i\n self.convs.add_module(\n \"conv_{}_base\".format(_i), nn.Conv2d(indim, outdim, 1, 1, 0))\n indim = outdim\n for _j in range(config.num_conv_inner):\n # We now use our selected convolution layer. Note that our\n # resnet implementation will have a different call style to\n # vanilla conv2d of torch, so we'll just do an ugly if-else\n # here.\n if config.conv2d == \"torch\":\n self.convs.add_module(\n \"conv_{}_{}\".format(_i, _j),\n self.Conv2d(indim, outdim, config.ksize, 1, 1))\n self.convs.add_module(\n \"act_{}_{}\".format(_i, _j),\n self.Activation())\n cur_h = cur_h - (config.ksize - 1)\n cur_w = cur_w - (config.ksize - 1)\n elif config.conv2d == \"custom\":\n self.convs.add_module(\n \"conv_{}_{}\".format(_i, _j),\n self.Conv2d(indim, outdim, config.ksize, 1, self.Activation))\n self.convs.add_module(\n \"conv_{}_pool\".format(_i), self.Pool2d(2, 2))\n cur_h = cur_h // 2\n cur_w = cur_w // 2\n\n # Final output layer. We'll assume that conv layer outputs are global\n # average pooled\n self.output = nn.Linear(indim, config.num_class)\n\n print(self)","def __init__(self,cell1,site1,cell2,site2,color=None,label=None,linewidth=None,linetype=None):\n self.cell1 = np.array(cell1)\n self.site1 = site1\n self.cell2 = np.array(cell2)\n self.site2 = site2\n coordinate1 = None\n coordinate2 = None\n self.color = color\n self.label = label\n self.linewidth = linewidth\n self.linetype = linetype","def __init__(self, num_units, levels, forget_bias=1.0,\r\n state_is_tuple=True, activation=None, reuse=None, name=None):\r\n super(ON_LSTMCell, self).__init__(_reuse=reuse, name=name)\r\n if not state_is_tuple:\r\n logging.warn(\"%s: Using a concatenated state is slower and will soon be \"\r\n \"deprecated. Use state_is_tuple=True.\", self)\r\n\r\n # Inputs must be 2-dimensional.\r\n self.input_spec = base_layer.InputSpec(ndim=2)\r\n\r\n self._num_units = num_units\r\n self._levels = levels\r\n self._chunk_size = num_units // levels\r\n self._forget_bias = forget_bias\r\n self._state_is_tuple = state_is_tuple\r\n self._activation = activation or math_ops.tanh","def __init__(self, voc_size, layer_size=512, num_layers=3, embedding_layer_size=256, dropout=0.,\n controller_type='gru', **kwargs):\n super(RNN, self).__init__()\n\n self._layer_size = layer_size\n self._embedding_layer_size = embedding_layer_size\n self._num_layers = num_layers\n self._dropout = dropout\n self._controller_type = controller_type\n\n self._embedding = tnn.Embedding(voc_size, self._embedding_layer_size)\n\n if controller_type == 'gru':\n self._layer = tnn.GRU(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\n dropout=self._dropout)\n elif controller_type == 'lstm':\n self._layer = tnn.LSTM(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\n dropout=self._dropout)\n\n self._linear = tnn.Linear(self._layer_size, voc_size)","def get_rnn_cells(self) -> List[mx.rnn.BaseRNNCell]:\n return self.forward_rnn.get_rnn_cells() + self.reverse_rnn.get_rnn_cells()","def __init__(self, cell):\n self._cell = cell\n self._residual_fn = gnmt_residual_fn","def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\n is_training=False, cell_name=\"GRU\", bidirectional=False, swap_memory=False):\n batch_size = tf.shape(X)[0]\n if bidirectional:\n rnn_size /= 2\n\n def get_cell():\n if cell_name == \"GRU\": # GRU\n _cell = rnn_cell.GRUCell(rnn_size)\n elif cell_name == \"LSTM\": # LSTM\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\n else:\n raise ValueError(\"Unrecognized Cell Name: {0}\".format(cell_name))\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\n _initial_state = _cell.zero_state(batch_size, tf.float32)\n return _cell, _initial_state\n\n if bidirectional:\n with tf.variable_scope(\"forward\"):\n cell_fw, initial_state_fw = get_cell()\n with tf.variable_scope(\"backward\"):\n cell_bw, initial_state_bw = get_cell()\n return rnn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, X, sequence_length=seq_len,\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\n else:\n cell, initial_state = get_cell()\n return rnn.dynamic_rnn(\n cell, X, sequence_length=seq_len, initial_state=initial_state,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)","def get_init_cell(batch_size, rnn_size, keep_prob, lstm_layers=2):\n def build_cell(lstm_size, keep_prob):\n cell = tf.nn.rnn.BasicLSTMCell(num_units=lstm_size)\n drop = tf.nn.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob)\n return drop\n\n # 堆栈cell 构建多层隐藏层\n multi_cell = tf.nn.rnn.MultiRNNCell(\n [build_cell(rnn_size, keep_prob) for _ in range(lstm_layers)]\n )\n\n # todo 这里使用tf.identity(final_state同)是为了生成一个op操作符，断点继续训练时候要用。\n initial_state = multi_cell.zero_state(batch_size, tf.float32)\n initial_state1 = tf.identity(initial_state, name='initial_state')\n return multi_cell, initial_state, initial_state1","def __init__(self, num_nodes, num_features, num_timesteps_input,\n num_timesteps_output, gcn_type='normal', hidden_size=64, num_comps=10):\n super(KRNN, self).__init__()\n self.encoders = nn.ModuleList()\n self.decoders = nn.ModuleList()\n self.linears = nn.ModuleList()\n\n self.num_timesteps_output = num_timesteps_output\n\n for r in range(num_comps):\n self.encoders.append(\n nn.GRU(num_features, hidden_size)\n )\n self.decoders.append(\n nn.GRUCell(1, hidden_size)\n )\n self.linears.append(\n nn.Linear(hidden_size, 1)\n )\n\n self.embed = nn.Parameter(torch.FloatTensor(num_nodes, num_comps))\n self.embed.data.normal_()","def test_learnable_cell(self):\n genotype = '0|0|2|0|0|2|0|0 1|0|0|1|1|0|0|0 0|1|0|0|0|0|2|1--1 7'\n search_space = {'dil_conv_3x3', 'dil_conv_5x5', 'dil_conv_7x7',\n 'skip_connect', 'clinc_3x3', 'clinc_7x7', 'avg_pool_3x3', 'max_pool_3x3'}\n\n net = LearnableCell(3, genotype, search_space)\n x = torch.rand((16, 3, 32, 32))\n y = net(x)\n self.assertEqual(list(y.shape), [16, 7, 15, 15])","def SimpleDeepCell():\n cell = Cell()\n node = cell._get_hcell2()\n node[\"celltype\"] = \"mixed\"\n node[\"hash_pattern\"] = {\"*\": \"#\"}\n return cell","def build_gru_cell(num_units, dropout):\n cell = tf.nn.rnn_cell.GRUCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result","def _build_bdrnn_graph(self, hparams):\n\n sample = self.iterator.get_next()\n\n inputs, tgt_outputs, seq_len = sample\n\n # linear projection to state size\n #with tf.variable_scope(\"bdrnn_in\", dtype=tf.float32):\n # inputs = tf.layers.dense(inputs=inputs,\n # units=hparams.input_proj_size,\n # kernel_initializer=tf.glorot_uniform_initializer())\n\n lm_fw_cell = []\n lm_bw_cell = []\n lm_init_state_fw = []\n lm_init_state_bw = []\n if hparams.pretrained:\n with tf.variable_scope(\"lm_rnn\", dtype=tf.float32):\n # create lm\n with tf.variable_scope(\"fw\", dtype=tf.float32):\n lm_fw_cell = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=1,\n mode=self.mode)\n # build the cell so it is in the correct scope\n # NOTE: this is hard coded\n lm_fw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\n lm_init_state_fw = _get_initial_state([lm_fw_cell[0].state_size], tf.shape(inputs)[0], \"lm\")\n with tf.variable_scope(\"bw\", dtype=tf.float32):\n lm_bw_cell = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=1,\n mode=self.mode)\n # NOTE: this is hard coded\n lm_bw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\n lm_init_state_bw = _get_initial_state([lm_bw_cell[0].state_size], tf.shape(inputs)[0], \"lm\")\n\n lm_outputs, lm_states = tf.nn.bidirectional_dynamic_rnn(lm_fw_cell[0],\n lm_bw_cell[0],\n inputs,\n sequence_length=seq_len,\n initial_state_fw=lm_init_state_fw[0],\n initial_state_bw=lm_init_state_bw[0],\n dtype=tf.float32)\n # optionally fix the LM weights\n if hparams.fixed_lm:\n print(\"Fixing pretrained language models.\")\n lm_outputs = tf.stop_gradient(lm_outputs)\n lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1]], axis=-1)\n lm_outputs = tf.layers.dense(lm_outputs,\n 20,\n kernel_initializer=tf.glorot_uniform_initializer())\n lm_outputs = tf.concat([lm_outputs, inputs], axis=-1)\n\n\n #lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1], inputs], axis=-1)\n else:\n lm_outputs = tf.concat(lm_outputs, axis=-1)\n\n\n\n with tf.variable_scope(\"bdrnn\", dtype=tf.float32) as bdrnn_scope:\n # create bdrnn\n with tf.variable_scope(\"fw\", dtype=tf.float32):\n fw_cells = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=hparams.num_layers,\n mode=self.mode\n )\n init_state_fw = _get_initial_state([cell.state_size for cell in fw_cells],\n tf.shape(inputs)[0], \"initial_state_fw\")\n\n with tf.variable_scope(\"bw\", dtype=tf.float32):\n bw_cells = _create_rnn_cell(num_units=hparams.num_units,\n num_layers=hparams.num_layers,\n mode=self.mode,\n )\n\n init_state_bw = _get_initial_state([cell.state_size for cell in bw_cells],\n tf.shape(inputs)[0], \"initial_state_bw\")\n # NOTE: this is commented because the lm cells and states are separated now\n #fw_cells = lm_fw_cell + fw_cells\n #bw_cells = lm_bw_cell + bw_cells\n #init_state_fw = lm_init_state_fw + init_state_fw\n #init_state_bw = lm_init_state_bw + init_state_bw\n\n # run bdrnn\n combined_outputs, output_state_fw, output_state_bw = \\\n tf.contrib.rnn.stack_bidirectional_dynamic_rnn(cells_fw=fw_cells,\n cells_bw=bw_cells,\n inputs=lm_outputs,\n sequence_length=seq_len,\n initial_states_fw=init_state_fw,\n initial_states_bw=init_state_bw,\n dtype=tf.float32,\n scope=bdrnn_scope)\n # outputs is a tuple (output_fw, output_bw)\n # output_fw/output_bw are tensors [batch_size, max_time, cell.output_size]\n # outputs_states is a tuple (output_state_fw, output_state_bw) containing final states for\n # forward and backward rnn\n\n # concatenate the outputs of each direction\n #combined_outputs = tf.concat([outputs[0], outputs[1]], axis=-1)\n\n with tf.variable_scope(\"bdrnn_out\", dtype=tf.float32):\n # dense output layers\n dense1 = tf.layers.dense(inputs=combined_outputs,\n units=hparams.num_dense_units,\n kernel_initializer=tf.glorot_uniform_initializer(),\n activation=tf.nn.relu,\n use_bias=True)\n drop1 = tf.layers.dropout(inputs=dense1,\n rate=hparams.dropout,\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\n dense2 = tf.layers.dense(inputs=drop1,\n units=hparams.num_dense_units,\n kernel_initializer=tf.glorot_uniform_initializer(),\n activation=tf.nn.relu,\n use_bias=True)\n drop2 = tf.layers.dropout(inputs=dense2,\n rate=hparams.dropout,\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\n\n logits = tf.layers.dense(inputs=drop2,\n units=hparams.num_labels,\n use_bias=False)\n\n # mask out entries longer than target sequence length\n mask = tf.sequence_mask(seq_len, dtype=tf.float32)\n\n crossent = tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,\n labels=tgt_outputs,\n name=\"crossent\")\n\n # divide loss by batch_size * mean(seq_len)\n loss = tf.reduce_sum(crossent*mask)/tf.cast(hparams.batch_size, tf.float32)\n\n metrics = []\n update_ops = []\n if self.mode == tf.contrib.learn.ModeKeys.EVAL:\n # mean eval loss\n loss, loss_update = tf.metrics.mean(values=loss)\n\n predictions = tf.argmax(input=logits, axis=-1)\n tgt_labels = tf.argmax(input=tgt_outputs, axis=-1)\n acc, acc_update = tf.metrics.accuracy(predictions=predictions,\n labels=tgt_labels,\n weights=mask)\n # confusion matrix\n targets_flat = tf.reshape(tgt_labels, [-1])\n predictions_flat = tf.reshape(predictions, [-1])\n mask_flat = tf.reshape(mask, [-1])\n cm, cm_update = streaming_confusion_matrix(labels=targets_flat,\n predictions=predictions_flat,\n num_classes=hparams.num_labels,\n weights=mask_flat)\n tf.add_to_collection(\"eval\", cm_summary(cm, hparams.num_labels))\n metrics = [acc, cm]\n update_ops = [loss_update, acc_update, cm_update]\n\n return logits, loss, metrics, update_ops","def __init__(self, sys, rcut, pad):\n self.sys = sys \n self.rcut = rcut \n self.pad = pad\n self.cell_list = CellList(self.sys.box, self.rcut + self.pad)","def __init__(self,\n cell_type: Text = \"lstm\",\n tiers: Dict[int:List[int]] = {1:[1]},\n window_sizes: List[int] = [1],\n strides: List[int] = [1],\n use_dense_layer_output : bool = False,\n dense_layer_args : Dict = {\"units\": None,\n \"activation\":None,#don't change this\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"bias_initializer\":'zeros',\n \"kernel_regularizer\":None,\n \"bias_regularizer\":None,\n \"activity_regularizer\":None,\n \"kernel_constraint\":None,\n \"bias_constraint\":None,\n },\n lstm_cell_args : Dict = {\"activation\":'tanh',\n \"recurrent_activation\":'hard_sigmoid',\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"recurrent_initializer\":'orthogonal',\n \"bias_initializer\":'zeros',\n \"unit_forget_bias\":True,\n \"kernel_regularizer\":None,\n \"recurrent_regularizer\":None,\n \"bias_regularizer\":None,\n \"kernel_constraint\":None,\n \"recurrent_constraint\":None,\n \"bias_constraint\":None,\n \"implementation\":1,\n },\n gru_cell_args : Dict = {\"activation\":'tanh',\n \"recurrent_activation\":'hard_sigmoid',\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"recurrent_initializer\":'orthogonal',\n \"bias_initializer\":'zeros',\n \"kernel_regularizer\":None,\n \"recurrent_regularizer\":None,\n \"bias_regularizer\":None,\n \"kernel_constraint\":None,\n \"recurrent_constraint\":None,\n \"bias_constraint\":None,\n \"implementation\":1,\n \"reset_after\":False,\n },\n adam_opt_args : Dict = {\"learning_rate\": None,\n \"epsilon\": None,\n \"beta_1\": None,\n \"beta_2\": None,\n },\n clip_norm : Optional[float] = None,\n dropout_training = 0,\n recurrent_dropout_training = 0,\n tens_to_log = None,\n checkpoint_path = None,\n predict_batch_size = 30,\n save_checkpoints_steps = 100,\n keep_checkpoint_max = 10,\n save_summary_steps = 10,\n logging_step = 10,\n ):\n \n if (len(tiers)!=len(window_sizes) or len(window_sizes)!=len(strides)):\n raise ValueError(\"Mismatch in network geometry specs. Need number of\"\n \" tiers = number of window size specs, or number of\"\n \" window specs = number of stride specs.\")\n \n \n self.cell_type = cell_type \n self.tiers = tiers, \n self.window_sizes = window_sizes,\n self.strides = strides,\n self.use_dense_layer_output = use_dense_layer_output\n self.dense_layer_args = dense_layer_args,\n self.lstm_cell_args = lstm_cell_args,\n self.gru_cell_args = gru_cell_args,\n self.adam_opt_args = adam_opt_args,\n self.clip_norm = clip_norm,\n self.dropout_training = 0,\n self.recurrent_dropout_training = recurrent_dropout_training,\n self.tens_to_log = tens_to_log,\n self.checkpoint_path = None,\n self.predict_batch_size = 30,\n self.save_checkpoints_steps = 100,\n self.keep_checkpoint_max = 10,\n self.save_summary_steps = 20,\n self.logging_step = 10","def BuildCoreGraph(self):\n # Input ids, with dynamic shape depending on input.\n # Should be shape [batch_size, max_time] and contain integer word indices.\n self.input_w_ = tf.placeholder(tf.int32, [None, None], name=\"w\")\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_], name=\"w\")\n\n # Initial hidden state. You'll need to overwrite this with cell.zero_state\n # once you construct your RNN cell.\n self.initial_h_ = None\n #tf.placeholder(tf.int32, [self.H,], name=\"h_i\")\n #tf.Variable(tf.random_normal([H,]), name=\"h_i\")\n\n # Final hidden state. You'll need to overwrite this with the output from\n # tf.nn.dynamic_rnn so that you can pass it in to the next batch (if\n # applicable).\n self.final_h_ = None\n #tf.placeholder(tf.int32, [self.H,], name=\"h_f\")\n #tf.Variable(tf.random_normal([H,]), name=\"h_f\")\n\n # Output logits, which can be used by loss functions or for prediction.\n # Overwrite this with an actual Tensor of shape\n # [batch_size, max_time, V].\n self.logits_ = None\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_, self.V], name=\"logits\")\n #tf.Variable(tf.random_normal([self.batch_size_, self.max_time_, self.V]), name=\"logits\")\n\n # Should be the same shape as inputs_w_\n self.target_y_ = tf.placeholder(tf.int32, [None, None], name=\"y\")\n #tf.placeholder(tf.int32, [None, None], name=\"y\")\n\n # Replace this with an actual loss function\n self.loss_ = None\n #tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.labels_, logits=self.logits_),0)#don't forget last parameter\n\n # Get dynamic shape info from inputs\n with tf.name_scope(\"batch_size\"):\n self.batch_size_ = tf.shape(self.input_w_)[0]\n with tf.name_scope(\"max_time\"):\n self.max_time_ = tf.shape(self.input_w_)[1]\n\n # Get sequence length from input_w_.\n # TL;DR: pass this to dynamic_rnn.\n # This will be a vector with elements ns[i] = len(input_w_[i])\n # You can override this in feed_dict if you want to have different-length\n # sequences in the same batch, although you shouldn't need to for this\n # assignment.\n self.ns_ = tf.tile([self.max_time_], [self.batch_size_, ], name=\"ns\")#update this for project\n\n #### YOUR CODE HERE ####\n # See hints in instructions!\n\n # Construct embedding layer\n #self.W_in_ = tf.get_variable(\"W_in\", shape=[self.V, self.H], \n #initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n #self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\n \n #self.W_in_ = tf.get_variable(tf.random_uniform([self.V, self.H], -1.0, 1.0), name=\"W_in\")\n #Variable(tf.random_uniform([V, M], -1.0, 1.0), name=\"C\")\n # embedding_lookup gives shape (batch_size, N, M)\n #x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\n \n with tf.name_scope(\"embedding_layer\"):\n self.W_in_ = tf.get_variable(\"W_in\", shape=[self.V, self.H], \n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\n\n\n\n # Construct RNN/LSTM cell and recurrent layer.\n with tf.name_scope(\"recurrent_layer\"):\n self.cell_ = MakeFancyRNNCell(self.H, self.dropout_keep_prob_, self.num_layers)\n self.initial_h_ = self.cell_.zero_state(self.batch_size_,tf.float32)\n self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=self.x_, \n sequence_length=self.ns_, initial_state=self.initial_h_,\n dtype=tf.float32)\n #print(self.outputs_.get_shape())\n #self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=x_, \n #sequence_length=self.ns_, initial_state=self.initial_h_,\n #dtype=tf.float32)\n \n #W1_ = tf.Variable(tf.random_normal([N*M,H]), name=\"W1\")\n #b1_ = tf.Variable(tf.zeros([H,], dtype=tf.float32), name=\"b1\")\n #h_ = tf.tanh(tf.matmul(x_, W1_) + b1_, name=\"h\")\n\n\n\n\n\n # Softmax output layer, over vocabulary. Just compute logits_ here.\n # Hint: the matmul3d function will be useful here; it's a drop-in\n # replacement for tf.matmul that will handle the \"time\" dimension\n # properly.\n with tf.name_scope(\"softmax_output_layer\"):\n self.W_out_ = tf.get_variable(\"W_out\", shape=[self.H, self.V], \n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n #tf.get_variable(tf.random_uniform([self.H, self.V], -1.0, 1.0), name=\"W_out\")\n\n self.b_out_ = tf.get_variable(\"b_out\", shape=[self.V,], \n initializer = tf.zeros_initializer())\n #self.b_out_ = tf.get_variable(\"b_out\", shape=[self.V,], initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n #tf.get_variable(tf.random_uniform([self.V,], -1.0, 1.0), name=\"b_out\")\n\n self.logits_ = tf.add(matmul3d(self.outputs_, self.W_out_), self.b_out_, name=\"logits\")\n #print(self.logits_.get_shape())\n\n\n\n # Loss computation (true loss, for prediction)\n with tf.name_scope(\"loss_computation\"):\n per_example_loss_ = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.target_y_, \n logits=self.logits_, \n name=\"per_example_loss\")\n self.loss_ = tf.reduce_mean(per_example_loss_, name=\"loss\")\n\n\n\n #### END(YOUR CODE) ####"],"string":"[\n \"def create_rnn_cell(num_units,\\n num_layers,\\n num_residual_layers,\\n dropout,\\n mode,\\n num_gpus,\\n base_gpu=0,\\n single_cell_fn=None,\\n all_layer_outputs=False):\\n cell_list = _cell_list(\\n num_units=num_units,\\n num_layers=num_layers,\\n num_residual_layers=num_residual_layers,\\n dropout=dropout,\\n mode=mode,\\n num_gpus=num_gpus,\\n base_gpu=base_gpu,\\n single_cell_fn=single_cell_fn)\\n\\n if len(cell_list) == 1: # Single layer.\\n return cell_list[0]\\n else: # Multi layers\\n print(all_layer_outputs, \\\"all_layer_outputs\\\")\\n\\n if all_layer_outputs:\\n return MultiRNNCell(cell_list)\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)\",\n \"def build_multi_rnn(cells):\\n return tf.nn.rnn_cell.MultiRNNCell(cells)\",\n \"def __init__(self, rnn_cell, batch_size,\\n input_size, num_outputs):\\n super().__init__(name='RNNCellStateModel')\\n self._rnn_cell = rnn_cell\\n self._batch_size = batch_size\\n self._input_size = input_size\\n self._num_outputs = num_outputs\",\n \"def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\\n if is_train:\\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\\n return cell\",\n \"def build_rnn_cell(type, num_units, dropout):\\n cell = tf.nn.rnn_cell.BasicRNNCell(num_units)\\n if dropout:\\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\\n output_keep_prob=1-dropout)\\n return result\",\n \"def MakeFancyRNNCell(H, keep_prob, num_layers=1):\\n cells = []\\n for _ in range(num_layers):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cells.append(cell)\\n return tf.nn.rnn_cell.MultiRNNCell(cells)\",\n \"def _create_rnn_cells(self, is_list=False):\\n\\n stacked_rnn = []\\n for _ in range(self.num_layers):\\n single_cell = self._rnn_single_cell()\\n stacked_rnn.append(single_cell)\\n\\n if is_list:\\n return stacked_rnn\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(\\n cells=stacked_rnn,\\n state_is_tuple=True)\",\n \"def __call__(self, inputs, state, scope=None, *args, **kwargs):\\r\\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\\r\\n # Instead, it is up to subclasses to provide a proper build\\r\\n # method. See the class docstring for more details.\\r\\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\\r\\n *args, **kwargs)\",\n \"def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\\n if layer_type == \\\"layernorm_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\\n else:\\n if layer_type == \\\"lstm\\\":\\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\\n elif layer_type == \\\"gru\\\":\\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_gru\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\\n else:\\n raise ValueError(\\\"Error: not supported rnn type:{}\\\".format(layer_type))\\n\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, output_keep_prob=dropout_keep_prob)\\n return cell\",\n \"def build_rnn(cell, inputs):\\n #_,initial_state = get_init_cell(batch_size, rnn_size)\\n \\n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name='final_state')\\n\\n return (output, final_state)\",\n \"def __init__(self,\\n num_units,\\n num_dims=1,\\n input_dims=None,\\n output_dims=None,\\n priority_dims=None,\\n non_recurrent_dims=None,\\n tied=False,\\n cell_fn=None,\\n non_recurrent_fn=None,\\n state_is_tuple=True,\\n output_is_tuple=True):\\n if not state_is_tuple:\\n logging.warning('%s: Using a concatenated state is slower and will '\\n 'soon be deprecated. Use state_is_tuple=True.', self)\\n if not output_is_tuple:\\n logging.warning('%s: Using a concatenated output is slower and will '\\n 'soon be deprecated. Use output_is_tuple=True.', self)\\n\\n if num_dims < 1:\\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\\n\\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\\n priority_dims, non_recurrent_dims,\\n non_recurrent_fn or nn.relu, tied,\\n num_units)\\n\\n self._state_is_tuple = state_is_tuple\\n self._output_is_tuple = output_is_tuple\\n\\n if cell_fn is None:\\n my_cell_fn = functools.partial(\\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\\n else:\\n my_cell_fn = lambda: cell_fn(num_units)\\n if tied:\\n self._cells = [my_cell_fn()] * num_dims\\n else:\\n self._cells = [my_cell_fn() for _ in range(num_dims)]\\n if not isinstance(self._cells[0], rnn.RNNCell):\\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\\n type(self._cells[0]))\\n\\n if self._output_is_tuple:\\n self._output_size = tuple(self._cells[0].output_size\\n for _ in self._config.outputs)\\n else:\\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\\n\\n if self._state_is_tuple:\\n self._state_size = tuple(self._cells[0].state_size\\n for _ in self._config.recurrents)\\n else:\\n self._state_size = self._cell_state_size() * len(self._config.recurrents)\",\n \"def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\\n readout_init, readout_apply = stax.Dense(num_outputs)\\n\\n def init_fun(key, input_shape):\\n \\\"\\\"\\\"Initialize the components of the RNN.\\n\\n Args:\\n key: Jax PRNGkey used to initialize the parameters.\\n input_shape: tuple representing the input shape, should be\\n (batch_size, sequence_length).\\n\\n Returns:\\n shapes: set of tuples representing the shapes after applying\\n the Embedding, RNN Cell, and Readout layers.\\n network_params: tuple of network parameters, containing the\\n embedding, RNN cell, and readout parameters.\\n \\\"\\\"\\\"\\n\\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\\n\\n # Initialize the Embedding for the input tokens.\\n emb_shape, emb_params = emb_init(emb_key, input_shape)\\n\\n # The cell is defined for a single update step, which is why we ignore\\n # the sequence dimension (emb_shape[1]) here.\\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\\n\\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\\n\\n shapes = (emb_shape, rnn_shape, output_shape)\\n network_params = (emb_params, rnn_params, readout_params)\\n\\n return shapes, network_params\\n\\n def apply_fun(network_params, tokens):\\n \\\"\\\"\\\"Applies the RNN on a batch of input sequences.\\n\\n Args:\\n network_params: tuple of network parameters (see init_fun).\\n tokens: batch of inputs, with shape (batch_size, sequence_length).\\n\\n Returns:\\n outputs: network outputs, at every step along the sequence.\\n \\\"\\\"\\\"\\n emb_params, rnn_params, readout_params = network_params\\n\\n # Apply the embedding.\\n inputs = emb_apply(emb_params, tokens)\\n\\n # Run the RNN.\\n initial_states = cell.get_initial_state(rnn_params,\\n batch_size=tokens.shape[0])\\n return unroll.unroll_rnn(initial_states, inputs,\\n functools.partial(cell.batch_apply, rnn_params),\\n functools.partial(readout_apply, readout_params))\\n\\n return init_fun, apply_fun, emb_apply, readout_apply\",\n \"def make_cell(self, unit_type, num_units, forget_bias, dropout,\\n mode, residual_connection=False):\\n\\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\\n dropout = dropout if mode == tf.contrib.learn.ModeKeys.TRAIN else 0.0\\n\\n # Cell Type\\n if unit_type == \\\"lstm\\\":\\n cell = tf.contrib.rnn.BasicLSTMCell(\\n num_units,\\n forget_bias=forget_bias)\\n elif unit_type == \\\"gru\\\":\\n cell = tf.contrib.rnn.GRUCell(num_units)\\n elif unit_type == \\\"layer_norm_lstm\\\":\\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units,\\n forget_bias=forget_bias,\\n layer_norm=True)\\n else:\\n raise ValueError(\\\"Unknown unit type %s!\\\" % unit_type)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n cell = tf.contrib.rnn.DropoutWrapper(\\n cell=cell, input_keep_prob=(1.0 - dropout))\\n\\n # Residual\\n if residual_connection:\\n cell = tf.contrib.rnn.ResidualWrapper(cell)\\n\\n return cell\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(RCRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = ResidualCNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=2,\\n )\\n #self.rnn2 = BidirectionalGRU(\\n # n_in=nb_in*2,\\n # n_hidden=n_RNN_cell,\\n # dropout=dropout_recurrent,\\n # num_layers=1,\\n #)\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.relu = nn.ReLU()\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def _create_rnn_cell(num_units, num_layers, mode):\\n\\n cell_list = []\\n for i in range(num_layers):\\n single_cell = STLSTMCell(name=\\\"stlstm\\\",\\n num_units=num_units,\\n st_activation=tf.nn.relu,\\n st_kernel_initializer=tf.glorot_uniform_initializer(),\\n st_num_layers=2,\\n st_residual=True)\\n cell_list.append(single_cell)\\n\\n return cell_list\",\n \"def constructCell():\\n\\t\\tself.weightGenerate()\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(CRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = CNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=n_layers_RNN,\\n )\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def __init__(self, cell, attn_inputs, \\n attn_size, attn_vec_size,\\n output_size=None, input_size=None, \\n state_is_tuple=True, attn_masks=None,\\n merge_output_attn='linear',\\n reuse=None):\\n if not isinstance(cell, rnn.RNNCell):\\n raise TypeError(\\\"The parameter cell is not RNNCell.\\\")\\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\\n raise ValueError(\\\"Cell returns tuple of states, but the flag \\\"\\n \\\"state_is_tuple is not set. State size is: %s\\\"\\n % str(cell.state_size))\\n if not state_is_tuple:\\n logging.warn(\\n \\\"%s: Using a concatenated state is slower and will soon be \\\"\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\n\\n self._state_is_tuple = state_is_tuple\\n\\n if not state_is_tuple:\\n raise NotImplementedError\\n\\n self._cell = cell\\n self._input_size = input_size\\n self._output_size = output_size\\n if output_size is None:\\n self._output_size = cell.output_size\\n self._attn_size = attn_size\\n self._reuse = reuse\\n self._attn_inputs = attn_inputs\\n self._attn_vec_size = attn_vec_size\\n self.attn_masks = attn_masks\\n self.merge_output_attn = merge_output_attn\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\\n if attn_len and not cells:\\n # Add attention wrapper to first layer.\\n cell = tf.contrib.rnn.AttentionCellWrapper(\\n cell, attn_len, state_is_tuple=True)\\n cell = tf.contrib.rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return tf.contrib.rnn.MultiRNNCell(cells)\",\n \"def __init__(self, input_size, hidden_size, output_size, model=\\\"gru\\\", n_layers=1):\\n \\n super(CharRNN, self).__init__()\\n\\n self.input_size = input_size\\n self.hidden_size = hidden_size\\n self.output_size = output_size\\n self.n_layers = n_layers\\n\\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\\n \\n self.model = model\\n if model.lower() == \\\"lstm\\\":\\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\\n else: # model is GRU\\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\\n\\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer\",\n \"def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\\n is_batch_norm, is_bidirectional):\\n if is_batch_norm:\\n input_data = tf.keras.layers.BatchNormalization(\\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\\n rnn_layer = rnn_cell(\\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\\n name=\\\"rnn_{}\\\".format(layer_id))\\n if is_bidirectional:\\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\\\"sum\\\")\\n\\n return rnn_layer(input_data)\",\n \"def build_rnn(cell, inputs):\\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name=\\\"final_state\\\")\\n\\n return outputs, final_state\",\n \"def get_init_cell(batch_size, rnn_size):\\n\\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\\n num_of_layers = 3\\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name='initial_state')\\n \\n return (cell, initial_state)\",\n \"def _initialize_gru_cell(self, num_units):\\n return gru_cell.LayerNormGRUCell(\\n num_units,\\n w_initializer=self.uniform_initializer,\\n u_initializer=random_orthonormal_initializer,\\n b_initializer=tf.constant_initializer(0.0))\",\n \"def custom_rnn(cell, inputs, initial_state=None, dtype=None,\\r\\n sequence_length=None, scope=None):\\r\\n\\r\\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\\r\\n raise TypeError(\\\"cell must be an instance of RNNCell\\\")\\r\\n if not nest.is_sequence(inputs):\\r\\n raise TypeError(\\\"inputs must be a sequence\\\")\\r\\n if not inputs:\\r\\n raise ValueError(\\\"inputs must not be empty\\\")\\r\\n\\r\\n outputs = []\\r\\n states = []\\r\\n # Create a new scope in which the caching device is either\\r\\n # determined by the parent scope, or is set to place the cached\\r\\n # Variable using the same placement as for the rest of the RNN.\\r\\n with vs.variable_scope(scope or \\\"RNN\\\") as varscope:\\r\\n if varscope.caching_device is None:\\r\\n varscope.set_caching_device(lambda op: op.device)\\r\\n\\r\\n # Obtain the first sequence of the input\\r\\n first_input = inputs\\r\\n while nest.is_sequence(first_input):\\r\\n first_input = first_input[0]\\r\\n\\r\\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\\r\\n # TODO(lukaszkaiser): remove EmbeddingWrapper\\r\\n if first_input.get_shape().ndims != 1:\\r\\n\\r\\n input_shape = first_input.get_shape().with_rank_at_least(2)\\r\\n fixed_batch_size = input_shape[0]\\r\\n\\r\\n flat_inputs = nest.flatten(inputs)\\r\\n for flat_input in flat_inputs:\\r\\n input_shape = flat_input.get_shape().with_rank_at_least(2)\\r\\n batch_size, input_size = input_shape[0], input_shape[1:]\\r\\n fixed_batch_size.merge_with(batch_size)\\r\\n for i, size in enumerate(input_size):\\r\\n if size.value is None:\\r\\n raise ValueError(\\r\\n \\\"Input size (dimension %d of inputs) must be accessible via \\\"\\r\\n \\\"shape inference, but saw value None.\\\" % i)\\r\\n else:\\r\\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\\r\\n\\r\\n if fixed_batch_size.value:\\r\\n batch_size = fixed_batch_size.value\\r\\n else:\\r\\n batch_size = array_ops.shape(first_input)[0]\\r\\n if initial_state is not None:\\r\\n state = initial_state\\r\\n else:\\r\\n if not dtype:\\r\\n raise ValueError(\\\"If no initial_state is provided, \\\"\\r\\n \\\"dtype must be specified\\\")\\r\\n state = cell.zero_state(batch_size, dtype)\\r\\n\\r\\n if sequence_length is not None: # Prepare variables\\r\\n sequence_length = ops.convert_to_tensor(\\r\\n sequence_length, name=\\\"sequence_length\\\")\\r\\n if sequence_length.get_shape().ndims not in (None, 1):\\r\\n raise ValueError(\\r\\n \\\"sequence_length must be a vector of length batch_size\\\")\\r\\n def _create_zero_output(output_size):\\r\\n # convert int to TensorShape if necessary\\r\\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\\r\\n output = array_ops.zeros(\\r\\n array_ops.pack(size), _infer_state_dtype(dtype, state))\\r\\n shape = _state_size_with_prefix(\\r\\n output_size, prefix=[fixed_batch_size.value])\\r\\n output.set_shape(tensor_shape.TensorShape(shape))\\r\\n return output\\r\\n\\r\\n output_size = cell.output_size\\r\\n flat_output_size = nest.flatten(output_size)\\r\\n flat_zero_output = tuple(\\r\\n _create_zero_output(size) for size in flat_output_size)\\r\\n zero_output = nest.pack_sequence_as(structure=output_size,\\r\\n flat_sequence=flat_zero_output)\\r\\n\\r\\n sequence_length = math_ops.to_int32(sequence_length)\\r\\n min_sequence_length = math_ops.reduce_min(sequence_length)\\r\\n max_sequence_length = math_ops.reduce_max(sequence_length)\\r\\n\\r\\n for time, input_ in enumerate(inputs):\\r\\n if time > 0: varscope.reuse_variables()\\r\\n # pylint: disable=cell-var-from-loop\\r\\n call_cell = lambda: cell(input_, state)\\r\\n # pylint: enable=cell-var-from-loop\\r\\n if sequence_length is not None:\\r\\n (output, state) = _rnn_step(\\r\\n time=time,\\r\\n sequence_length=sequence_length,\\r\\n min_sequence_length=min_sequence_length,\\r\\n max_sequence_length=max_sequence_length,\\r\\n zero_output=zero_output,\\r\\n state=state,\\r\\n call_cell=call_cell,\\r\\n state_size=cell.state_size)\\r\\n else:\\r\\n (output, state) = call_cell()\\r\\n\\r\\n outputs.append(output)\\r\\n states.append(state)\\r\\n\\r\\n return (outputs, state, states)\",\n \"def __init__(self, context, problem, update_rate=1, debug=False):\\n tf.keras.layers.AbstractRNNCell.__init__(self)\\n self.context = context\\n self.problem = problem\\n\\n if hasattr(self.context, 'scale'):\\n self.scale = self.context.scale\\n else:\\n self.scale = 1\\n\\n self.debug = debug\\n\\n # shape related information\\n self.batch_size = self.context.batch_size\\n self.dim_x = self.context.dim_x\\n self.dim_z = self.context.dim_z\\n self.dim_u = self.context.dim_u\\n\\n # rate at which observations are taken into account\\n self.update_rate = tf.ones([], dtype=tf.float32) * update_rate\\n\\n self.filter_layers = []\",\n \"def _single_cell(num_units,\\n dropout,\\n mode,\\n residual_connection=False,\\n device_str=None):\\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\\n\\n # Cell Type\\n utils.print_out(\\\" GRU\\\", new_line=False)\\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n utils.print_out(\\n \\\" %s, dropout=%g \\\" % (type(single_cell).__name__, dropout),\\n new_line=False)\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\\n utils.print_out(\\\" %s\\\" % type(single_cell).__name__, new_line=False)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\\n utils.print_out(\\n \\\" %s, device=%s\\\" % (type(single_cell).__name__, device_str),\\n new_line=False)\\n\\n return single_cell\",\n \"def resnet10(shortcut_type, num_classes, in_channels):\\n model = ResNet(BasicBlock, [1, 1, 1, 1], shortcut_type, num_classes, in_channels)\\n return model\",\n \"def create_model():\\n\\n class Net(nn.Cell):\\n def construct(self, x, y):\\n return x\\n\\n net = Net()\\n model_simple = Model(net)\\n\\n return model_simple\",\n \"def __init__(self, cell_index, stimulus_type, loss='poisson_loss', optimizer='sgd',\\n weight_init='glorot_normal', l2_reg=0., mean_adapt=False):\\n\\n self.stim_shape = (40, 50, 50)\\n\\n # build the model (flatten the input, followed by a dense layer and\\n # softplus activation)\\n with notify('Building LN model'):\\n self.model = Sequential()\\n self.model.add(Flatten(input_shape=self.stim_shape))\\n self.model.add(Dense(1, activation='softplus', init=weight_init,\\n W_regularizer=l2(l2_reg)))\\n\\n # save architecture string (for markdown file)\\n self.architecture = '\\\\n'.join(['l2 regularization: {}'.format(l2_reg),\\n 'stimulus shape: {}'.format(self.stim_shape),\\n 'weight initialization: {}'.format(weight_init)])\\n\\n # compile\\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embedding = get_embed(input_data, vocab_size, rnn_size)\\n outputs, final_state = build_rnn(cell, embedding)\\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\\n\\n return logits, final_state\",\n \"def rnn_cell(hprev, zt, name=None, reuse=False):\\n nin = zt.shape[-1].value\\n nout = hprev.shape[-1].value\\n with tf.variable_scope(name, default_name=\\\"rnn\\\", values=[hprev, zt], reuse=reuse):\\n wz = get_variable_wrap(\\\"kernel/input\\\", [nin, nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n wh = get_variable_wrap(\\\"kernel/hidden\\\", [nout, nout],dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n bh = get_variable_wrap(\\\"bias\\\", [nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n \\n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = rnn.LSTMBlockCell(layer_size)\\n cell = rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return rnn.MultiRNNCell(cells)\",\n \"def get_init_cell(batch_size, rnn_size):\\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name=\\\"initial_state\\\")\\n\\n return cell, initial_state\",\n \"def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\\n # todo 1、获取嵌入层的输出\\n embed = get_embed(input_data, vocab_size, embed_dim)\\n # todo-2、获取 隐藏层的输出\\n rnn_outputs, final_state, final_state1 = build_rnn(\\n cell, embed, initial_state=initial_state)\\n # 3、构建全连接，获取logits\\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\\n # [N, n-steps, num_classes]\\n return logits, final_state, final_state1\",\n \"def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\\n residual_connection=False, device_str=None):\\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\\n dropout = dropout if mode == \\\"train\\\" else 0.0\\n # Cell Type\\n if unit_type == \\\"lstm\\\":\\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\\n\\n elif unit_type == \\\"gru\\\":\\n single_cell = tf.contrib.rnn.GRUCell(num_units)\\n\\n elif unit_type == \\\"layer_norm_lstm\\\":\\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units,layer_norm=True)\\n else:\\n raise ValueError(\\\"Unknown unit type %s!\\\" % unit_type)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.contrib.rnn.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\\n\\n return single_cell\",\n \"def __init__(self, layers, rnnType, seqLength=128, outputDim=None, activation=None, dropout=0.0):\\n model = utils.buildRNN(layers, rnnType, dropout)\\n super().__init__(torch.nn.Sequential(model), nnType='rnn')\\n \\n self.seqLength = seqLength\\n if outputDim is not None:\\n self.update(DNN([layers[-1]*seqLength, outputDim], [activation]).model)\\n self.nnType = 'rnn-mlp'\",\n \"def __init__(self,\\n shape,\\n kernel,\\n depth,\\n use_peepholes=False,\\n cell_clip=None,\\n initializer=None,\\n forget_bias=1.0,\\n activation=None,\\n normalize=None,\\n dropout=None,\\n reuse=None):\\n super(ConvLSTMCell, self).__init__(_reuse=reuse)\\n\\n tf_shape = tf.TensorShape(shape + [depth])\\n self._output_size = tf_shape\\n self._state_size = tf.nn.rnn_cell.LSTMStateTuple(tf_shape, tf_shape)\\n\\n self._kernel = kernel\\n self._depth = depth\\n self._use_peepholes = use_peepholes\\n self._cell_clip = cell_clip\\n self._initializer = initializer\\n self._forget_bias = forget_bias\\n self._activation = activation or tf.nn.tanh\\n self._normalize = normalize\\n self._dropout = dropout\\n\\n self._w_conv = None\\n if self._use_peepholes:\\n self._w_f_diag = None\\n self._w_i_diag = None\\n self._w_o_diag = None\",\n \"def __init__(self, num_units,\\n use_peepholes=False, cell_clip=None,\\n initializer=None, num_proj=None, proj_clip=None,\\n num_unit_shards=None, num_proj_shards=None,\\n forget_bias=1.0, state_is_tuple=False,\\n activation=None, trainable=None, name=None, dtype=None, residual_connection=False, **kwargs):\\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\\n if not state_is_tuple:\\n logging.warn(\\\"%s: Using a concatenated state is slower and will soon be \\\"\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\n if num_unit_shards is not None or num_proj_shards is not None:\\n logging.warn(\\n \\\"%s: The num_unit_shards and proj_unit_shards parameters are \\\"\\n \\\"depreca ted and will be removed in Jan 2017. \\\"\\n \\\"Use a variable scope with a partitioner instead.\\\", self)\\n if context.executing_eagerly() and context.num_gpus() > 0:\\n logging.warn(\\\"%s: Note that this cell is not optimized for performance. \\\"\\n \\\"Please use tf.contrib.cudnn_rnn.CudnnLSTM for better \\\"\\n \\\"performance on GPU.\\\", self)\\n self._num_units = num_units\\n self._use_peepholes = use_peepholes\\n self._cell_clip = cell_clip\\n self._initializer = initializers.get(initializer)\\n self._num_proj = num_proj\\n self._proj_clip = proj_clip\\n self._num_unit_shards = num_unit_shards\\n self._num_proj_shards = num_proj_shards\\n self._forget_bias = forget_bias\\n self._state_is_tuple = state_is_tuple\\n self.residual_connection = residual_connection\\n self._kernel = None\\n self._bias = None\\n self._w_f_diag = None\\n self._w_i_diag = None\\n self._w_o_diag = None\\n self._proj_kernel = None\\n if activation:\\n self._activation = activations.get(activation)\\n else:\\n self._activation = math_ops.tanh\\n\\n if num_proj:\\n self.state_size = [num_proj, num_units]\\n self._output_size = num_proj\\n\\n else:\\n self._state_size = [num_units, num_units]\\n self._output_size = num_units\",\n \"def __init__(self, num_nodes, h_dim, out_dim, num_rels,\\n num_bases=-1, num_hidden_layers=1, dropout=0.5, bias=False):\\n super(RGCN, self).__init__()\\n self.num_nodes = num_nodes\\n self.h_dim = h_dim\\n self.out_dim = out_dim\\n self.num_rels = num_rels\\n self.num_bases = num_bases\\n self.num_hidden_layers = num_hidden_layers\\n self.dropout = dropout\\n self.bias = bias\\n\\n self.layers = nn.ModuleList()\\n # create rgcn layers\\n self.build_model()\",\n \"def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\\n if rnn_type.endswith('lstm'):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n elif rnn_type.endswith('gru'):\\n cell = tc.rnn.GRUCell(num_units=hidden_size)\\n elif rnn_type.endswith('rnn'):\\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\\n else:\\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n if layer_num > 1:\\n cell = tc.rnn.MultiRNNCell([cell] * layer_num, state_is_tuple=True)\\n return cell\",\n \"def __init__(self,\\n num_units,\\n use_peepholes=False,\\n cell_clip=None,\\n initializer=None,\\n num_proj=None,\\n proj_clip=None,\\n num_unit_shards=None,\\n num_proj_shards=None,\\n forget_bias=1.0,\\n state_is_tuple=True,\\n activation=None,\\n reuse=None):\\n super(MaskedLSTMCell, self).__init__(\\n num_units,\\n use_peepholes=use_peepholes,\\n cell_clip=cell_clip,\\n initializer=initializer,\\n num_proj=num_proj,\\n proj_clip=proj_clip,\\n num_unit_shards=num_unit_shards,\\n num_proj_shards=num_proj_shards,\\n forget_bias=forget_bias,\\n state_is_tuple=state_is_tuple,\\n activation=activation,\\n reuse=reuse)\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embed = get_embed(input_data, vocab_size, embed_dim) \\n output, final_state = build_rnn(cell, embed)\\n \\n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\\n #final_state = tf.identity(final_state, name='final_state') \\n return logits, final_state\",\n \"def __init__(self,\\n layer,\\n train_batch=1,\\n query_batch=1,\\n num_steps=1,\\n init_lr=0.2,\\n initializer=tf.contrib.layers.xavier_initializer(),\\n loss=batched_mse,\\n flatten_output=True,\\n reuse=None):\\n super(Cell, self).__init__(_reuse=reuse)\\n self._layer = layer\\n self._train_batch = train_batch\\n self._query_batch = query_batch\\n self._num_steps = num_steps\\n self._init_lr = init_lr\\n self._initializer = initializer\\n self._loss = loss\\n self._flatten_output = flatten_output\",\n \"def single_cell(\\n cell_class,\\n cell_params,\\n dp_input_keep_prob=1.0,\\n dp_output_keep_prob=1.0,\\n recurrent_keep_prob=1.0,\\n input_weight_keep_prob=1.0,\\n recurrent_weight_keep_prob=1.0,\\n weight_variational=False,\\n dropout_seed=None,\\n zoneout_prob=0.,\\n training=True,\\n residual_connections=False,\\n awd_initializer=False,\\n variational_recurrent=False, # in case they want to use DropoutWrapper\\n dtype=None,\\n):\\n if awd_initializer:\\n val = 1.0/math.sqrt(cell_params['num_units'])\\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\\n if recurrent_keep_prob < 1.0:\\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\\n if input_weight_keep_prob < 1.0:\\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\\n if recurrent_weight_keep_prob < 1.0:\\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\\n if weight_variational:\\n cell_params['weight_variational'] = weight_variational # which is basically True\\n if dropout_seed:\\n cell_params['dropout_seed'] = dropout_seed\\n\\n\\n cell = cell_class(**cell_params)\\n if residual_connections:\\n cell = ResidualWrapper(cell)\\n if zoneout_prob > 0. and (\\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\\n ):\\n raise ValueError(\\n \\\"Currently applying both dropout and zoneout on the same cell.\\\"\\n \\\"This is currently not supported.\\\"\\n )\\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\\n cell = DropoutWrapper(\\n cell,\\n input_keep_prob=dp_input_keep_prob,\\n output_keep_prob=dp_output_keep_prob,\\n variational_recurrent=variational_recurrent,\\n dtype=dtype,\\n seed=dropout_seed\\n )\\n if zoneout_prob > 0.:\\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\\n return cell\",\n \"def _rnn_cells(self) -> RNNCellTuple:\\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))\",\n \"def init_gru(rnn):\\n\\n def _concat_init(tensor, init_funcs):\\n (length, fan_out) = tensor.shape\\n fan_in = length // len(init_funcs)\\n\\n for (i, init_func) in enumerate(init_funcs):\\n init_func(tensor[i * fan_in: (i + 1) * fan_in, :])\\n\\n def _inner_uniform(tensor):\\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\\n\\n for i in range(rnn.num_layers):\\n _concat_init(\\n getattr(rnn, 'weight_ih_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, _inner_uniform]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\\n\\n _concat_init(\\n getattr(rnn, 'weight_hh_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)\",\n \"def lstm_cell():\\n if 'reuse' in inspect.getargspec(\\n tf.contrib.rnn.BasicLSTMCell.__init__).args:\\n return tf.contrib.rnn.BasicLSTMCell(\\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True,\\n reuse=tf.get_variable_scope().reuse)\\n else:\\n return tf.contrib.rnn.BasicLSTMCell(\\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True)\",\n \"def init_gru(rnn):\\n \\n def _concat_init(tensor, init_funcs):\\n (length, fan_out) = tensor.shape\\n fan_in = length // len(init_funcs)\\n \\n for (i, init_func) in enumerate(init_funcs):\\n init_func(tensor[i * fan_in : (i + 1) * fan_in, :])\\n \\n def _inner_uniform(tensor):\\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\\n \\n for i in range(rnn.num_layers):\\n _concat_init(\\n getattr(rnn, 'weight_ih_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, _inner_uniform]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\\n\\n _concat_init(\\n getattr(rnn, 'weight_hh_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)\",\n \"def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\\n\\t\\treturn _mh.create_rnn_cell(\\n\\t\\t\\tunit_type=hparams.unit_type,\\n\\t\\t\\tnum_units=self.num_units,\\n\\t\\t\\tnum_layers=num_layers,\\n\\t\\t\\tnum_residual_layers=num_residual_layers,\\n\\t\\t\\tforget_bias=hparams.forget_bias,\\n\\t\\t\\tdropout=hparams.dropout,\\n\\t\\t\\tmode=self.mode)\",\n \"def setup_rnn_model(default_ctx,\\n num_lstm_layer, \\n num_hidden,\\n batch_size,\\n initializer,\\n group2ctx=None, concat_decode=True,\\n use_loss=False, buckets=None):\\n max_len = n_steps\\n max_rnn_exec = None\\n rnn_sym = lstm_unroll(num_lstm_layer=num_lstm_layer,\\n num_hidden=num_hidden)\\n arg_names = rnn_sym.list_arguments()\\n internals = rnn_sym.get_internals()\\n\\n input_shapes = {}\\n for name in arg_names:\\n if name.endswith(\\\"init_c\\\") or name.endswith(\\\"init_h\\\"):\\n input_shapes[name] = (batch_size, num_hidden)\\n elif name.endswith(\\\"data\\\"):\\n input_shapes[name] = (batch_size,MAX_LEN)\\n elif name == \\\"labels\\\":\\n input_shapes[name] = (batch_size,MAX_LEN)\\n elif name.endswith(\\\"label\\\"):\\n input_shapes[name] = (batch_size, )\\n else:\\n pass\\n\\n arg_shape, out_shape, aux_shape = rnn_sym.infer_shape(**input_shapes)\\n # bind arrays\\n arg_arrays = []\\n args_grad = {}\\n for shape, name in zip(arg_shape, arg_names):\\n group = internals[name].attr(\\\"ctx_group\\\")\\n ctx = group2ctx[group] if group is not None else default_ctx\\n arg_arrays.append(mx.nd.zeros(shape, ctx))\\n if is_param_name(name):\\n args_grad[name] = mx.nd.zeros(shape, ctx)\\n if not name.startswith(\\\"t\\\"):\\n print(\\\"%s group=%s, ctx=%s\\\" % (name, group, str(ctx)))\\n \\n #bind with shared executor\\n rnn_exec = None\\n rnn_exec = rnn_sym.bind(default_ctx, args=arg_arrays,\\n args_grad=args_grad,\\n grad_req=\\\"add\\\", group2ctx=group2ctx)\\n max_rnn_exec = rnn_exec\\n \\n\\n param_blocks = []\\n arg_dict = dict(zip(arg_names, rnn_exec.arg_arrays))\\n for i, name in enumerate(arg_names):\\n if is_param_name(name):\\n initializer(name, arg_dict[name])\\n param_blocks.append((i, arg_dict[name], args_grad[name], name))\\n else:\\n assert name not in args_grad\\n\\n out_dict = dict(zip(rnn_sym.list_outputs(), rnn_exec.outputs))\\n\\n init_states = [LSTMState(c=arg_dict[\\\"l%d_init_c\\\" % i],\\n h=arg_dict[\\\"l%d_init_h\\\" % i]) for i in range(num_lstm_layer)]\\n\\n seq_data = rnn_exec.arg_dict[\\\"data\\\"]\\n # we don't need to store the last state \\n last_states = None\\n\\n seq_outputs = [out_dict[\\\"sm_output\\\"]]\\n seq_labels = [rnn_exec.arg_dict[\\\"labels\\\"]]\\n\\n model = LSTMModel(rnn_exec=rnn_exec, symbol=rnn_sym,\\n init_states=init_states, last_states=last_states,\\n seq_data=seq_data, seq_labels=seq_labels, seq_outputs=seq_outputs,\\n param_blocks=param_blocks)\\n return model\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):\\n super(ModGRUCell, self).__init__()\\n\\n self.height, self.width = input_size\\n self.input_dim = input_dim\\n self.hidden_dim = hidden_dim\\n\\n self.kernel_size = kernel_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.bias = bias\\n\\n self.conv1 = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\\n out_channels=1,\\n kernel_size=self.kernel_size,\\n padding=self.padding,\\n bias=self.bias)\\n \\n self.conv2 = nn.Conv2d(in_channels=self.input_dim,\\n out_channels=self.hidden_dim,\\n kernel_size=self.kernel_size,\\n padding=self.padding,\\n bias=self.bias)\",\n \"def __init__(self, init_grid=None):\\n\\n self.height = len(init_grid)\\n self.width = len(init_grid[0])\\n\\n self.grid = [[Cell(self, c) for c in row]\\n for row in init_grid]\\n\\n self.g = nx.Graph()\\n self.tangle()\",\n \"def _create_cell(self,row_number,cell_number):\\n cell = Cell(self)\\n cell.x = cell_number * self.cell_width\\n cell.y = row_number * self.cell_width\\n cell.rect.x = cell.x\\n cell.rect.y = cell.y\\n return cell\",\n \"def _build_pnasnet_base(\\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\\n start_cell_num):\\n\\n # Find where to place the reduction cells or stride normal cells\\n reduction_indices = nasnet_utils.calc_reduction_layers(\\n hparams.num_cells, hparams.num_reduction_layers)\\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\\n\\n # Note: The None is prepended to match the behavior of _imagenet_stem()\\n cell_outputs = [None, hidden_previous, hidden]\\n net = hidden\\n\\n # Run the cells\\n for cell_num in range(start_cell_num, hparams.num_cells):\\n is_reduction = cell_num in reduction_indices\\n stride = 2 if is_reduction else 1\\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\\n prev_layer = cell_outputs[-2]\\n net = normal_cell(\\n net,\\n scope='cell_{}'.format(cell_num),\\n filter_scaling=filter_scaling,\\n stride=stride,\\n prev_layer=prev_layer,\\n cell_num=true_cell_num)\\n true_cell_num += 1\\n cell_outputs.append(net)\\n\\n # Final nonlinearity.\\n # Note that we have dropped the final pooling, dropout and softmax layers\\n # from the default pnasnet version.\\n with tf.variable_scope('final_layer'):\\n net = tf.nn.relu(net)\\n return net\",\n \"def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\\n state_keep_prob=1.0, variational_recurrent=False,\\n input_size=None, dtype=None, seed=None,\\n dropout_state_filter_visitor=None):\\n if not _like_rnncell(cell):\\n raise TypeError(\\\"The parameter cell is not a RNNCell.\\\")\\n if (dropout_state_filter_visitor is not None\\n and not callable(dropout_state_filter_visitor)):\\n raise TypeError(\\\"dropout_state_filter_visitor must be callable\\\")\\n self._dropout_state_filter = (\\n dropout_state_filter_visitor or _default_dropout_state_filter_visitor)\\n with ops.name_scope(\\\"DropoutWrapperInit\\\"):\\n def tensor_and_const_value(v):\\n tensor_value = ops.convert_to_tensor(v)\\n const_value = tensor_util.constant_value(tensor_value)\\n return (tensor_value, const_value)\\n for prob, attr in [(input_keep_prob, \\\"input_keep_prob\\\"),\\n (state_keep_prob, \\\"state_keep_prob\\\"),\\n (output_keep_prob, \\\"output_keep_prob\\\")]:\\n tensor_prob, const_prob = tensor_and_const_value(prob)\\n if const_prob is not None:\\n if const_prob < 0 or const_prob > 1:\\n raise ValueError(\\\"Parameter %s must be between 0 and 1: %d\\\"\\n % (attr, const_prob))\\n setattr(self, \\\"_%s\\\" % attr, float(const_prob))\\n else:\\n setattr(self, \\\"_%s\\\" % attr, tensor_prob)\\n\\n # Set cell, variational_recurrent, seed before running the code below\\n self._cell = cell\\n self._variational_recurrent = variational_recurrent\\n self._seed = seed\\n\\n self._recurrent_input_noise = None\\n self._recurrent_state_noise = None\\n self._recurrent_output_noise = None\\n\\n if variational_recurrent:\\n if dtype is None:\\n raise ValueError(\\n \\\"When variational_recurrent=True, dtype must be provided\\\")\\n\\n def convert_to_batch_shape(s):\\n # Prepend a 1 for the batch dimension; for recurrent\\n # variational dropout we use the same dropout mask for all\\n # batch elements.\\n return array_ops.concat(\\n ([1], tensor_shape.TensorShape(s).as_list()), 0)\\n\\n def batch_noise(s, inner_seed):\\n shape = convert_to_batch_shape(s)\\n return random_ops.random_uniform(shape, seed=inner_seed, dtype=dtype)\\n\\n if (not isinstance(self._input_keep_prob, numbers.Real) or\\n self._input_keep_prob < 1.0):\\n if input_size is None:\\n raise ValueError(\\n \\\"When variational_recurrent=True and input_keep_prob < 1.0 or \\\"\\n \\\"is unknown, input_size must be provided\\\")\\n self._recurrent_input_noise = _enumerated_map_structure_up_to(\\n input_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"input\\\", i)),\\n input_size)\\n self._recurrent_state_noise = _enumerated_map_structure_up_to(\\n cell.state_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"state\\\", i)),\\n cell.state_size)\\n self._recurrent_output_noise = _enumerated_map_structure_up_to(\\n cell.output_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"output\\\", i)),\\n cell.output_size)\",\n \"def rnn_cell_loop(self):\\n\\n\\t\\t# Set up initial state\\n\\t\\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\\t\\t\\t# Spike\\n\\t\\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\\t\\t\\t\\t\\t# State\\n\\t\\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\\n\\t\\tself.h = [self.h]\\n\\t\\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\\n\\n\\t\\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\t\\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\n\\t\\t# Apply the EI mask to the recurrent weights\\n\\t\\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\\n\\n\\t\\t# Set up latency buffer if being used\\n\\t\\tif par['use_latency']:\\n\\t\\t\\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\\n\\t\\t\\tself.state_buffer = deque(self.state_buffer)\\n\\t\\t\\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\\n\\t\\t\\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\\n\\n\\t\\t# Set up output record\\n\\t\\tself.output = []\\n\\t\\tself.syn_x = []\\n\\t\\tself.syn_u = []\\n\\n\\t\\ty = 0.\\n\\t\\tfor t in range(par['num_time_steps']):\\n\\t\\t\\tself.t = t \\t\\t# For latency calculations\\n\\n\\t\\t\\tif par['cell_type'] == 'rate':\\n\\t\\t\\t\\traise Exception('Rate cell not yet implemented.')\\n\\t\\t\\telif par['cell_type'] == 'adex':\\n\\t\\t\\t\\tif t < 10:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\t\\t\\t\\tself.syn_x.append(syn_x)\\n\\t\\t\\t\\tself.syn_u.append(syn_u)\\n\\n\\t\\t\\telif par['cell_type'] == 'lif':\\n\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\n\\t\\t# Stack records\\n\\t\\tself.output = tf.stack(self.output, axis=0)\\n\\t\\tself.h = tf.stack(self.h, axis=0)\\n\\t\\tself.h_out = tf.stack(self.h_out, axis=0)\\n\\t\\tself.syn_x = tf.stack(self.syn_x, axis=0)\\n\\t\\tself.syn_u = tf.stack(self.syn_u, axis=0)\",\n \"def _build_rnn(self, n_cells, hidden_layer_size, num_layers,\\n batch_size, time_window, lr):\\n\\n x_anchor = tf.placeholder(shape=[batch_size, n_cells, time_window],\\n dtype=tf.float32)\\n x_pos = tf.placeholder(shape=[batch_size, n_cells, time_window],\\n dtype=tf.float32)\\n x_neg = tf.placeholder(shape=[batch_size, n_cells, time_window,],\\n dtype=tf.float32)\\n\\n def embed_rnn(x_in):\\n \\\"\\\"\\\"Gives RNN embedding of x_in.\\\"\\\"\\\"\\n x_in_flat = tf.reshape(x_in, [batch_size*time_window, n_cells])\\n w_in = tf.get_variable(\\\"w_in\\\", shape=[n_cells, hidden_layer_size],\\n initializer=tf.random_normal_initializer())\\n b_in = tf.get_variable(\\\"b_in\\\", shape=[hidden_layer_size],\\n initializer=tf.random_normal_initializer())\\n x_ld_flat = tf.matmul(x_in_flat, w_in) + b_in\\n x_ld = tf.reshape(x_ld_flat, [batch_size, time_window, hidden_layer_size])\\n\\n # stacked LSTM cells\\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_layer_size,\\n forget_bias=0.0,\\n state_is_tuple=True)\\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers,\\n state_is_tuple=True)\\n\\n # compute output\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n outputs, _ = tf.nn.dynamic_rnn(cell, x_ld,\\n initial_state=initial_state,\\n time_major=False)\\n\\n # reconstruct and compute loss on last output only\\n outputs_unp = tf.unpack(tf.transpose(outputs, [1, 0, 2]))\\n embedding = outputs_unp[-1]\\n\\n return embedding\\n\\n def distance_squared(embed1, embed2):\\n return tf.reduce_sum((embed1 - embed2)**2, 1)\\n\\n with tf.variable_scope(\\\"RNN\\\") as scope:\\n\\n # embed anchor, positive and negative examples.\\n embed_anchor = embed_rnn(tf.transpose(x_anchor, [0, 2, 1]))\\n # This enables reusing the RNN for anchor, pos and neg.\\n scope.reuse_variables()\\n # Check that we are reusing the same RNN using:\\n # print(tf.get_variable_scope().reuse)\\n embed_pos = embed_rnn(tf.transpose(x_pos, [0, 2, 1]))\\n embed_neg = embed_rnn(tf.transpose(x_neg, [0, 2, 1]))\\n\\n # Loss for each point max(d(anchor, pos)^2 - d(anchor, neg)^2 + 1, 0)\\n loss = tf.reduce_sum(tf.nn.relu(distance_squared(embed_anchor,\\n embed_pos) -\\n distance_squared(embed_anchor,\\n embed_neg)\\n + 1), 0)\\n # train model\\n train_step = tf.train.AdagradOptimizer(lr).minimize(loss)\\n\\n return (x_anchor, x_pos, x_neg, train_step, loss,\\n embed_anchor, embed_pos, embed_neg)\",\n \"def __init__(self,\\n num_units,\\n forget_bias=1.0,\\n state_is_tuple=True,\\n activation=None,\\n reuse=None,\\n name=None):\\n super(MaskedBasicLSTMCell, self).__init__(\\n num_units,\\n forget_bias=forget_bias,\\n state_is_tuple=state_is_tuple,\\n activation=activation,\\n reuse=reuse,\\n name=name)\",\n \"def build(self, input_tensors, is_training, lengths=None, hparams=None):\\n input_tensor = input_tensors[-1]\\n rnn_cell = tf.compat.v1.nn.rnn_cell.BasicRNNCell(\\n num_units=self._output_size, activation=tf.nn.tanh)\\n net, _ = tf.compat.v1.nn.dynamic_rnn(\\n rnn_cell, input_tensor, sequence_length=lengths, dtype=tf.float32)\\n\\n if self._skip:\\n net += _add_projection_if_needed(input_tensor, net)\\n\\n return input_tensors + [net]\",\n \"def __init__(self, num_outputs, use_ground_truth, internal_cell):\\n self._num_outputs = num_outputs\\n self._use_ground_truth = use_ground_truth # boolean\\n self._internal_cell = internal_cell # may be LSTM or GRU or anything\",\n \"def __init__(\\n self,\\n input_size,\\n hidden_size,\\n nonlinearity='relu',\\n num_layers=1,\\n bidirectional=False,\\n dropout=0,\\n **kwargs\\n ):\\n mode = 'rnn_relu' if nonlinearity == 'relu' else 'rnn_tanh'\\n super(RNN, self).__init__(\\n mode, input_size, hidden_size,\\n num_layers, bidirectional, dropout, **kwargs\\n )\",\n \"def __init__(\\n self,\\n input_tensor_spec,\\n output_tensor_spec,\\n conv_layer_params=None,\\n input_fc_layer_params=(200, 100),\\n lstm_size=(40,),\\n output_fc_layer_params=(200, 100),\\n activation_fn=tf.keras.activations.relu,\\n name='ActorRnnNetwork',\\n ):\\n if len(tf.nest.flatten(input_tensor_spec)) > 1:\\n raise ValueError('Only a single observation is supported by this network')\\n\\n input_layers = utils.mlp_layers(\\n conv_layer_params,\\n input_fc_layer_params,\\n activation_fn=activation_fn,\\n kernel_initializer=tf.compat.v1.keras.initializers.glorot_uniform(),\\n name='input_mlp',\\n )\\n\\n # Create RNN cell\\n if len(lstm_size) == 1:\\n cell = tf.keras.layers.LSTMCell(lstm_size[0])\\n else:\\n cell = tf.keras.layers.StackedRNNCells(\\n [tf.keras.layers.LSTMCell(size) for size in lstm_size]\\n )\\n\\n state_spec = tf.nest.map_structure(\\n functools.partial(\\n tensor_spec.TensorSpec, dtype=tf.float32, name='network_state_spec'\\n ),\\n list(cell.state_size),\\n )\\n\\n output_layers = utils.mlp_layers(\\n fc_layer_params=output_fc_layer_params, name='output'\\n )\\n\\n flat_action_spec = tf.nest.flatten(output_tensor_spec)\\n action_layers = [\\n tf.keras.layers.Dense(\\n single_action_spec.shape.num_elements(),\\n activation=tf.keras.activations.tanh,\\n kernel_initializer=tf.keras.initializers.RandomUniform(\\n minval=-0.003, maxval=0.003\\n ),\\n name='action',\\n )\\n for single_action_spec in flat_action_spec\\n ]\\n\\n super(ActorRnnNetwork, self).__init__(\\n input_tensor_spec=input_tensor_spec, state_spec=state_spec, name=name\\n )\\n\\n self._output_tensor_spec = output_tensor_spec\\n self._flat_action_spec = flat_action_spec\\n self._conv_layer_params = conv_layer_params\\n self._input_layers = input_layers\\n self._dynamic_unroll = dynamic_unroll_layer.DynamicUnroll(cell)\\n self._output_layers = output_layers\\n self._action_layers = action_layers\",\n \"def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\\n cells = []\\n for i in range(layer_num):\\n if rnn_type.endswith('lstm'):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n elif rnn_type.endswith('gru'):\\n cell = tc.rnn.GRUCell(num_units=hidden_size)\\n elif rnn_type.endswith('rnn'):\\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\\n else:\\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\\n return cells\",\n \"def __init__(self, model, num_classes=-1, hidden_size=128, type='gru', **kwargs):\\n super(CNNRNN, self).__init__(**kwargs)\\n self.feats = model is None\\n with self.name_scope():\\n if model is not None:\\n self.td = TimeDistributed(model.backbone)\\n if type == 'lstm':\\n self.rnn = mx.gluon.rnn.LSTM(hidden_size, layout=\\\"NTC\\\", bidirectional=True)\\n else:\\n self.rnn = mx.gluon.rnn.GRU(hidden_size, layout=\\\"NTC\\\", bidirectional=True)\\n self.classes = None\\n if num_classes == 0:\\n self.classes = model.classes\\n elif num_classes > 0:\\n self.classes = nn.Dense(num_classes, flatten=True)\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\\n super(ConvGRUCell, self).__init__()\\n self.height, self.width = input_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.hidden_dim = hidden_dim\\n self.bias = bias\\n self.dtype = dtype\\n\\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\\n\\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\\n out_channels=self.hidden_dim, # for candidate neural memory\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\",\n \"def __init__(self, celltype, model=None, build_mode='lazy'):\\n # Generate the NineLine class from the nineml file and initialise a\\n # single cell from it\\n if (isinstance(celltype, BiophysNineml) or isinstance(celltype, str)):\\n self.celltype = CellMetaClass(celltype, build_mode=build_mode)\\n else:\\n self.celltype = celltype\\n self.default_seg = self.celltype(model=model).source_section.name\\n self._model = model\\n self.genome_keys = []\\n self.log_scales = []\",\n \"def __call__(self, inputs, state, scope=None, debug=False):\\n # B is batch size.\\n\\n # 1) Use read_ind to find memory location to read from\\n # as input.\\n\\n # inputs.read_ind: (B, 1)\\n # memory: (B, mem_size, embed_size)\\n read_ind = tf.to_int32(inputs.read_ind)\\n batch_size = tf.shape(read_ind)[0]\\n if debug:\\n print('batch size is', batch_size)\\n print('read ind is', read_ind)\\n mem_ind = tf.range(batch_size)\\n\\n # read_mem_ind: (B, 1)\\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n # read_ind: (B, 2)\\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\\n if debug:\\n print('processed read ind is', read_ind)\\n\\n # inner_inputs: (B, embed_size)\\n inner_inputs = tf.gather_nd(state.memory, read_ind)\\n if debug:\\n print('inner_inputs is', inner_inputs)\\n\\n inner_state = state.inner_state\\n\\n # 2) Run the inner RNNCell.\\n \\n # inner_outputs: (B, embed_size)\\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\\n\\n if debug:\\n print('inner_outputs is', inner_outputs)\\n\\n # 3) Compute logits for valid indices (using logit_masks\\n # to mask out padded valid indices (-1)).\\n \\n # valid_indices: (B, max_n_valid_indices)\\n valid_indices = tf.to_int32(inputs.valid_indices)\\n if debug:\\n print('valid_indices is', valid_indices)\\n \\n # Logit mask: (B, max_n_valid_indices)\\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\\n logit_masks = tf.cast(logit_masks, tf.float32)\\n\\n if debug:\\n print('logit_masks is', logit_masks)\\n\\n # Normalize indices to be at least 0.\\n valid_indices = tf.maximum(valid_indices, 0)\\n\\n # valid_indices: (B, max_n_valid_indices, 1)\\n valid_indices = tf.expand_dims(valid_indices, -1)\\n if debug:\\n print('valid_indices is', valid_indices)\\n print('mem_ind is', mem_ind)\\n\\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # valid_mem_ind: (B, 1, 1)\\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\\n if debug:\\n print('valid_mem_ind is', valid_mem_ind)\\n\\n # valid_mem_ind: (B, max_n_valid_indices, 1)\\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\\n\\n # valid_indices: (B, max_n_valid_indices, 2)\\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\\n # index into the right memory location.\\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\\n\\n if debug:\\n print('valid_indices is', valid_indices)\\n\\n # select all the valid slots. \\n # valid_values: (B, max_n_valid_indices, embed_size)\\n valid_values = tf.gather_nd(state.memory, valid_indices)\\n if debug:\\n print('valid_values is', valid_values)\\n \\n # expanded_inner_outputs: (B, 1, embed_size)\\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\\n if debug:\\n print('expanded_inner_outputs is', expanded_inner_outputs)\\n\\n # valid_values: (B, embed_size, max_n_valid_indices)\\n valid_values = tf.transpose(valid_values, [0, 2, 1])\\n if debug:\\n print('valid_values is', valid_values)\\n\\n # logits: (B, 1, max_n_valid_indices)\\n logits = tf.matmul(expanded_inner_outputs, valid_values)\\n \\n if debug:\\n print('logits is', logits)\\n\\n # logits: (B, max_n_valid_indices)\\n logits = tf.squeeze(logits, axis=[1])\\n if debug:\\n print('logits is', logits)\\n\\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\\n\\n outputs = masked_logits\\n # 4) Write the output of the inner RNN to a memory\\n # location (write_ind), using write_masks to mask out\\n # padded write_ind (-1).\\n \\n # write_ind: (B, 1)\\n write_ind = tf.cast(inputs.write_ind, tf.int32)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n # write mask: (B, 1)\\n write_masks = tf.greater_equal(inputs.write_ind, 0)\\n if debug:\\n print('write_masks greater_equal', write_masks)\\n\\n write_masks = tf.cast(write_masks, tf.float32)\\n\\n # write mask: (B, 1, 1)\\n write_masks = tf.expand_dims(write_masks, [-1])\\n\\n if debug:\\n print('write_masks is', write_masks)\\n\\n # Normalize write_ind to be above 0.\\n # write_ind: (B, 1)\\n write_ind = tf.maximum(write_ind, 0)\\n\\n # write_mem_ind: (B, 1)\\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # write_ind: (B, 2)\\n # Second dimension is [b_i, write_index]\\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n if debug:\\n print('masked_logits is', masked_logits)\\n print('memory is', state.memory)\\n\\n # write_mat: (B, mem_size, embed_size)\\n write_mat = tf.scatter_nd(\\n write_ind, inner_outputs, shape=tf.shape(state.memory))\\n\\n if debug:\\n print('@' * 50)\\n print('write_mat is', write_mat)\\n print('write_mask is', write_masks)\\n print('@' * 50)\\n\\n masked_write_mat = write_mat * write_masks\\n new_memory = state.memory + masked_write_mat\\n \\n state = MemoryStateTuple(new_memory, new_inner_state)\\n if debug:\\n print('state is', state)\\n \\n return (outputs, state)\",\n \"def resnet_9blocks(pretrained=False, **kwargs):\\n return ResnetGenerator(\\n 9, **kwargs\\n )\",\n \"def __init__(self,\\n num_units,\\n forget_bias=1.0,\\n activation=None,\\n reuse=None,\\n layer_norm: bool=False,\\n norm_shift: float=0.0,\\n norm_gain: float=1.0, # layer normalization\\n dropout_keep_prob_in: float = 1.0,\\n dropout_keep_prob_h: float=1.0,\\n dropout_keep_prob_out: float=1.0,\\n dropout_keep_prob_gate: float=1.0,\\n dropout_keep_prob_forget: float=1.0,\\n dropout_prob_seed: int=None,\\n variational_dropout: bool=False,\\n recurrent_dropout: bool=False\\n ):\\n super(CustomLSTMCell, self).__init__(_reuse=reuse)\\n self._num_units = num_units\\n self._forget_bias = forget_bias\\n self._activation = activation or math_ops.tanh\\n\\n self._layer_norm = layer_norm\\n self._g = norm_gain\\n self._b = norm_shift\\n\\n self._recurrent_dropout = recurrent_dropout\\n self._variational_dropout = variational_dropout\\n \\n self._seed = dropout_prob_seed\\n self._keep_prob_i = dropout_keep_prob_in\\n self._keep_prob_g = dropout_keep_prob_gate\\n self._keep_prob_f = dropout_keep_prob_forget\\n self._keep_prob_o = dropout_keep_prob_out\\n self._keep_prob_h = dropout_keep_prob_h\",\n \"def resnet10(**kwargs):\\n model = ResNet(BasicBlock, [1, 1, 1, 1], **kwargs)\\n return model\",\n \"def get_rnn_cells(self):\\n return [self.rnn]\",\n \"def SimpleRNN(self):\\n # Model.\\n model = Sequential()\\n model.add(SimpleRNN(2048, return_sequences=True,\\n input_shape=self.input_shape,\\n dropout=0.0))\\n #model.add(Flatten()) #qiao_added\\n # model.add(Dense(1024, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(2048, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Flatten())\\n model.add(Dense(self.nb_classes, activation='softmax'))\\n return model\",\n \"def __call__(self, inputs, state, scope=None):\\n if scope is not None:\\n with vs.variable_scope(scope,\\n custom_getter=self._rnn_get_variable) as scope:\\n return super(RNNCell, self).__call__(inputs, state, scope=scope)\\n else:\\n scope_attrname = \\\"rnncell_scope\\\"\\n scope = getattr(self, scope_attrname, None)\\n if scope is None:\\n scope = vs.variable_scope(vs.get_variable_scope(),\\n custom_getter=self._rnn_get_variable)\\n setattr(self, scope_attrname, scope)\\n with scope:\\n return super(RNNCell, self).__call__(inputs, state)\",\n \"def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\\n is_training=True, seed=None):\\n if not isinstance(cell, tf.nn.rnn_cell.RNNCell):\\n raise TypeError(\\\"The parameter cell is not a RNNCell.\\\")\\n if (isinstance(input_keep_prob, float) and\\n not (input_keep_prob >= 0.0 and input_keep_prob <= 1.0)):\\n raise ValueError(\\\"Parameter input_keep_prob must be between 0 and 1: %d\\\"\\n % input_keep_prob)\\n if (isinstance(output_keep_prob, float) and\\n not (output_keep_prob >= 0.0 and output_keep_prob <= 1.0)):\\n raise ValueError(\\\"Parameter output_keep_prob must be between 0 and 1: %d\\\"\\n % output_keep_prob)\\n self._cell = cell\\n self._input_keep_prob = input_keep_prob\\n self._output_keep_prob = output_keep_prob\\n self._seed = seed\\n self._is_training = is_training\",\n \"def __init__(self, name=\\\"conv_1d_lstm_cell\\\", **kwargs):\\n super(Conv1DLSTMCell, self).__init__(conv_ndims=1, name=name, **kwargs)\",\n \"def __init__(self, width=20, height=20):\\n self.width = width\\n self.height = height\\n self.cells = []\\n for y in range(self.height):\\n for x in range(self.width):\\n self.cells.append(Cell(x, y, [N, S, E, W]))\",\n \"def n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs,\\n activation, use_bi_direction, **kwargs): # NOQA\\n\\n argument.check_unexpected_kwargs(\\n kwargs, train='train argument is not supported anymore. '\\n 'Use chainer.using_config',\\n use_cudnn='use_cudnn argument is not supported anymore. '\\n 'Use chainer.using_config')\\n argument.assert_kwargs_empty(kwargs)\\n\\n activation_list = ['tanh', 'relu']\\n if activation not in activation_list:\\n candidate = ','.join(activation_list)\\n raise ValueError('Invalid activation: \\\"%s\\\". Please select from [%s]'\\n % (activation, candidate))\\n\\n xp = cuda.get_array_module(hx)\\n\\n if xp is not numpy and chainer.should_use_cudnn('>=auto', 5000):\\n states = get_random_state().create_dropout_states(dropout_ratio)\\n lengths = [len(x) for x in xs]\\n xs = chainer.functions.concat(xs, axis=0)\\n\\n rnn_mode = 'rnn_%s' % activation\\n w = cudnn_rnn_weight_concat(\\n n_layers, states, use_bi_direction, rnn_mode, ws, bs)\\n\\n if use_bi_direction:\\n # Bi-directional RNN\\n if activation == 'tanh':\\n rnn = NStepBiRNNTanh\\n elif activation == 'relu':\\n rnn = NStepBiRNNReLU\\n else:\\n # Uni-directional RNN\\n if activation == 'tanh':\\n rnn = NStepRNNTanh\\n elif activation == 'relu':\\n rnn = NStepRNNReLU\\n\\n hy, ys = rnn(n_layers, states, lengths)(hx, w, xs)\\n sections = numpy.cumsum(lengths[:-1])\\n ys = chainer.functions.split_axis(ys, sections, 0)\\n return hy, ys\\n\\n else:\\n\\n def f(x, h, c, w, b):\\n xw, hw = w\\n xb, hb = b\\n rnn_in = linear.linear(x, xw, xb) + linear.linear(h, hw, hb)\\n if activation == 'tanh':\\n return tanh.tanh(rnn_in), None\\n elif activation == 'relu':\\n return relu.relu(rnn_in), None\\n\\n hy, _, ys = n_step_rnn_impl(\\n f, n_layers, dropout_ratio, hx, None, ws, bs, xs, use_bi_direction)\\n return hy, ys\",\n \"def create_cells(self, N):\\n self.cells = []\\n r = 50 # Radius of cell locations from origin (0,0,0) in microns\\n N = self._N\\n for i in range(N):\\n cell = BallAndStick()\\n # When cells are created, the soma location is at (0,0,0) and\\n # the dendrite extends along the X-axis.\\n # First, at the origin, rotate about Z.\\n cell.rotateZ(i * 2 * pi / N)\\n # Then reposition\\n x_loc = cos(i * 2 * pi / N) * r\\n y_loc = sin(i * 2 * pi / N) * r\\n cell.set_position(x_loc, y_loc, 0)\\n self.cells.append(cell)\",\n \"def __init__(self,\\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\\n in2hid: tuple, in2out: tuple,\\n hid2hid: tuple, hid2out: tuple,\\n hidden_biases: np.ndarray, output_biases: np.ndarray,\\n rnn_array: np.ndarray, rnn_map: np.ndarray,\\n activation,\\n batch_size: int = 1,\\n initial_read: np.ndarray = None,\\n dtype=np.float64,\\n ):\\n # Storing the input arguments (needed later on)\\n self.act_f = activation\\n self.dtype = dtype\\n self.rnn_idx: np.ndarray = rnn_idx\\n self.n_inputs: int = len(input_idx)\\n self.n_hidden: int = len(hidden_idx)\\n self.n_rnn: int = len(rnn_idx)\\n self.n_outputs: int = len(output_idx)\\n self.bs: int = batch_size\\n \\n # Setup the rnn_map\\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\\n for i, m in enumerate(rnn_map):\\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\\n \\n # Placeholders, initialized during reset\\n self.rnn_state: np.ndarray = None # State of the RNNs\\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\\n self.output_act: np.ndarray = None # Activations of the output nodes\\n \\n # Do not create the hidden-related matrices if hidden-nodes do not exist\\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\\n if self.n_hidden > 0:\\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\\n self.rnn_array: np.ndarray = rnn_array\\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\\n \\n # Fill in the biases\\n if self.n_hidden > 0:\\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\\n \\n # Put network to initial (default) state\\n self.reset(initial_read=initial_read)\",\n \"def __init__(\\n self, channel_count: int, input_height_width: tuple, no_add: bool = False\\n ):\\n super().__init__()\\n\\n self.no_add: bool = no_add\\n\\n self.rm_block_1 = RMBlock(\\n channel_count // 2,\\n channel_count,\\n input_height_width,\\n 1,\\n \\\"weight\\\",\\n 1,\\n )\\n\\n self.rm_block_2 = RMBlock(\\n channel_count // 2,\\n channel_count // 2,\\n input_height_width,\\n 3,\\n \\\"weight\\\",\\n 32,\\n )\\n\\n self.rm_block_3 = RMBlock(\\n channel_count,\\n channel_count // 2,\\n input_height_width,\\n 1,\\n \\\"weight\\\",\\n 1,\\n )\",\n \"def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\\n #====================================================================================#\\n # ----------PROBLEM 2----------\\n #====================================================================================#\\n # YOUR CODE HERE\\n # raise NotImplementedError\\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\\n ## step 1 - inputs are first embedded by an MLP\\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\\n # print(\\\"after build_mlp x = \\\", x)\\n ## step 2 - passed to a GRU cell\\n # as \\\"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\\\"hidden\\\", dtype=tf.float32)\\\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\\n # after build_mlp x = Tensor(\\\"continuous_logits/continuous_logits/fc1/BiasAdd:0\\\", shape=(?, 1, 32), dtype=float32)\\n # x = tf.squeeze(x, axis=1)\\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\\n # print(\\\"dynamic_rnn build_mlp x = \\\", x, \\\" h = \\\", h)\\n return x, h\",\n \"def add_model(self, inputs):\\n size = self.config.hidden_size\\n forget_bias = self.config.forget_bias\\n input_cell = self.config.input_cell\\n\\n if input_cell == 'BasicLSTMCell':\\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\\n print 'Using Basic LSTM Cell \\\\n'\\n\\n elif input_cell == 'LSTMCell':\\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\\n print 'Using LSTM Cell \\\\n'\\n\\n elif input_cell == 'GRUCell':\\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\\n print 'Using GRU Cell \\\\n'\\n\\n else:\\n print \\\"Please Specify a Correct Cell Type\\\"\\n\\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\\n input_keep_prob=self.config.dropout)\\n\\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\\n \\n print 'Number of Hidden Layers ', self.config.num_layers\\n \\n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\\n rnn_outputs = []\\n state = self.initial_state\\n\\n with tf.variable_scope('RNNLM') as scope:\\n for time_step in range(self.config.num_steps):\\n if time_step > 0: scope.reuse_variables()\\n (cell_output, state) = cell(inputs[:, time_step, :], state)\\n rnn_outputs.append(cell_output)\\n self.final_state = state\\n\\n return rnn_outputs\",\n \"def __init__(self, cell_index, stimulus_type, conv_layers=[(12, 9, 9), (12, 9, 9)], dense_layer=64,\\n loss='poisson_loss', optimizer='adam', weight_init='normal', l2_reg=0., dropout=0.5, mean_adapt=False):\\n\\n self.stim_shape = (40, 50, 50)\\n\\n # build the model\\n with notify('Building convnet'):\\n\\n self.model = Sequential()\\n\\n # convolutional layers\\n for ix, layer in enumerate(conv_layers):\\n\\n # get parameters for this layer\\n num_filters, row_size, col_size = layer\\n\\n # convolutional layer\\n if ix == 0:\\n self.model.add(Convolution2D(num_filters, row_size, col_size,\\n input_shape=self.stim_shape, init=weight_init,\\n border_mode='same', subsample=(1,1),\\n W_regularizer=l2(l2_reg), activation='relu'))\\n\\n else:\\n self.model.add(Convolution2D(num_filters, row_size, col_size,\\n input_shape=self.stim_shape, init=weight_init,\\n border_mode='same', subsample=(1,1),\\n W_regularizer=l2(l2_reg), activation='relu'))\\n\\n # max pooling layer\\n self.model.add(MaxPooling2D(pool_size=(2, 2), ignore_border=True))\\n\\n # dropout\\n self.model.add(Dropout(dropout))\\n\\n # flatten\\n self.model.add(Flatten())\\n\\n # Add dense (affine) layer with relu activation\\n self.model.add(Dense(dense_layer, init=weight_init, W_regularizer=l2(l2_reg), activation='relu'))\\n self.model.add(Dropout(dropout))\\n\\n # Add a final dense (affine) layer with softplus activation\\n self.model.add(Dense(1, init=weight_init, W_regularizer=l2(l2_reg), activation='softplus'))\\n\\n # save architecture string (for markdown file)\\n self.architecture = '\\\\n'.join(['Convolutional layers {}'.format(conv_layers),\\n '{} filters in the second (fully connected) layer'.format(dense_layer),\\n 'weight initialization: {}'.format(weight_init),\\n 'l2 regularization: {}'.format(l2_reg),\\n 'stimulus shape: {}'.format(self.stim_shape)])\\n\\n # compile\\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)\",\n \"def __init__(self, name=\\\"conv_2d_lstm_cell\\\", **kwargs):\\n super(Conv2DLSTMCell, self).__init__(conv_ndims=2, name=name, **kwargs)\",\n \"def __init__(self, config, input_shp):\\n\\n # Run initialization for super class\\n super(MyNetwork, self).__init__()\\n\\n # Store configuration\\n self.config = config\\n\\n # Placeholder for layers\\n self.layers = {}\\n indim = input_shp[0]\\n\\n # Retrieve Conv, Act, Pool functions from configurations. We'll use\\n # these for our code below.\\n if config.conv2d == \\\"torch\\\":\\n self.Conv2d = nn.Conv2d\\n elif config.conv2d == \\\"custom\\\":\\n self.Conv2d = ConvBlock\\n self.Activation = getattr(nn, config.activation)\\n self.Pool2d = getattr(nn, config.pool2d)\\n self.Linear = nn.Linear\\n\\n # Resnet Blocks, similar to slide 73 of lecture 21. However, for\\n # simplicity, we'll make is slightly different. Note that we used\\n # nn.Sequential this time.\\n self.convs = nn.Sequential()\\n cur_h, cur_w = input_shp[-2:]\\n for _i in range(config.num_conv_outer):\\n #\\n # NOTE THE NEW LAYER ON THESE LINES!\\n #\\n # We have a dedicated 1x1 layer to get more channels. Note also\\n # that this is a pure linear convolution layer.\\n outdim = config.nchannel_base * 2 ** _i\\n self.convs.add_module(\\n \\\"conv_{}_base\\\".format(_i), nn.Conv2d(indim, outdim, 1, 1, 0))\\n indim = outdim\\n for _j in range(config.num_conv_inner):\\n # We now use our selected convolution layer. Note that our\\n # resnet implementation will have a different call style to\\n # vanilla conv2d of torch, so we'll just do an ugly if-else\\n # here.\\n if config.conv2d == \\\"torch\\\":\\n self.convs.add_module(\\n \\\"conv_{}_{}\\\".format(_i, _j),\\n self.Conv2d(indim, outdim, config.ksize, 1, 1))\\n self.convs.add_module(\\n \\\"act_{}_{}\\\".format(_i, _j),\\n self.Activation())\\n cur_h = cur_h - (config.ksize - 1)\\n cur_w = cur_w - (config.ksize - 1)\\n elif config.conv2d == \\\"custom\\\":\\n self.convs.add_module(\\n \\\"conv_{}_{}\\\".format(_i, _j),\\n self.Conv2d(indim, outdim, config.ksize, 1, self.Activation))\\n self.convs.add_module(\\n \\\"conv_{}_pool\\\".format(_i), self.Pool2d(2, 2))\\n cur_h = cur_h // 2\\n cur_w = cur_w // 2\\n\\n # Final output layer. We'll assume that conv layer outputs are global\\n # average pooled\\n self.output = nn.Linear(indim, config.num_class)\\n\\n print(self)\",\n \"def __init__(self,cell1,site1,cell2,site2,color=None,label=None,linewidth=None,linetype=None):\\n self.cell1 = np.array(cell1)\\n self.site1 = site1\\n self.cell2 = np.array(cell2)\\n self.site2 = site2\\n coordinate1 = None\\n coordinate2 = None\\n self.color = color\\n self.label = label\\n self.linewidth = linewidth\\n self.linetype = linetype\",\n \"def __init__(self, num_units, levels, forget_bias=1.0,\\r\\n state_is_tuple=True, activation=None, reuse=None, name=None):\\r\\n super(ON_LSTMCell, self).__init__(_reuse=reuse, name=name)\\r\\n if not state_is_tuple:\\r\\n logging.warn(\\\"%s: Using a concatenated state is slower and will soon be \\\"\\r\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\r\\n\\r\\n # Inputs must be 2-dimensional.\\r\\n self.input_spec = base_layer.InputSpec(ndim=2)\\r\\n\\r\\n self._num_units = num_units\\r\\n self._levels = levels\\r\\n self._chunk_size = num_units // levels\\r\\n self._forget_bias = forget_bias\\r\\n self._state_is_tuple = state_is_tuple\\r\\n self._activation = activation or math_ops.tanh\",\n \"def __init__(self, voc_size, layer_size=512, num_layers=3, embedding_layer_size=256, dropout=0.,\\n controller_type='gru', **kwargs):\\n super(RNN, self).__init__()\\n\\n self._layer_size = layer_size\\n self._embedding_layer_size = embedding_layer_size\\n self._num_layers = num_layers\\n self._dropout = dropout\\n self._controller_type = controller_type\\n\\n self._embedding = tnn.Embedding(voc_size, self._embedding_layer_size)\\n\\n if controller_type == 'gru':\\n self._layer = tnn.GRU(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\\n dropout=self._dropout)\\n elif controller_type == 'lstm':\\n self._layer = tnn.LSTM(self._embedding_layer_size, self._layer_size, num_layers=self._num_layers,\\n dropout=self._dropout)\\n\\n self._linear = tnn.Linear(self._layer_size, voc_size)\",\n \"def get_rnn_cells(self) -> List[mx.rnn.BaseRNNCell]:\\n return self.forward_rnn.get_rnn_cells() + self.reverse_rnn.get_rnn_cells()\",\n \"def __init__(self, cell):\\n self._cell = cell\\n self._residual_fn = gnmt_residual_fn\",\n \"def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\\n is_training=False, cell_name=\\\"GRU\\\", bidirectional=False, swap_memory=False):\\n batch_size = tf.shape(X)[0]\\n if bidirectional:\\n rnn_size /= 2\\n\\n def get_cell():\\n if cell_name == \\\"GRU\\\": # GRU\\n _cell = rnn_cell.GRUCell(rnn_size)\\n elif cell_name == \\\"LSTM\\\": # LSTM\\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\\n else:\\n raise ValueError(\\\"Unrecognized Cell Name: {0}\\\".format(cell_name))\\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\\n _initial_state = _cell.zero_state(batch_size, tf.float32)\\n return _cell, _initial_state\\n\\n if bidirectional:\\n with tf.variable_scope(\\\"forward\\\"):\\n cell_fw, initial_state_fw = get_cell()\\n with tf.variable_scope(\\\"backward\\\"):\\n cell_bw, initial_state_bw = get_cell()\\n return rnn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, X, sequence_length=seq_len,\\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\\n else:\\n cell, initial_state = get_cell()\\n return rnn.dynamic_rnn(\\n cell, X, sequence_length=seq_len, initial_state=initial_state,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\",\n \"def get_init_cell(batch_size, rnn_size, keep_prob, lstm_layers=2):\\n def build_cell(lstm_size, keep_prob):\\n cell = tf.nn.rnn.BasicLSTMCell(num_units=lstm_size)\\n drop = tf.nn.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob)\\n return drop\\n\\n # 堆栈cell 构建多层隐藏层\\n multi_cell = tf.nn.rnn.MultiRNNCell(\\n [build_cell(rnn_size, keep_prob) for _ in range(lstm_layers)]\\n )\\n\\n # todo 这里使用tf.identity(final_state同)是为了生成一个op操作符，断点继续训练时候要用。\\n initial_state = multi_cell.zero_state(batch_size, tf.float32)\\n initial_state1 = tf.identity(initial_state, name='initial_state')\\n return multi_cell, initial_state, initial_state1\",\n \"def __init__(self, num_nodes, num_features, num_timesteps_input,\\n num_timesteps_output, gcn_type='normal', hidden_size=64, num_comps=10):\\n super(KRNN, self).__init__()\\n self.encoders = nn.ModuleList()\\n self.decoders = nn.ModuleList()\\n self.linears = nn.ModuleList()\\n\\n self.num_timesteps_output = num_timesteps_output\\n\\n for r in range(num_comps):\\n self.encoders.append(\\n nn.GRU(num_features, hidden_size)\\n )\\n self.decoders.append(\\n nn.GRUCell(1, hidden_size)\\n )\\n self.linears.append(\\n nn.Linear(hidden_size, 1)\\n )\\n\\n self.embed = nn.Parameter(torch.FloatTensor(num_nodes, num_comps))\\n self.embed.data.normal_()\",\n \"def test_learnable_cell(self):\\n genotype = '0|0|2|0|0|2|0|0 1|0|0|1|1|0|0|0 0|1|0|0|0|0|2|1--1 7'\\n search_space = {'dil_conv_3x3', 'dil_conv_5x5', 'dil_conv_7x7',\\n 'skip_connect', 'clinc_3x3', 'clinc_7x7', 'avg_pool_3x3', 'max_pool_3x3'}\\n\\n net = LearnableCell(3, genotype, search_space)\\n x = torch.rand((16, 3, 32, 32))\\n y = net(x)\\n self.assertEqual(list(y.shape), [16, 7, 15, 15])\",\n \"def SimpleDeepCell():\\n cell = Cell()\\n node = cell._get_hcell2()\\n node[\\\"celltype\\\"] = \\\"mixed\\\"\\n node[\\\"hash_pattern\\\"] = {\\\"*\\\": \\\"#\\\"}\\n return cell\",\n \"def build_gru_cell(num_units, dropout):\\n cell = tf.nn.rnn_cell.GRUCell(num_units)\\n if dropout:\\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\\n output_keep_prob=1-dropout)\\n return result\",\n \"def _build_bdrnn_graph(self, hparams):\\n\\n sample = self.iterator.get_next()\\n\\n inputs, tgt_outputs, seq_len = sample\\n\\n # linear projection to state size\\n #with tf.variable_scope(\\\"bdrnn_in\\\", dtype=tf.float32):\\n # inputs = tf.layers.dense(inputs=inputs,\\n # units=hparams.input_proj_size,\\n # kernel_initializer=tf.glorot_uniform_initializer())\\n\\n lm_fw_cell = []\\n lm_bw_cell = []\\n lm_init_state_fw = []\\n lm_init_state_bw = []\\n if hparams.pretrained:\\n with tf.variable_scope(\\\"lm_rnn\\\", dtype=tf.float32):\\n # create lm\\n with tf.variable_scope(\\\"fw\\\", dtype=tf.float32):\\n lm_fw_cell = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=1,\\n mode=self.mode)\\n # build the cell so it is in the correct scope\\n # NOTE: this is hard coded\\n lm_fw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\\n lm_init_state_fw = _get_initial_state([lm_fw_cell[0].state_size], tf.shape(inputs)[0], \\\"lm\\\")\\n with tf.variable_scope(\\\"bw\\\", dtype=tf.float32):\\n lm_bw_cell = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=1,\\n mode=self.mode)\\n # NOTE: this is hard coded\\n lm_bw_cell[0].build([None, hparams.num_features])#hparams.input_proj_size])\\n lm_init_state_bw = _get_initial_state([lm_bw_cell[0].state_size], tf.shape(inputs)[0], \\\"lm\\\")\\n\\n lm_outputs, lm_states = tf.nn.bidirectional_dynamic_rnn(lm_fw_cell[0],\\n lm_bw_cell[0],\\n inputs,\\n sequence_length=seq_len,\\n initial_state_fw=lm_init_state_fw[0],\\n initial_state_bw=lm_init_state_bw[0],\\n dtype=tf.float32)\\n # optionally fix the LM weights\\n if hparams.fixed_lm:\\n print(\\\"Fixing pretrained language models.\\\")\\n lm_outputs = tf.stop_gradient(lm_outputs)\\n lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1]], axis=-1)\\n lm_outputs = tf.layers.dense(lm_outputs,\\n 20,\\n kernel_initializer=tf.glorot_uniform_initializer())\\n lm_outputs = tf.concat([lm_outputs, inputs], axis=-1)\\n\\n\\n #lm_outputs = tf.concat([lm_outputs[0], lm_outputs[1], inputs], axis=-1)\\n else:\\n lm_outputs = tf.concat(lm_outputs, axis=-1)\\n\\n\\n\\n with tf.variable_scope(\\\"bdrnn\\\", dtype=tf.float32) as bdrnn_scope:\\n # create bdrnn\\n with tf.variable_scope(\\\"fw\\\", dtype=tf.float32):\\n fw_cells = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=hparams.num_layers,\\n mode=self.mode\\n )\\n init_state_fw = _get_initial_state([cell.state_size for cell in fw_cells],\\n tf.shape(inputs)[0], \\\"initial_state_fw\\\")\\n\\n with tf.variable_scope(\\\"bw\\\", dtype=tf.float32):\\n bw_cells = _create_rnn_cell(num_units=hparams.num_units,\\n num_layers=hparams.num_layers,\\n mode=self.mode,\\n )\\n\\n init_state_bw = _get_initial_state([cell.state_size for cell in bw_cells],\\n tf.shape(inputs)[0], \\\"initial_state_bw\\\")\\n # NOTE: this is commented because the lm cells and states are separated now\\n #fw_cells = lm_fw_cell + fw_cells\\n #bw_cells = lm_bw_cell + bw_cells\\n #init_state_fw = lm_init_state_fw + init_state_fw\\n #init_state_bw = lm_init_state_bw + init_state_bw\\n\\n # run bdrnn\\n combined_outputs, output_state_fw, output_state_bw = \\\\\\n tf.contrib.rnn.stack_bidirectional_dynamic_rnn(cells_fw=fw_cells,\\n cells_bw=bw_cells,\\n inputs=lm_outputs,\\n sequence_length=seq_len,\\n initial_states_fw=init_state_fw,\\n initial_states_bw=init_state_bw,\\n dtype=tf.float32,\\n scope=bdrnn_scope)\\n # outputs is a tuple (output_fw, output_bw)\\n # output_fw/output_bw are tensors [batch_size, max_time, cell.output_size]\\n # outputs_states is a tuple (output_state_fw, output_state_bw) containing final states for\\n # forward and backward rnn\\n\\n # concatenate the outputs of each direction\\n #combined_outputs = tf.concat([outputs[0], outputs[1]], axis=-1)\\n\\n with tf.variable_scope(\\\"bdrnn_out\\\", dtype=tf.float32):\\n # dense output layers\\n dense1 = tf.layers.dense(inputs=combined_outputs,\\n units=hparams.num_dense_units,\\n kernel_initializer=tf.glorot_uniform_initializer(),\\n activation=tf.nn.relu,\\n use_bias=True)\\n drop1 = tf.layers.dropout(inputs=dense1,\\n rate=hparams.dropout,\\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\\n dense2 = tf.layers.dense(inputs=drop1,\\n units=hparams.num_dense_units,\\n kernel_initializer=tf.glorot_uniform_initializer(),\\n activation=tf.nn.relu,\\n use_bias=True)\\n drop2 = tf.layers.dropout(inputs=dense2,\\n rate=hparams.dropout,\\n training=self.mode==tf.contrib.learn.ModeKeys.TRAIN)\\n\\n logits = tf.layers.dense(inputs=drop2,\\n units=hparams.num_labels,\\n use_bias=False)\\n\\n # mask out entries longer than target sequence length\\n mask = tf.sequence_mask(seq_len, dtype=tf.float32)\\n\\n crossent = tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,\\n labels=tgt_outputs,\\n name=\\\"crossent\\\")\\n\\n # divide loss by batch_size * mean(seq_len)\\n loss = tf.reduce_sum(crossent*mask)/tf.cast(hparams.batch_size, tf.float32)\\n\\n metrics = []\\n update_ops = []\\n if self.mode == tf.contrib.learn.ModeKeys.EVAL:\\n # mean eval loss\\n loss, loss_update = tf.metrics.mean(values=loss)\\n\\n predictions = tf.argmax(input=logits, axis=-1)\\n tgt_labels = tf.argmax(input=tgt_outputs, axis=-1)\\n acc, acc_update = tf.metrics.accuracy(predictions=predictions,\\n labels=tgt_labels,\\n weights=mask)\\n # confusion matrix\\n targets_flat = tf.reshape(tgt_labels, [-1])\\n predictions_flat = tf.reshape(predictions, [-1])\\n mask_flat = tf.reshape(mask, [-1])\\n cm, cm_update = streaming_confusion_matrix(labels=targets_flat,\\n predictions=predictions_flat,\\n num_classes=hparams.num_labels,\\n weights=mask_flat)\\n tf.add_to_collection(\\\"eval\\\", cm_summary(cm, hparams.num_labels))\\n metrics = [acc, cm]\\n update_ops = [loss_update, acc_update, cm_update]\\n\\n return logits, loss, metrics, update_ops\",\n \"def __init__(self, sys, rcut, pad):\\n self.sys = sys \\n self.rcut = rcut \\n self.pad = pad\\n self.cell_list = CellList(self.sys.box, self.rcut + self.pad)\",\n \"def __init__(self,\\n cell_type: Text = \\\"lstm\\\",\\n tiers: Dict[int:List[int]] = {1:[1]},\\n window_sizes: List[int] = [1],\\n strides: List[int] = [1],\\n use_dense_layer_output : bool = False,\\n dense_layer_args : Dict = {\\\"units\\\": None,\\n \\\"activation\\\":None,#don't change this\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"kernel_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"activity_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n },\\n lstm_cell_args : Dict = {\\\"activation\\\":'tanh',\\n \\\"recurrent_activation\\\":'hard_sigmoid',\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"recurrent_initializer\\\":'orthogonal',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"unit_forget_bias\\\":True,\\n \\\"kernel_regularizer\\\":None,\\n \\\"recurrent_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"recurrent_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n \\\"implementation\\\":1,\\n },\\n gru_cell_args : Dict = {\\\"activation\\\":'tanh',\\n \\\"recurrent_activation\\\":'hard_sigmoid',\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"recurrent_initializer\\\":'orthogonal',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"kernel_regularizer\\\":None,\\n \\\"recurrent_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"recurrent_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n \\\"implementation\\\":1,\\n \\\"reset_after\\\":False,\\n },\\n adam_opt_args : Dict = {\\\"learning_rate\\\": None,\\n \\\"epsilon\\\": None,\\n \\\"beta_1\\\": None,\\n \\\"beta_2\\\": None,\\n },\\n clip_norm : Optional[float] = None,\\n dropout_training = 0,\\n recurrent_dropout_training = 0,\\n tens_to_log = None,\\n checkpoint_path = None,\\n predict_batch_size = 30,\\n save_checkpoints_steps = 100,\\n keep_checkpoint_max = 10,\\n save_summary_steps = 10,\\n logging_step = 10,\\n ):\\n \\n if (len(tiers)!=len(window_sizes) or len(window_sizes)!=len(strides)):\\n raise ValueError(\\\"Mismatch in network geometry specs. Need number of\\\"\\n \\\" tiers = number of window size specs, or number of\\\"\\n \\\" window specs = number of stride specs.\\\")\\n \\n \\n self.cell_type = cell_type \\n self.tiers = tiers, \\n self.window_sizes = window_sizes,\\n self.strides = strides,\\n self.use_dense_layer_output = use_dense_layer_output\\n self.dense_layer_args = dense_layer_args,\\n self.lstm_cell_args = lstm_cell_args,\\n self.gru_cell_args = gru_cell_args,\\n self.adam_opt_args = adam_opt_args,\\n self.clip_norm = clip_norm,\\n self.dropout_training = 0,\\n self.recurrent_dropout_training = recurrent_dropout_training,\\n self.tens_to_log = tens_to_log,\\n self.checkpoint_path = None,\\n self.predict_batch_size = 30,\\n self.save_checkpoints_steps = 100,\\n self.keep_checkpoint_max = 10,\\n self.save_summary_steps = 20,\\n self.logging_step = 10\",\n \"def BuildCoreGraph(self):\\n # Input ids, with dynamic shape depending on input.\\n # Should be shape [batch_size, max_time] and contain integer word indices.\\n self.input_w_ = tf.placeholder(tf.int32, [None, None], name=\\\"w\\\")\\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_], name=\\\"w\\\")\\n\\n # Initial hidden state. You'll need to overwrite this with cell.zero_state\\n # once you construct your RNN cell.\\n self.initial_h_ = None\\n #tf.placeholder(tf.int32, [self.H,], name=\\\"h_i\\\")\\n #tf.Variable(tf.random_normal([H,]), name=\\\"h_i\\\")\\n\\n # Final hidden state. You'll need to overwrite this with the output from\\n # tf.nn.dynamic_rnn so that you can pass it in to the next batch (if\\n # applicable).\\n self.final_h_ = None\\n #tf.placeholder(tf.int32, [self.H,], name=\\\"h_f\\\")\\n #tf.Variable(tf.random_normal([H,]), name=\\\"h_f\\\")\\n\\n # Output logits, which can be used by loss functions or for prediction.\\n # Overwrite this with an actual Tensor of shape\\n # [batch_size, max_time, V].\\n self.logits_ = None\\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_, self.V], name=\\\"logits\\\")\\n #tf.Variable(tf.random_normal([self.batch_size_, self.max_time_, self.V]), name=\\\"logits\\\")\\n\\n # Should be the same shape as inputs_w_\\n self.target_y_ = tf.placeholder(tf.int32, [None, None], name=\\\"y\\\")\\n #tf.placeholder(tf.int32, [None, None], name=\\\"y\\\")\\n\\n # Replace this with an actual loss function\\n self.loss_ = None\\n #tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.labels_, logits=self.logits_),0)#don't forget last parameter\\n\\n # Get dynamic shape info from inputs\\n with tf.name_scope(\\\"batch_size\\\"):\\n self.batch_size_ = tf.shape(self.input_w_)[0]\\n with tf.name_scope(\\\"max_time\\\"):\\n self.max_time_ = tf.shape(self.input_w_)[1]\\n\\n # Get sequence length from input_w_.\\n # TL;DR: pass this to dynamic_rnn.\\n # This will be a vector with elements ns[i] = len(input_w_[i])\\n # You can override this in feed_dict if you want to have different-length\\n # sequences in the same batch, although you shouldn't need to for this\\n # assignment.\\n self.ns_ = tf.tile([self.max_time_], [self.batch_size_, ], name=\\\"ns\\\")#update this for project\\n\\n #### YOUR CODE HERE ####\\n # See hints in instructions!\\n\\n # Construct embedding layer\\n #self.W_in_ = tf.get_variable(\\\"W_in\\\", shape=[self.V, self.H], \\n #initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n #self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\\n \\n #self.W_in_ = tf.get_variable(tf.random_uniform([self.V, self.H], -1.0, 1.0), name=\\\"W_in\\\")\\n #Variable(tf.random_uniform([V, M], -1.0, 1.0), name=\\\"C\\\")\\n # embedding_lookup gives shape (batch_size, N, M)\\n #x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\\n \\n with tf.name_scope(\\\"embedding_layer\\\"):\\n self.W_in_ = tf.get_variable(\\\"W_in\\\", shape=[self.V, self.H], \\n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\\n\\n\\n\\n # Construct RNN/LSTM cell and recurrent layer.\\n with tf.name_scope(\\\"recurrent_layer\\\"):\\n self.cell_ = MakeFancyRNNCell(self.H, self.dropout_keep_prob_, self.num_layers)\\n self.initial_h_ = self.cell_.zero_state(self.batch_size_,tf.float32)\\n self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=self.x_, \\n sequence_length=self.ns_, initial_state=self.initial_h_,\\n dtype=tf.float32)\\n #print(self.outputs_.get_shape())\\n #self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=x_, \\n #sequence_length=self.ns_, initial_state=self.initial_h_,\\n #dtype=tf.float32)\\n \\n #W1_ = tf.Variable(tf.random_normal([N*M,H]), name=\\\"W1\\\")\\n #b1_ = tf.Variable(tf.zeros([H,], dtype=tf.float32), name=\\\"b1\\\")\\n #h_ = tf.tanh(tf.matmul(x_, W1_) + b1_, name=\\\"h\\\")\\n\\n\\n\\n\\n\\n # Softmax output layer, over vocabulary. Just compute logits_ here.\\n # Hint: the matmul3d function will be useful here; it's a drop-in\\n # replacement for tf.matmul that will handle the \\\"time\\\" dimension\\n # properly.\\n with tf.name_scope(\\\"softmax_output_layer\\\"):\\n self.W_out_ = tf.get_variable(\\\"W_out\\\", shape=[self.H, self.V], \\n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n #tf.get_variable(tf.random_uniform([self.H, self.V], -1.0, 1.0), name=\\\"W_out\\\")\\n\\n self.b_out_ = tf.get_variable(\\\"b_out\\\", shape=[self.V,], \\n initializer = tf.zeros_initializer())\\n #self.b_out_ = tf.get_variable(\\\"b_out\\\", shape=[self.V,], initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n #tf.get_variable(tf.random_uniform([self.V,], -1.0, 1.0), name=\\\"b_out\\\")\\n\\n self.logits_ = tf.add(matmul3d(self.outputs_, self.W_out_), self.b_out_, name=\\\"logits\\\")\\n #print(self.logits_.get_shape())\\n\\n\\n\\n # Loss computation (true loss, for prediction)\\n with tf.name_scope(\\\"loss_computation\\\"):\\n per_example_loss_ = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.target_y_, \\n logits=self.logits_, \\n name=\\\"per_example_loss\\\")\\n self.loss_ = tf.reduce_mean(per_example_loss_, name=\\\"loss\\\")\\n\\n\\n\\n #### END(YOUR CODE) ####\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7134765","0.69544786","0.6926675","0.68001246","0.6651791","0.6566028","0.6565687","0.638008","0.63594615","0.63141453","0.6299174","0.62913984","0.6288368","0.6231029","0.61889553","0.61449057","0.612983","0.60820633","0.60315627","0.6013897","0.59920675","0.5987377","0.5977691","0.5977407","0.59273916","0.59167576","0.59138685","0.5910982","0.58800834","0.58664817","0.58560675","0.5841385","0.58348316","0.5834066","0.5828423","0.5824593","0.5821416","0.58068234","0.5778823","0.57756174","0.57693964","0.57516426","0.57354546","0.5732244","0.57102233","0.5698352","0.56893283","0.5649766","0.56477404","0.5646928","0.56263626","0.55937123","0.55821514","0.558211","0.557798","0.5574521","0.55737853","0.55493593","0.5546122","0.5499126","0.54933757","0.5490494","0.5483441","0.54556924","0.5453264","0.54475415","0.54304373","0.54241145","0.54218566","0.54169214","0.54096645","0.5388485","0.53881735","0.5386813","0.5367765","0.5359346","0.53571284","0.53437704","0.5335231","0.53266007","0.5325248","0.5320717","0.5319166","0.5309825","0.5296833","0.5289435","0.52859735","0.5284626","0.5281951","0.5279597","0.5272202","0.5264839","0.525082","0.52480763","0.5234128","0.5229518","0.5226798","0.52265424","0.522223","0.5218368","0.51968294"],"string":"[\n \"0.7134765\",\n \"0.69544786\",\n \"0.6926675\",\n \"0.68001246\",\n \"0.6651791\",\n \"0.6566028\",\n \"0.6565687\",\n \"0.638008\",\n \"0.63594615\",\n \"0.63141453\",\n \"0.6299174\",\n \"0.62913984\",\n \"0.6288368\",\n \"0.6231029\",\n \"0.61889553\",\n \"0.61449057\",\n \"0.612983\",\n \"0.60820633\",\n \"0.60315627\",\n \"0.6013897\",\n \"0.59920675\",\n \"0.5987377\",\n \"0.5977691\",\n \"0.5977407\",\n \"0.59273916\",\n \"0.59167576\",\n \"0.59138685\",\n \"0.5910982\",\n \"0.58800834\",\n \"0.58664817\",\n \"0.58560675\",\n \"0.5841385\",\n \"0.58348316\",\n \"0.5834066\",\n \"0.5828423\",\n \"0.5824593\",\n \"0.5821416\",\n \"0.58068234\",\n \"0.5778823\",\n \"0.57756174\",\n \"0.57693964\",\n \"0.57516426\",\n \"0.57354546\",\n \"0.5732244\",\n \"0.57102233\",\n \"0.5698352\",\n \"0.56893283\",\n \"0.5649766\",\n \"0.56477404\",\n \"0.5646928\",\n \"0.56263626\",\n \"0.55937123\",\n \"0.55821514\",\n \"0.558211\",\n \"0.557798\",\n \"0.5574521\",\n \"0.55737853\",\n \"0.55493593\",\n \"0.5546122\",\n \"0.5499126\",\n \"0.54933757\",\n \"0.5490494\",\n \"0.5483441\",\n \"0.54556924\",\n \"0.5453264\",\n \"0.54475415\",\n \"0.54304373\",\n \"0.54241145\",\n \"0.54218566\",\n \"0.54169214\",\n \"0.54096645\",\n \"0.5388485\",\n \"0.53881735\",\n \"0.5386813\",\n \"0.5367765\",\n \"0.5359346\",\n \"0.53571284\",\n \"0.53437704\",\n \"0.5335231\",\n \"0.53266007\",\n \"0.5325248\",\n \"0.5320717\",\n \"0.5319166\",\n \"0.5309825\",\n \"0.5296833\",\n \"0.5289435\",\n \"0.52859735\",\n \"0.5284626\",\n \"0.5281951\",\n \"0.5279597\",\n \"0.5272202\",\n \"0.5264839\",\n \"0.525082\",\n \"0.52480763\",\n \"0.5234128\",\n \"0.5229518\",\n \"0.5226798\",\n \"0.52265424\",\n \"0.522223\",\n \"0.5218368\",\n \"0.51968294\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88991,"cells":{"query":{"kind":"string","value":"Construct a GRU RNN cell. It is configured to be passed to a multi rnn cell wrapper."},"document":{"kind":"string","value":"def build_gru_cell(num_units, dropout):\n cell = tf.nn.rnn_cell.GRUCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result"},"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 _initialize_gru_cell(self, num_units):\n return gru_cell.LayerNormGRUCell(\n num_units,\n w_initializer=self.uniform_initializer,\n u_initializer=random_orthonormal_initializer,\n b_initializer=tf.constant_initializer(0.0))","def build_rnn_cell(type, num_units, dropout):\n cell = tf.nn.rnn_cell.BasicRNNCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result","def rnn(input_size, rnn_size, rnn_len):\n num_rnn_layers = rnn_len\n assert num_rnn_layers >= 1\n hidden_size = rnn_size\n\n gru = nn.GRU(input_size=input_size, hidden_size=hidden_size, num_layers=num_rnn_layers, bias=True, batch_first=True, dropout=0, bidirectional=False)\n return gru","def create_rnn_cell(num_units,\n num_layers,\n num_residual_layers,\n dropout,\n mode,\n num_gpus,\n base_gpu=0,\n single_cell_fn=None,\n all_layer_outputs=False):\n cell_list = _cell_list(\n num_units=num_units,\n num_layers=num_layers,\n num_residual_layers=num_residual_layers,\n dropout=dropout,\n mode=mode,\n num_gpus=num_gpus,\n base_gpu=base_gpu,\n single_cell_fn=single_cell_fn)\n\n if len(cell_list) == 1: # Single layer.\n return cell_list[0]\n else: # Multi layers\n print(all_layer_outputs, \"all_layer_outputs\")\n\n if all_layer_outputs:\n return MultiRNNCell(cell_list)\n else:\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(RCRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = ResidualCNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=2,\n )\n #self.rnn2 = BidirectionalGRU(\n # n_in=nb_in*2,\n # n_hidden=n_RNN_cell,\n # dropout=dropout_recurrent,\n # num_layers=1,\n #)\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.relu = nn.ReLU()\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def _single_cell(num_units,\n dropout,\n mode,\n residual_connection=False,\n device_str=None):\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\n\n # Cell Type\n utils.print_out(\" GRU\", new_line=False)\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n utils.print_out(\n \" %s, dropout=%g \" % (type(single_cell).__name__, dropout),\n new_line=False)\n\n # Residual\n if residual_connection:\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\n utils.print_out(\" %s\" % type(single_cell).__name__, new_line=False)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\n utils.print_out(\n \" %s, device=%s\" % (type(single_cell).__name__, device_str),\n new_line=False)\n\n return single_cell","def init_gru(rnn):\n\n def _concat_init(tensor, init_funcs):\n (length, fan_out) = tensor.shape\n fan_in = length // len(init_funcs)\n\n for (i, init_func) in enumerate(init_funcs):\n init_func(tensor[i * fan_in: (i + 1) * fan_in, :])\n\n def _inner_uniform(tensor):\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\n\n for i in range(rnn.num_layers):\n _concat_init(\n getattr(rnn, 'weight_ih_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, _inner_uniform]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\n\n _concat_init(\n getattr(rnn, 'weight_hh_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)","def compile_gru_model(input_dim=101, output_dim=4563, recur_layers=3, nodes=1000,\n conv_context=11, conv_border_mode='valid', conv_stride=2,\n initialization='glorot_uniform', batch_norm=True, num_gpu=1):\n logger.info(\"Building gru model\")\n # Main acoustic input\n acoustic_input = Input(shape=(None, input_dim), name='acoustic_input')\n\n # Setup the network\n #conv_1d = Conv1D(nodes, conv_context, name='conv_1d',\n # padding='same', strides=conv_stride,\n # kernel_initializer=initialization,\n # activation='relu')(acoustic_input)\n conv_1d = Convolution1D(nodes, conv_context, name='conv1d',\n border_mode=conv_border_mode,\n subsample_length=conv_stride, init=initialization,\n activation='relu')(acoustic_input)\n if batch_norm:\n output = normalization.BatchNormalization(name='bn_conv_1d')(conv_1d, training=True)\n else:\n output = conv_1d\n\n for r in range(recur_layers):\n # output = GRU(nodes, activation='relu',\n # name='rnn_{}'.format(r + 1), init=initialization,\n # return_sequences=True)(output)\n output = Bidirectional(GRU(nodes, return_sequences=True),name='bi_lstm_{}'.format(r + 1))(output)\n if batch_norm:\n bn_layer = normalization.BatchNormalization(name='bn_rnn_{}'.format(r + 1),moving_mean_initializer='zeros')\n output = bn_layer(output, training=True)\n\n network_output = TimeDistributed(Dense(\n output_dim+1, name='dense', activation='softmax', init=initialization,\n ))(output)\n model = Model(input=acoustic_input, output=network_output)\n #model.conv_output_length = lambda x: conv_output_length(\n # x, conv_context, conv_border_mode, conv_stride)\n # model = ParallelModel(model, num_gpu)\n return model","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\n super(ConvGRUCell, self).__init__()\n self.height, self.width = input_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.hidden_dim = hidden_dim\n self.bias = bias\n self.dtype = dtype\n\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)\n\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\n out_channels=self.hidden_dim, # for candidate neural memory\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)","def __init__(\n self,\n input_size,\n hidden_size,\n num_layers=1,\n bidirectional=False,\n dropout=0,\n **kwargs\n ):\n super(GRU, self).__init__(\n 'gru', input_size, hidden_size,\n num_layers, bidirectional, dropout, **kwargs\n )","def build_multi_rnn(cells):\n return tf.nn.rnn_cell.MultiRNNCell(cells)","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(CRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = CNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=n_layers_RNN,\n )\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def init_gru(rnn):\n \n def _concat_init(tensor, init_funcs):\n (length, fan_out) = tensor.shape\n fan_in = length // len(init_funcs)\n \n for (i, init_func) in enumerate(init_funcs):\n init_func(tensor[i * fan_in : (i + 1) * fan_in, :])\n \n def _inner_uniform(tensor):\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\n \n for i in range(rnn.num_layers):\n _concat_init(\n getattr(rnn, 'weight_ih_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, _inner_uniform]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\n\n _concat_init(\n getattr(rnn, 'weight_hh_l{}'.format(i)),\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\n )\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)","def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\n if is_train:\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\n return cell","def make_cell(self, unit_type, num_units, forget_bias, dropout,\n mode, residual_connection=False):\n\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\n dropout = dropout if mode == tf.contrib.learn.ModeKeys.TRAIN else 0.0\n\n # Cell Type\n if unit_type == \"lstm\":\n cell = tf.contrib.rnn.BasicLSTMCell(\n num_units,\n forget_bias=forget_bias)\n elif unit_type == \"gru\":\n cell = tf.contrib.rnn.GRUCell(num_units)\n elif unit_type == \"layer_norm_lstm\":\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units,\n forget_bias=forget_bias,\n layer_norm=True)\n else:\n raise ValueError(\"Unknown unit type %s!\" % unit_type)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n cell = tf.contrib.rnn.DropoutWrapper(\n cell=cell, input_keep_prob=(1.0 - dropout))\n\n # Residual\n if residual_connection:\n cell = tf.contrib.rnn.ResidualWrapper(cell)\n\n return cell","def rnn_gru(\n nclass,\n input_shape=(187, 1),\n recurrent_layers=[64, 128],\n dense_layers=[64, 16],\n dropout=0.2,\n binary=False,\n):\n if not binary:\n loss = losses.sparse_categorical_crossentropy\n last_activation = activations.softmax\n else:\n loss = losses.binary_crossentropy\n last_activation = activations.sigmoid\n return_sequences = True\n\n inp = Input(shape=input_shape)\n x = inp\n for i, neurons in enumerate(recurrent_layers):\n x = GRU(neurons, return_sequences=return_sequences)(x)\n x = Dropout(rate=dropout)(x)\n return_sequences = False\n for i, neurons in enumerate(dense_layers):\n x = Dense(neurons, name=f\"dense_{i+1}\", activation=\"relu\")(x)\n x = Dense(nclass, name=\"Output\", activation=last_activation)(x)\n\n model = models.Model(inputs=inp, outputs=x)\n opt = optimizers.Adam(0.001)\n model.compile(optimizer=opt, loss=loss, metrics=[\"acc\"])\n model.summary()\n return model","def __init__(self, num_nodes, h_dim, out_dim, num_rels,\n num_bases=-1, num_hidden_layers=1, dropout=0.5, bias=False):\n super(RGCN, self).__init__()\n self.num_nodes = num_nodes\n self.h_dim = h_dim\n self.out_dim = out_dim\n self.num_rels = num_rels\n self.num_bases = num_bases\n self.num_hidden_layers = num_hidden_layers\n self.dropout = dropout\n self.bias = bias\n\n self.layers = nn.ModuleList()\n # create rgcn layers\n self.build_model()","def build_gru_model(num_features,\n embedding_size=None,\n kernel_size=None,\n filters=None,\n pool_size=None,\n gru_output_size=None):\n # Embedding\n if embedding_size is None:\n embedding_size = 64\n\n # Convolution\n if kernel_size is None:\n kernel_size = 5\n if filters is None:\n filters = 64\n if pool_size is None:\n pool_size = 4\n\n # GRU\n if gru_output_size is None:\n gru_output_size = 70\n\n print('Build model...')\n\n gru_model = models.gru(num_features,\n embedding_size=embedding_size,\n kernel_size=kernel_size,\n filters=filters,\n pool_size=pool_size,\n gru_output_size=gru_output_size)\n\n return gru_model","def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\n if layer_type == \"layernorm_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\n else:\n if layer_type == \"lstm\":\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\n elif layer_type == \"gru\":\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_gru\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\n else:\n raise ValueError(\"Error: not supported rnn type:{}\".format(layer_type))\n\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, output_keep_prob=dropout_keep_prob)\n return cell","def build_rnn(cell, inputs):\n #_,initial_state = get_init_cell(batch_size, rnn_size)\n \n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name='final_state')\n\n return (output, final_state)","def _create_rnn_cells(self, is_list=False):\n\n stacked_rnn = []\n for _ in range(self.num_layers):\n single_cell = self._rnn_single_cell()\n stacked_rnn.append(single_cell)\n\n if is_list:\n return stacked_rnn\n else:\n return tf.nn.rnn_cell.MultiRNNCell(\n cells=stacked_rnn,\n state_is_tuple=True)","def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\n #====================================================================================#\n # ----------PROBLEM 2----------\n #====================================================================================#\n # YOUR CODE HERE\n # raise NotImplementedError\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\n ## step 1 - inputs are first embedded by an MLP\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\n # print(\"after build_mlp x = \", x)\n ## step 2 - passed to a GRU cell\n # as \"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\"hidden\", dtype=tf.float32)\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\n # after build_mlp x = Tensor(\"continuous_logits/continuous_logits/fc1/BiasAdd:0\", shape=(?, 1, 32), dtype=float32)\n # x = tf.squeeze(x, axis=1)\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\n # print(\"dynamic_rnn build_mlp x = \", x, \" h = \", h)\n return x, h","def MakeFancyRNNCell(H, keep_prob, num_layers=1):\n cells = []\n for _ in range(num_layers):\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cells.append(cell)\n return tf.nn.rnn_cell.MultiRNNCell(cells)","def __init__(self, rnn_cell, batch_size,\n input_size, num_outputs):\n super().__init__(name='RNNCellStateModel')\n self._rnn_cell = rnn_cell\n self._batch_size = batch_size\n self._input_size = input_size\n self._num_outputs = num_outputs","def __init__(self,input_dim, hidden_dim, kernel_sizes, num_layers,gb_hidden_size):\r\n\r\n super().__init__()\r\n\r\n self.input_size = input_dim\r\n self.input_dim =input_dim\r\n\r\n if type(hidden_dim) != list:\r\n self.hidden_sizes = [hidden_dim]*num_layers\r\n else:\r\n assert len(hidden_dim) == num_layers, '`hidden_sizes` must have the same length as n_layers'\r\n self.hidden_sizes = hidden_dim\r\n if type(kernel_sizes) != list:\r\n self.kernel_sizes = [kernel_sizes]*num_layers\r\n else:\r\n assert len(kernel_sizes) == num_layers, '`kernel_sizes` must have the same length as n_layers'\r\n self.kernel_sizes = kernel_sizes\r\n\r\n self.n_layers = num_layers\r\n\r\n cells = nn.ModuleList()\r\n squenceCells=nn.ModuleList()\r\n\r\n for i in range(self.n_layers):\r\n\r\n if i == 0:\r\n input_dim = self.input_size\r\n else:\r\n input_dim = self.hidden_sizes[i-1]\r\n\r\n cell = ConvGRUCell(self.input_dim[i], self.hidden_sizes[i], 3)\r\n\r\n cells.append(cell)\r\n\r\n self.cells = cells\r\n\r\n\r\n for i in range(self.n_layers):\r\n\r\n squenceCell = SequenceGRU(gb_hidden_size[i])\r\n\r\n squenceCells.append(squenceCell)\r\n\r\n self.squenceCells = squenceCells","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):\n super(ModGRUCell, self).__init__()\n\n self.height, self.width = input_size\n self.input_dim = input_dim\n self.hidden_dim = hidden_dim\n\n self.kernel_size = kernel_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.bias = bias\n\n self.conv1 = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n out_channels=1,\n kernel_size=self.kernel_size,\n padding=self.padding,\n bias=self.bias)\n \n self.conv2 = nn.Conv2d(in_channels=self.input_dim,\n out_channels=self.hidden_dim,\n kernel_size=self.kernel_size,\n padding=self.padding,\n bias=self.bias)","def param_init_gru(options, params, prefix='gru', nin=None, dim=None):\n\tif nin == None:\n\t\tnin = options['dim_proj']\n\tif dim == None:\n\t\tdim = options['dim_proj']\n\tW = numpy.concatenate([norm_weight(nin,dim),\n\t\t\t\t\t\t norm_weight(nin,dim)], axis=1)\n\tparams[_p(prefix,'W')] = W\n\tparams[_p(prefix,'b')] = numpy.zeros((2 * dim,)).astype('float32')\n\tU = numpy.concatenate([ortho_weight(dim),\n\t\t\t\t\t\t ortho_weight(dim)], axis=1)\n\tparams[_p(prefix,'U')] = U\n\n\tWx = norm_weight(nin, dim)\n\tparams[_p(prefix,'Wx')] = Wx\n\tUx = ortho_weight(dim)\n\tparams[_p(prefix,'Ux')] = Ux\n\tparams[_p(prefix,'bx')] = numpy.zeros((dim,)).astype('float32')\n\n\treturn params","def __init__(self,\n num_units,\n num_dims=1,\n input_dims=None,\n output_dims=None,\n priority_dims=None,\n non_recurrent_dims=None,\n tied=False,\n cell_fn=None,\n non_recurrent_fn=None,\n state_is_tuple=True,\n output_is_tuple=True):\n if not state_is_tuple:\n logging.warning('%s: Using a concatenated state is slower and will '\n 'soon be deprecated. Use state_is_tuple=True.', self)\n if not output_is_tuple:\n logging.warning('%s: Using a concatenated output is slower and will '\n 'soon be deprecated. Use output_is_tuple=True.', self)\n\n if num_dims < 1:\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\n\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\n priority_dims, non_recurrent_dims,\n non_recurrent_fn or nn.relu, tied,\n num_units)\n\n self._state_is_tuple = state_is_tuple\n self._output_is_tuple = output_is_tuple\n\n if cell_fn is None:\n my_cell_fn = functools.partial(\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\n else:\n my_cell_fn = lambda: cell_fn(num_units)\n if tied:\n self._cells = [my_cell_fn()] * num_dims\n else:\n self._cells = [my_cell_fn() for _ in range(num_dims)]\n if not isinstance(self._cells[0], rnn.RNNCell):\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\n type(self._cells[0]))\n\n if self._output_is_tuple:\n self._output_size = tuple(self._cells[0].output_size\n for _ in self._config.outputs)\n else:\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\n\n if self._state_is_tuple:\n self._state_size = tuple(self._cells[0].state_size\n for _ in self._config.recurrents)\n else:\n self._state_size = self._cell_state_size() * len(self._config.recurrents)","def rnn_gru_bidir(\n nclass,\n input_shape=(187, 1),\n recurrent_layers=[64, 128],\n dense_layers=[64, 16],\n dropout=0.2,\n binary=False,\n):\n if not binary:\n loss = losses.sparse_categorical_crossentropy\n last_activation = activations.softmax\n else:\n loss = losses.binary_crossentropy\n last_activation = \"sigmoid\"\n return_sequences = True\n\n inp = Input(shape=input_shape)\n x = inp\n for i, neurons in enumerate(recurrent_layers):\n layer = GRU(neurons, return_sequences=return_sequences)\n x = Bidirectional(layer)(x)\n x = Dropout(rate=dropout)(x)\n return_sequences = False\n for i, neurons in enumerate(dense_layers):\n x = Dense(neurons, name=f\"dense_{i+1}\", activation=\"relu\")(x)\n x = Dense(nclass, name=\"Output\", activation=last_activation)(x)\n\n model = models.Model(inputs=inp, outputs=x)\n opt = optimizers.Adam(0.001)\n model.compile(optimizer=opt, loss=loss, metrics=[\"acc\"])\n model.summary()\n return model","def __call__(self, inputs, state, scope=None, *args, **kwargs):\r\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\r\n # Instead, it is up to subclasses to provide a proper build\r\n # method. See the class docstring for more details.\r\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\r\n *args, **kwargs)","def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\n readout_init, readout_apply = stax.Dense(num_outputs)\n\n def init_fun(key, input_shape):\n \"\"\"Initialize the components of the RNN.\n\n Args:\n key: Jax PRNGkey used to initialize the parameters.\n input_shape: tuple representing the input shape, should be\n (batch_size, sequence_length).\n\n Returns:\n shapes: set of tuples representing the shapes after applying\n the Embedding, RNN Cell, and Readout layers.\n network_params: tuple of network parameters, containing the\n embedding, RNN cell, and readout parameters.\n \"\"\"\n\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\n\n # Initialize the Embedding for the input tokens.\n emb_shape, emb_params = emb_init(emb_key, input_shape)\n\n # The cell is defined for a single update step, which is why we ignore\n # the sequence dimension (emb_shape[1]) here.\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\n\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\n\n shapes = (emb_shape, rnn_shape, output_shape)\n network_params = (emb_params, rnn_params, readout_params)\n\n return shapes, network_params\n\n def apply_fun(network_params, tokens):\n \"\"\"Applies the RNN on a batch of input sequences.\n\n Args:\n network_params: tuple of network parameters (see init_fun).\n tokens: batch of inputs, with shape (batch_size, sequence_length).\n\n Returns:\n outputs: network outputs, at every step along the sequence.\n \"\"\"\n emb_params, rnn_params, readout_params = network_params\n\n # Apply the embedding.\n inputs = emb_apply(emb_params, tokens)\n\n # Run the RNN.\n initial_states = cell.get_initial_state(rnn_params,\n batch_size=tokens.shape[0])\n return unroll.unroll_rnn(initial_states, inputs,\n functools.partial(cell.batch_apply, rnn_params),\n functools.partial(readout_apply, readout_params))\n\n return init_fun, apply_fun, emb_apply, readout_apply","def GRU(previous_hidden_state, x):\n # R Gate\n r = tf.sigmoid(tf.matmul(x, Wr) + \\\n tf.matmul(previous_hidden_state, Ur) + br)\n # U Gate\n u = tf.sigmoid(tf.matmul(x, Wu) + \\\n tf.matmul(previous_hidden_state, Uu) + bu)\n # Final Memory cell\n c = tf.tanh(tf.matmul(x, Wh) + \\\n tf.matmul( tf.multiply(r, previous_hidden_state), Uh) + bh)\n # Current Hidden state\n current_hidden_state = tf.multiply( (1 - u), previous_hidden_state ) + \\\n tf.multiply( u, c )\n return current_hidden_state","def build_rnn(cell, inputs):\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name=\"final_state\")\n\n return outputs, final_state","def get_gru_node_gene(key, config):\n gene1 = GruNodeGene(key, config, input_keys=[-1], input_keys_full=[-1, -2])\n gene1.activation = 'a'\n gene1.bias_hh = np.zeros(gene1.bias_hh.shape)\n gene1.bias_ih = np.zeros(gene1.bias_ih.shape)\n gene1.weight_hh = np.zeros(gene1.weight_hh.shape)\n gene1.weight_ih_full = np.zeros(gene1.weight_ih_full.shape)\n gene1.update_weight_ih()\n gene2 = GruNodeGene(key, config, input_keys=[-1], input_keys_full=[-1, -3])\n gene2.activation = 'b'\n gene2.bias_hh = np.ones(gene2.bias_hh.shape)\n gene2.bias_ih = np.ones(gene2.bias_ih.shape)\n gene2.weight_hh = np.ones(gene2.weight_hh.shape)\n gene2.weight_ih_full = np.ones(gene2.weight_ih_full.shape)\n gene2.update_weight_ih()\n return gene1, gene2","def __init__(\n self,\n model_type,\n num_features,\n num_classes,\n reparam_mode,\n prior_mode,\n latent_size,\n sample_size=1,\n num_layers=2,\n struct_dropout_mode=(\"standard\", 0.6),\n dropout=True,\n with_relu=True,\n val_use_mean=True,\n reparam_all_layers=True,\n normalize=True,\n is_cuda=False,\n ):\n super(GNN, self).__init__()\n self.model_type = model_type\n self.num_features = num_features\n self.num_classes = num_classes\n self.normalize = normalize\n self.reparam_mode = reparam_mode\n self.prior_mode = prior_mode\n self.struct_dropout_mode = struct_dropout_mode\n self.dropout = dropout\n self.latent_size = latent_size\n self.sample_size = sample_size\n self.num_layers = num_layers\n self.with_relu = with_relu\n self.val_use_mean = val_use_mean\n self.reparam_all_layers = reparam_all_layers\n self.is_cuda = is_cuda\n self.device = torch.device(self.is_cuda if isinstance(self.is_cuda, str) else \"cuda\" if self.is_cuda else \"cpu\")\n\n self.init()","def _create_rnn_cell(num_units, num_layers, mode):\n\n cell_list = []\n for i in range(num_layers):\n single_cell = STLSTMCell(name=\"stlstm\",\n num_units=num_units,\n st_activation=tf.nn.relu,\n st_kernel_initializer=tf.glorot_uniform_initializer(),\n st_num_layers=2,\n st_residual=True)\n cell_list.append(single_cell)\n\n return cell_list","def __init__(self, input_size, hidden_size, output_size, model=\"gru\", n_layers=1):\n \n super(CharRNN, self).__init__()\n\n self.input_size = input_size\n self.hidden_size = hidden_size\n self.output_size = output_size\n self.n_layers = n_layers\n\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\n \n self.model = model\n if model.lower() == \"lstm\":\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\n else: # model is GRU\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\n\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer","def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\n if rnn_type.endswith('lstm'):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n elif rnn_type.endswith('gru'):\n cell = tc.rnn.GRUCell(num_units=hidden_size)\n elif rnn_type.endswith('rnn'):\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\n else:\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n if layer_num > 1:\n cell = tc.rnn.MultiRNNCell([cell] * layer_num, state_is_tuple=True)\n return cell","def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\n residual_connection=False, device_str=None):\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\n dropout = dropout if mode == \"train\" else 0.0\n # Cell Type\n if unit_type == \"lstm\":\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\n\n elif unit_type == \"gru\":\n single_cell = tf.contrib.rnn.GRUCell(num_units)\n\n elif unit_type == \"layer_norm_lstm\":\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units,layer_norm=True)\n else:\n raise ValueError(\"Unknown unit type %s!\" % unit_type)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.contrib.rnn.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n\n # Residual\n if residual_connection:\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\n\n return single_cell","def rnn_cell(hprev, zt, name=None, reuse=False):\n nin = zt.shape[-1].value\n nout = hprev.shape[-1].value\n with tf.variable_scope(name, default_name=\"rnn\", values=[hprev, zt], reuse=reuse):\n wz = get_variable_wrap(\"kernel/input\", [nin, nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n wh = get_variable_wrap(\"kernel/hidden\", [nout, nout],dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n bh = get_variable_wrap(\"bias\", [nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n \n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)","def __call__(self, inputs, state, scope=None):\n with vs.variable_scope(scope or type(self).__name__): # \"GRUCell\" \n with vs.variable_scope(\"Gates\"): # Reset gate and update gate. \n # We start with bias of 1.0 to not reset and not update. \n r, u = array_ops.split(1, 2, rnn_cell.linear([inputs, state],\n 2 * self._num_units, True, 1.0))\n r, u = tf.sigmoid(r), tf.sigmoid(u)\n with vs.variable_scope(\"Candidate\"):\n c = self._activation(rnn_cell.linear([inputs, r * state], self._num_units, True))\n new_h = u * state + (1 - u) * c\n return new_h, new_h","def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\n cells = []\n for layer_size in rnn_cell_size:\n cell = rnn.LSTMBlockCell(layer_size)\n cell = rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return rnn.MultiRNNCell(cells)","def constructCell():\n\t\tself.weightGenerate()","def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\n is_training=False, cell_name=\"GRU\", bidirectional=False, swap_memory=False):\n batch_size = tf.shape(X)[0]\n if bidirectional:\n rnn_size /= 2\n\n def get_cell():\n if cell_name == \"GRU\": # GRU\n _cell = rnn_cell.GRUCell(rnn_size)\n elif cell_name == \"LSTM\": # LSTM\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\n else:\n raise ValueError(\"Unrecognized Cell Name: {0}\".format(cell_name))\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\n _initial_state = _cell.zero_state(batch_size, tf.float32)\n return _cell, _initial_state\n\n if bidirectional:\n with tf.variable_scope(\"forward\"):\n cell_fw, initial_state_fw = get_cell()\n with tf.variable_scope(\"backward\"):\n cell_bw, initial_state_bw = get_cell()\n return rnn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, X, sequence_length=seq_len,\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\n else:\n cell, initial_state = get_cell()\n return rnn.dynamic_rnn(\n cell, X, sequence_length=seq_len, initial_state=initial_state,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)","def __init__(self, encoder_type=\"uni\", num_layers=1,\n cell_type=\"gru\", num_units=512, dropout=0.8,\n dtype=tf.float32):\n\n self.encoder_type = encoder_type\n self.num_layers = num_layers\n self.cell_type = cell_type\n self.num_units = num_units\n self.dropout = dropout\n self.dtype = dtype","def __init__(self, cell, attn_inputs, \n attn_size, attn_vec_size,\n output_size=None, input_size=None, \n state_is_tuple=True, attn_masks=None,\n merge_output_attn='linear',\n reuse=None):\n if not isinstance(cell, rnn.RNNCell):\n raise TypeError(\"The parameter cell is not RNNCell.\")\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\n raise ValueError(\"Cell returns tuple of states, but the flag \"\n \"state_is_tuple is not set. State size is: %s\"\n % str(cell.state_size))\n if not state_is_tuple:\n logging.warn(\n \"%s: Using a concatenated state is slower and will soon be \"\n \"deprecated. Use state_is_tuple=True.\", self)\n\n self._state_is_tuple = state_is_tuple\n\n if not state_is_tuple:\n raise NotImplementedError\n\n self._cell = cell\n self._input_size = input_size\n self._output_size = output_size\n if output_size is None:\n self._output_size = cell.output_size\n self._attn_size = attn_size\n self._reuse = reuse\n self._attn_inputs = attn_inputs\n self._attn_vec_size = attn_vec_size\n self.attn_masks = attn_masks\n self.merge_output_attn = merge_output_attn","def get_init_cell(batch_size, rnn_size):\n\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\n num_of_layers = 3\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name='initial_state')\n \n return (cell, initial_state)","def gru_cell(self, Xt, h_t_minus_1):\n # 1.update gate: decides how much past information is kept and how much new information is added.\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z) + tf.matmul(h_t_minus_1,self.U_z) + self.b_z) # z_t:[batch_size,self.hidden_size]\n # 2.reset gate: controls how much the past state contributes to the candidate state.\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r) + tf.matmul(h_t_minus_1,self.U_r) + self.b_r) # r_t:[batch_size,self.hidden_size]\n # candiate state h_t~\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h) +r_t * (tf.matmul(h_t_minus_1, self.U_h)) + self.b_h) # h_t_candiate:[batch_size,self.hidden_size]\n # new state: a linear combine of pervious hidden state and the current new state h_t~\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\n return h_t","def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\n is_batch_norm, is_bidirectional):\n if is_batch_norm:\n input_data = tf.keras.layers.BatchNormalization(\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\n rnn_layer = rnn_cell(\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\n name=\"rnn_{}\".format(layer_id))\n if is_bidirectional:\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\"sum\")\n\n return rnn_layer(input_data)","def bidirectional_gru_encoder(cell_fw, cell_bw, embedding, init_state, batch_input_fw, batch_input_bw, batch_mask):\n # Forward direction\n outputs_fw, _ = gru_encoder(cell_fw, embedding, init_state, batch_input_fw, batch_mask)\n\n # Backward direction\n outputs_bw, _ = gru_encoder(cell_bw, embedding, init_state, batch_input_bw, batch_mask)\n\n outputs = [tf.concat(1, [fw, bw]) for fw, bw in zip(outputs_fw, outputs_bw)]\n return outputs","def convert_rnn(g, op, block):\n\n def generate_lstm(\n input_seqs,\n hidden_state,\n cell_state,\n w_inp,\n w_hid,\n b_inp,\n b_hid,\n f_act,\n g_act,\n h_act,\n backwards=False,\n ):\n \"\"\"Implementation of LSTM cell for paddlepaddle of TVM\"\"\"\n\n h_list = []\n seq_length = len(input_seqs)\n for i in range(seq_length):\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\n step = _op.squeeze(step, axis=[0])\n gates = _op.nn.dense(step, w_inp) + _op.nn.dense(hidden_state, w_hid)\n if b_inp is not None:\n gates += b_inp\n if b_hid is not None:\n gates += b_hid\n i, f, c, o = _op.split(gates, 4, axis=-1)\n\n i = f_act(i)\n f = f_act(f)\n\n c = g_act(c)\n C = f * cell_state + i * c\n\n o = f_act(o)\n\n H = o * h_act(C)\n\n hidden_state = H\n cell_state = C\n h_list.append(_op.expand_dims(H, axis=0))\n\n if backwards:\n h_list = h_list[::-1]\n\n # Concatenate outputs and add back in direction axis.\n concatenated = _op.concatenate(h_list, 0)\n output = _op.expand_dims(concatenated, axis=1)\n hidden_state = _op.expand_dims(hidden_state, axis=0)\n cell_state = _op.expand_dims(cell_state, axis=0)\n\n return output, hidden_state, cell_state\n\n def generate_gru(\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, rz_act, n_act, backwards=False\n ):\n \"\"\"Implementation of GRU cell for paddlepaddle of TVM\"\"\"\n\n h_list = []\n seq_length = len(input_seqs)\n for i in range(seq_length):\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\n step = _op.squeeze(step, axis=[0])\n xwt = _op.nn.dense(step, w_inp)\n hwt = _op.nn.dense(hidden_state, w_hid)\n if b_inp is not None:\n xwt += b_inp\n if b_hid is not None:\n hwt += b_hid\n i_r, i_z, i_n = _op.split(xwt, 3, axis=-1)\n h_r, h_z, h_n = _op.split(hwt, 3, axis=-1)\n\n r_gate = rz_act(i_r + h_r)\n z_gate = rz_act(i_z + h_z)\n n_gate = n_act(i_n + r_gate * h_n)\n\n hidden_state = (hidden_state - n_gate) * z_gate + n_gate\n h_list.append(_op.expand_dims(hidden_state, axis=0))\n\n if backwards:\n h_list = h_list[::-1]\n\n # Concatenate outputs and add back in direction axis.\n concatenated = _op.concatenate(h_list, 0)\n output = _op.expand_dims(concatenated, axis=1)\n hidden_state = _op.expand_dims(hidden_state, axis=0)\n\n return output, hidden_state\n\n def generate_simplernn(\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, n_act, backwards=False\n ):\n \"\"\"Implementation of SimpleRNN cell for paddlepaddle of TVM\"\"\"\n\n h_list = []\n seq_length = len(input_seqs)\n for i in range(seq_length):\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\n step = _op.squeeze(step, axis=[0])\n xwt = _op.nn.dense(step, w_inp)\n hwt = _op.nn.dense(hidden_state, w_hid)\n if b_inp is not None:\n xwt += b_inp\n if b_hid is not None:\n hwt += b_hid\n\n n_gate = n_act(xwt + hwt)\n\n hidden_state = n_gate\n h_list.append(_op.expand_dims(hidden_state, axis=0))\n\n if backwards:\n h_list = h_list[::-1]\n\n # Concatenate outputs and add back in direction axis.\n concatenated = _op.concatenate(h_list, 0)\n output = _op.expand_dims(concatenated, axis=1)\n hidden_state = _op.expand_dims(hidden_state, axis=0)\n\n return output, hidden_state\n\n def make_param_inputs(g, node, layer, hidden_size, num_layers):\n \"\"\"Param for weight and bias.\"\"\"\n\n bidirect_len = 4 if node.attr(\"is_bidirec\") else 2\n all_layer_param_len = len(node.input(\"WeightList\"))\n weight_list = node.input(\"WeightList\")[: all_layer_param_len // 2]\n bias_list = node.input(\"WeightList\")[all_layer_param_len // 2 :]\n\n layer_weight_list = weight_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\n layer_bias_list = bias_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\n param_list = layer_weight_list + layer_bias_list\n param_list_len = len(param_list)\n\n input_weights = param_list[0 : param_list_len // 2 : 2]\n hidden_weights = param_list[1 : param_list_len // 2 : 2]\n\n input_bias = param_list[param_list_len // 2 : param_list_len : 2]\n hidden_bias = param_list[param_list_len // 2 + 1 : param_list_len : 2]\n\n return input_weights, hidden_weights, input_bias, hidden_bias\n\n def make_init_param_inputs(g, node, layer):\n \"\"\"Init param for inputs.\"\"\"\n\n mode = node.attr(\"mode\")\n if mode == \"LSTM\":\n all_init_h, all_init_c = node.input(\"PreState\")\n bidirect_len = 2 if node.attr(\"is_bidirec\") else 1\n init_h = _op.strided_slice(\n g.get_node(all_init_h),\n [layer * bidirect_len],\n [layer * bidirect_len + bidirect_len],\n axes=[0],\n )\n init_c = _op.strided_slice(\n g.get_node(all_init_c),\n [layer * bidirect_len],\n [layer * bidirect_len + bidirect_len],\n axes=[0],\n )\n return init_h, init_c\n all_init_h = node.input(\"PreState\")[0]\n bidirect_len = 2 if node.attr(\"is_bidirec\") else 1\n init_h = _op.strided_slice(\n g.get_node(all_init_h),\n [layer * bidirect_len],\n [layer * bidirect_len + bidirect_len],\n axes=[0],\n )\n return init_h\n\n hidden_size = op.attr(\"hidden_size\")\n num_layers = op.attr(\"num_layers\")\n is_bidirec = op.attr(\"is_bidirec\")\n mode = op.attr(\"mode\")\n\n input_x = g.get_node(op.input(\"Input\")[0])\n\n num_directions = 1\n if is_bidirec:\n num_directions = 2\n\n x_shape = infer_shape(input_x)\n time_steps = x_shape[0]\n x_steps = _op.split(input_x, indices_or_sections=time_steps, axis=0)\n for layer in range(num_layers):\n input_weights, hidden_weights, input_bias, hidden_bias = make_param_inputs(\n g, op, layer, hidden_size, num_layers\n )\n if mode == \"LSTM\":\n init_h, init_c = make_init_param_inputs(g, op, layer)\n init_hs = _op.split(init_h, num_directions)\n init_cs = _op.split(init_c, num_directions)\n result_output = []\n result_H = []\n result_C = []\n for i in range(num_directions):\n H_t = _op.squeeze(init_hs[i], axis=[0])\n C_t = _op.squeeze(init_cs[i], axis=[0])\n W = g.get_node(input_weights[i])\n R = g.get_node(hidden_weights[i])\n WB = g.get_node(input_bias[i])\n RB = g.get_node(hidden_bias[i])\n output, H, C = generate_lstm(\n input_seqs=x_steps,\n hidden_state=H_t,\n cell_state=C_t,\n w_inp=W,\n w_hid=R,\n b_inp=WB,\n b_hid=RB,\n f_act=_op.sigmoid,\n g_act=_op.tanh,\n h_act=_op.tanh,\n backwards=i == 1,\n )\n result_output.append(output)\n result_H.append(H)\n result_C.append(C)\n output = _op.concatenate(result_output, axis=1)\n H = _op.concatenate(result_H, axis=0)\n C = _op.concatenate(result_C, axis=0)\n elif mode == \"GRU\":\n init_h = make_init_param_inputs(g, op, layer)\n init_hs = _op.split(init_h, num_directions)\n result_output = []\n result_H = []\n for i in range(num_directions):\n H_t = _op.squeeze(init_hs[i], axis=[0])\n W = g.get_node(input_weights[i])\n R = g.get_node(hidden_weights[i])\n WB = g.get_node(input_bias[i])\n RB = g.get_node(hidden_bias[i])\n output, H = generate_gru(\n input_seqs=x_steps,\n hidden_state=H_t,\n w_inp=W,\n w_hid=R,\n b_inp=WB,\n b_hid=RB,\n rz_act=_op.sigmoid,\n n_act=_op.tanh,\n backwards=i == 1,\n )\n result_output.append(output)\n result_H.append(H)\n output = _op.concatenate(result_output, axis=1)\n H = _op.concatenate(result_H, axis=0)\n elif mode == \"RNN_TANH\":\n init_h = make_init_param_inputs(g, op, layer)\n init_hs = _op.split(init_h, num_directions)\n result_output = []\n result_H = []\n for i in range(num_directions):\n H_t = _op.squeeze(init_hs[i], axis=[0])\n W = g.get_node(input_weights[i])\n R = g.get_node(hidden_weights[i])\n WB = g.get_node(input_bias[i])\n RB = g.get_node(hidden_bias[i])\n output, H = generate_simplernn(\n input_seqs=x_steps,\n hidden_state=H_t,\n w_inp=W,\n w_hid=R,\n b_inp=WB,\n b_hid=RB,\n n_act=_op.tanh,\n backwards=i == 1,\n )\n result_output.append(output)\n result_H.append(H)\n output = _op.concatenate(result_output, axis=1)\n H = _op.concatenate(result_H, axis=0)\n\n output = _op.transpose(output, axes=[0, 2, 1, 3])\n output = _op.reshape(output, newshape=(0, 0, -1))\n x_steps = _op.split(output, indices_or_sections=time_steps, axis=0)\n\n g.add_node(op.output(\"Out\")[0], output)","def get_init_cell(batch_size, rnn_size):\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name=\"initial_state\")\n\n return cell, initial_state","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embed = get_embed(input_data, vocab_size, embed_dim) \n output, final_state = build_rnn(cell, embed)\n \n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\n #final_state = tf.identity(final_state, name='final_state') \n return logits, final_state","def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\n state_keep_prob=1.0, variational_recurrent=False,\n input_size=None, dtype=None, seed=None,\n dropout_state_filter_visitor=None):\n if not _like_rnncell(cell):\n raise TypeError(\"The parameter cell is not a RNNCell.\")\n if (dropout_state_filter_visitor is not None\n and not callable(dropout_state_filter_visitor)):\n raise TypeError(\"dropout_state_filter_visitor must be callable\")\n self._dropout_state_filter = (\n dropout_state_filter_visitor or _default_dropout_state_filter_visitor)\n with ops.name_scope(\"DropoutWrapperInit\"):\n def tensor_and_const_value(v):\n tensor_value = ops.convert_to_tensor(v)\n const_value = tensor_util.constant_value(tensor_value)\n return (tensor_value, const_value)\n for prob, attr in [(input_keep_prob, \"input_keep_prob\"),\n (state_keep_prob, \"state_keep_prob\"),\n (output_keep_prob, \"output_keep_prob\")]:\n tensor_prob, const_prob = tensor_and_const_value(prob)\n if const_prob is not None:\n if const_prob < 0 or const_prob > 1:\n raise ValueError(\"Parameter %s must be between 0 and 1: %d\"\n % (attr, const_prob))\n setattr(self, \"_%s\" % attr, float(const_prob))\n else:\n setattr(self, \"_%s\" % attr, tensor_prob)\n\n # Set cell, variational_recurrent, seed before running the code below\n self._cell = cell\n self._variational_recurrent = variational_recurrent\n self._seed = seed\n\n self._recurrent_input_noise = None\n self._recurrent_state_noise = None\n self._recurrent_output_noise = None\n\n if variational_recurrent:\n if dtype is None:\n raise ValueError(\n \"When variational_recurrent=True, dtype must be provided\")\n\n def convert_to_batch_shape(s):\n # Prepend a 1 for the batch dimension; for recurrent\n # variational dropout we use the same dropout mask for all\n # batch elements.\n return array_ops.concat(\n ([1], tensor_shape.TensorShape(s).as_list()), 0)\n\n def batch_noise(s, inner_seed):\n shape = convert_to_batch_shape(s)\n return random_ops.random_uniform(shape, seed=inner_seed, dtype=dtype)\n\n if (not isinstance(self._input_keep_prob, numbers.Real) or\n self._input_keep_prob < 1.0):\n if input_size is None:\n raise ValueError(\n \"When variational_recurrent=True and input_keep_prob < 1.0 or \"\n \"is unknown, input_size must be provided\")\n self._recurrent_input_noise = _enumerated_map_structure_up_to(\n input_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"input\", i)),\n input_size)\n self._recurrent_state_noise = _enumerated_map_structure_up_to(\n cell.state_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"state\", i)),\n cell.state_size)\n self._recurrent_output_noise = _enumerated_map_structure_up_to(\n cell.output_size,\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\"output\", i)),\n cell.output_size)","def __init__(self, num_nodes, num_features, num_timesteps_input,\n num_timesteps_output, gcn_type='normal', hidden_size=64, num_comps=10):\n super(KRNN, self).__init__()\n self.encoders = nn.ModuleList()\n self.decoders = nn.ModuleList()\n self.linears = nn.ModuleList()\n\n self.num_timesteps_output = num_timesteps_output\n\n for r in range(num_comps):\n self.encoders.append(\n nn.GRU(num_features, hidden_size)\n )\n self.decoders.append(\n nn.GRUCell(1, hidden_size)\n )\n self.linears.append(\n nn.Linear(hidden_size, 1)\n )\n\n self.embed = nn.Parameter(torch.FloatTensor(num_nodes, num_comps))\n self.embed.data.normal_()","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embedding = get_embed(input_data, vocab_size, rnn_size)\n outputs, final_state = build_rnn(cell, embedding)\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\n\n return logits, final_state","def build(self, input_tensors, is_training, lengths=None, hparams=None):\n input_tensor = input_tensors[-1]\n rnn_cell = tf.compat.v1.nn.rnn_cell.BasicRNNCell(\n num_units=self._output_size, activation=tf.nn.tanh)\n net, _ = tf.compat.v1.nn.dynamic_rnn(\n rnn_cell, input_tensor, sequence_length=lengths, dtype=tf.float32)\n\n if self._skip:\n net += _add_projection_if_needed(input_tensor, net)\n\n return input_tensors + [net]","def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\n\t\treturn _mh.create_rnn_cell(\n\t\t\tunit_type=hparams.unit_type,\n\t\t\tnum_units=self.num_units,\n\t\t\tnum_layers=num_layers,\n\t\t\tnum_residual_layers=num_residual_layers,\n\t\t\tforget_bias=hparams.forget_bias,\n\t\t\tdropout=hparams.dropout,\n\t\t\tmode=self.mode)","def _rnn_relu_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):\n if b_ih is None:\n igates = P.MatMul(False, True)(inputs, w_ih)\n hgates = P.MatMul(False, True)(hidden, w_hh)\n else:\n igates = P.MatMul(False, True)(inputs, w_ih) + b_ih\n hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh\n return P.ReLU()(igates + hgates)","def _rnn_cells(self) -> RNNCellTuple:\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))","def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\n cells = []\n for layer_size in rnn_cell_size:\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\n if attn_len and not cells:\n # Add attention wrapper to first layer.\n cell = tf.contrib.rnn.AttentionCellWrapper(\n cell, attn_len, state_is_tuple=True)\n cell = tf.contrib.rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return tf.contrib.rnn.MultiRNNCell(cells)","def __init__(self,\n num_units,\n forget_bias=1.0,\n activation=None,\n reuse=None,\n layer_norm: bool=False,\n norm_shift: float=0.0,\n norm_gain: float=1.0, # layer normalization\n dropout_keep_prob_in: float = 1.0,\n dropout_keep_prob_h: float=1.0,\n dropout_keep_prob_out: float=1.0,\n dropout_keep_prob_gate: float=1.0,\n dropout_keep_prob_forget: float=1.0,\n dropout_prob_seed: int=None,\n variational_dropout: bool=False,\n recurrent_dropout: bool=False\n ):\n super(CustomLSTMCell, self).__init__(_reuse=reuse)\n self._num_units = num_units\n self._forget_bias = forget_bias\n self._activation = activation or math_ops.tanh\n\n self._layer_norm = layer_norm\n self._g = norm_gain\n self._b = norm_shift\n\n self._recurrent_dropout = recurrent_dropout\n self._variational_dropout = variational_dropout\n \n self._seed = dropout_prob_seed\n self._keep_prob_i = dropout_keep_prob_in\n self._keep_prob_g = dropout_keep_prob_gate\n self._keep_prob_f = dropout_keep_prob_forget\n self._keep_prob_o = dropout_keep_prob_out\n self._keep_prob_h = dropout_keep_prob_h","def gru_layer(tparams, state_below, options, prefix='gru', mask=None, **kwargs):\n\tnsteps = state_below.shape[0]\n\tif state_below.ndim == 3:\n\t\tn_samples = state_below.shape[1]\n\telse:\n\t\tn_samples = 1\n\n\tdim = tparams[_p(prefix,'Ux')].shape[1]\n\n\tif mask == None:\n\t\tmask = tensor.alloc(1., state_below.shape[0], 1)\n\n\tdef _slice(_x, n, dim):\n\t\tif _x.ndim == 3:\n\t\t\treturn _x[:, :, n*dim:(n+1)*dim]\n\t\treturn _x[:, n*dim:(n+1)*dim]\n\n\tstate_below_ = tensor.dot(state_below, tparams[_p(prefix, 'W')]) + tparams[_p(prefix, 'b')]\n\tstate_belowx = tensor.dot(state_below, tparams[_p(prefix, 'Wx')]) + tparams[_p(prefix, 'bx')]\n\tU = tparams[_p(prefix, 'U')]\n\tUx = tparams[_p(prefix, 'Ux')]\n\n\tdef _step_slice(m_, x_, xx_, h_, U, Ux):\n\t\tpreact = tensor.dot(h_, U)\n\t\tpreact += x_\n\n\t\tr = tensor.nnet.sigmoid(_slice(preact, 0, dim))\n\t\tu = tensor.nnet.sigmoid(_slice(preact, 1, dim))\n\n\t\tpreactx = tensor.dot(h_, Ux)\n\t\tpreactx = preactx * r\n\t\tpreactx = preactx + xx_\n\n\t\th = tensor.tanh(preactx)\n\n\t\th = u * h_ + (1. - u) * h\n\t\th = m_[:,None] * h + (1. - m_)[:,None] * h_\n\n\t\treturn h\n\n\tseqs = [mask, state_below_, state_belowx]\n\t_step = _step_slice\n\n\trval, updates = theano.scan(_step,\n\t\t\t\t\t\t\t\tsequences=seqs,\n\t\t\t\t\t\t\t\toutputs_info = [tensor.alloc(0., n_samples, dim)],\n\t\t\t\t\t\t\t\tnon_sequences = [tparams[_p(prefix, 'U')],\n\t\t\t\t\t\t\t\t\t\t\t\t tparams[_p(prefix, 'Ux')]],\n\t\t\t\t\t\t\t\tname=_p(prefix, '_layers'),\n\t\t\t\t\t\t\t\tn_steps=nsteps,\n\t\t\t\t\t\t\t\tprofile=profile,\n\t\t\t\t\t\t\t\tstrict=True)\n\trval = [rval]\n\treturn rval","def __init__(self, num_units,\n use_peepholes=False, cell_clip=None,\n initializer=None, num_proj=None, proj_clip=None,\n num_unit_shards=None, num_proj_shards=None,\n forget_bias=1.0, state_is_tuple=False,\n activation=None, trainable=None, name=None, dtype=None, residual_connection=False, **kwargs):\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n if not state_is_tuple:\n logging.warn(\"%s: Using a concatenated state is slower and will soon be \"\n \"deprecated. Use state_is_tuple=True.\", self)\n if num_unit_shards is not None or num_proj_shards is not None:\n logging.warn(\n \"%s: The num_unit_shards and proj_unit_shards parameters are \"\n \"depreca ted and will be removed in Jan 2017. \"\n \"Use a variable scope with a partitioner instead.\", self)\n if context.executing_eagerly() and context.num_gpus() > 0:\n logging.warn(\"%s: Note that this cell is not optimized for performance. \"\n \"Please use tf.contrib.cudnn_rnn.CudnnLSTM for better \"\n \"performance on GPU.\", self)\n self._num_units = num_units\n self._use_peepholes = use_peepholes\n self._cell_clip = cell_clip\n self._initializer = initializers.get(initializer)\n self._num_proj = num_proj\n self._proj_clip = proj_clip\n self._num_unit_shards = num_unit_shards\n self._num_proj_shards = num_proj_shards\n self._forget_bias = forget_bias\n self._state_is_tuple = state_is_tuple\n self.residual_connection = residual_connection\n self._kernel = None\n self._bias = None\n self._w_f_diag = None\n self._w_i_diag = None\n self._w_o_diag = None\n self._proj_kernel = None\n if activation:\n self._activation = activations.get(activation)\n else:\n self._activation = math_ops.tanh\n\n if num_proj:\n self.state_size = [num_proj, num_units]\n self._output_size = num_proj\n\n else:\n self._state_size = [num_units, num_units]\n self._output_size = num_units","def __call__(self, inputs, state, scope=None):\n with tf.variable_scope(scope or type(self).__name__): # \"GRUCell\"\n with tf.variable_scope(\"Gates\"): # Reset gate and update gate.\n # We start with bias of 1.0 to not reset and not udpate.\n #pudb.set_trace()\n # k1 x k2 x Ox x Oh where k1 x k2 is the convolutional kernel spatial\n # size.\n Wzconv = tf.nn.conv2d(inputs, self.W_z, [1,1,1,1], padding='SAME')\n Uzconv = tf.nn.conv2d(state, self.U_z, [1,1,1,1], padding='SAME')\n Wrconv = tf.nn.conv2d(inputs, self.W_r, [1,1,1,1], padding='SAME')\n Urconv = tf.nn.conv2d(state, self.U_r, [1,1,1,1], padding='SAME')\n # sig(W_r * x_t + U_r * h_t-1 )\n u = tf.sigmoid(Wzconv + Uzconv)\n r = tf.sigmoid(Wrconv + Urconv)\n with tf.variable_scope(\"Candidate\"):\n # tanh(W * x_t + U * (r_t dot h_t-1) not confident yet.\n Wconv = tf.nn.conv2d(inputs, self.W, [1,1,1,1], padding='SAME')\n Uconv = tf.nn.conv2d(r*state, self.U, [1,1,1,1], padding='SAME')\n c = tf.tanh(tf.add(Wconv,Uconv))\n new_h = u * state + (1 - u) * c\n # output, state is (batch_size, H=7, W=7, num_units)\n return new_h, new_h","def rnn_cell_loop(self):\n\n\t\t# Set up initial state\n\t\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\t\t\t# Spike\n\t\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\t\t\t\t\t# State\n\t\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\n\t\tself.h = [self.h]\n\t\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\n\n\t\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\t\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\n\t\t# Apply the EI mask to the recurrent weights\n\t\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\n\n\t\t# Set up latency buffer if being used\n\t\tif par['use_latency']:\n\t\t\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\n\t\t\tself.state_buffer = deque(self.state_buffer)\n\t\t\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\n\t\t\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\n\n\t\t# Set up output record\n\t\tself.output = []\n\t\tself.syn_x = []\n\t\tself.syn_u = []\n\n\t\ty = 0.\n\t\tfor t in range(par['num_time_steps']):\n\t\t\tself.t = t \t\t# For latency calculations\n\n\t\t\tif par['cell_type'] == 'rate':\n\t\t\t\traise Exception('Rate cell not yet implemented.')\n\t\t\telif par['cell_type'] == 'adex':\n\t\t\t\tif t < 10:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\telse:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\t\t\t\tself.syn_x.append(syn_x)\n\t\t\t\tself.syn_u.append(syn_u)\n\n\t\t\telif par['cell_type'] == 'lif':\n\t\t\t\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\n\t\t# Stack records\n\t\tself.output = tf.stack(self.output, axis=0)\n\t\tself.h = tf.stack(self.h, axis=0)\n\t\tself.h_out = tf.stack(self.h_out, axis=0)\n\t\tself.syn_x = tf.stack(self.syn_x, axis=0)\n\t\tself.syn_u = tf.stack(self.syn_u, axis=0)","def create_model(self, model_input, vocab_size, num_frames, is_training=True, **unused_params):\n gru_size = FLAGS.gru_cells\n number_of_layers = FLAGS.gru_layers\n backward = FLAGS.gru_backward\n random_frames = FLAGS.gru_random_sequence\n iterations = FLAGS.iterations\n \n if random_frames:\n num_frames_2 = tf.cast(tf.expand_dims(num_frames, 1), tf.float32)\n model_input = utils.SampleRandomFrames(model_input, num_frames_2,\n iterations)\n \n if backward:\n model_input = tf.reverse_sequence(model_input, num_frames, seq_axis=1) \n \n stacked_GRU = tf.contrib.rnn.MultiRNNCell(\n [\n tf.contrib.rnn.GRUCell(gru_size)\n for _ in range(number_of_layers)\n ], state_is_tuple=False)\n\n loss = 0.0\n with tf.variable_scope(\"RNN\"):\n outputs, state = tf.nn.dynamic_rnn(stacked_GRU, model_input,\n sequence_length=num_frames,\n dtype=tf.float32)\n\n aggregated_model = getattr(video_level_models,\n FLAGS.video_level_classifier_model)\n return aggregated_model().create_model(\n model_input=state,\n vocab_size=vocab_size,\n is_training=is_training,\n **unused_params)","def model_create_gru(input_dim, output_dim, n_features, n_houses, x_train, y_train, x_test, y_test, early=None):\r\n model = Sequential()\r\n for _ in range(nn_hparams['num_layers']):\r\n model.add(GRU(nn_hparams['units'], activation=nn_hparams['activation'], input_shape=(input_dim,n_features), return_sequences=True))\r\n model.add(Dropout(nn_hparams['dropout']))\r\n model.add(Flatten())\r\n model.add(Dense(y_train.shape[1]*y_train.shape[2]))\r\n custom_optimizer = getattr(optimizers, nn_hparams['optimizer'])(lr=nn_hparams['learning_rate'], beta_1=nn_hparams['beta_1'], beta_2=nn_hparams['beta_2'])\r\n model.compile(optimizer=custom_optimizer, loss=nn_hparams['loss'])\r\n y_train = y_train.reshape((y_train.shape[0], y_train.shape[1]*y_train.shape[2]))\r\n y_test = y_test.reshape((y_test.shape[0], y_test.shape[1]*y_test.shape[2]))\r\n if early:\r\n model.fit(x_train, y_train, validation_data=(x_test,y_test), epochs=nn_hparams['epochs'], verbose=1, callbacks=[early])\r\n else:\r\n model.fit(x_train, y_train, validation_data=(x_test,y_test), epochs=nn_hparams['epochs'], verbose=1)\r\n model_loss = model.evaluate(x_train, y_train, verbose=0)\r\n \r\n return model, model_loss","def single_cell(\n cell_class,\n cell_params,\n dp_input_keep_prob=1.0,\n dp_output_keep_prob=1.0,\n recurrent_keep_prob=1.0,\n input_weight_keep_prob=1.0,\n recurrent_weight_keep_prob=1.0,\n weight_variational=False,\n dropout_seed=None,\n zoneout_prob=0.,\n training=True,\n residual_connections=False,\n awd_initializer=False,\n variational_recurrent=False, # in case they want to use DropoutWrapper\n dtype=None,\n):\n if awd_initializer:\n val = 1.0/math.sqrt(cell_params['num_units'])\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\n if recurrent_keep_prob < 1.0:\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\n if input_weight_keep_prob < 1.0:\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\n if recurrent_weight_keep_prob < 1.0:\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\n if weight_variational:\n cell_params['weight_variational'] = weight_variational # which is basically True\n if dropout_seed:\n cell_params['dropout_seed'] = dropout_seed\n\n\n cell = cell_class(**cell_params)\n if residual_connections:\n cell = ResidualWrapper(cell)\n if zoneout_prob > 0. and (\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\n ):\n raise ValueError(\n \"Currently applying both dropout and zoneout on the same cell.\"\n \"This is currently not supported.\"\n )\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\n cell = DropoutWrapper(\n cell,\n input_keep_prob=dp_input_keep_prob,\n output_keep_prob=dp_output_keep_prob,\n variational_recurrent=variational_recurrent,\n dtype=dtype,\n seed=dropout_seed\n )\n if zoneout_prob > 0.:\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\n return cell","def trainGestureRNN(numLayers, numNodesPerLayer, useGRU, batchSize,\n numEpochs, learningRate, l1Reg, l2Reg, dropoutI, dropoutH,\n sequences, classes, trainRange, valRange, testRange,\n numClasses, numObservations, numSequences, numFeatures,\n modelFile, callbacks = None, \n outDirectory = '', trainMode = 'continue'):\n trainModes = ['continue', 'overwrite', 'skip']\n \n if trainMode.lower() not in trainModes:\n raise ValueError(\"Parameter 'trainMode' must be one of 'continue', 'overwrite', or 'skip'\")\n \n if dropoutI < 0 or dropoutH < 0 or l2Reg < 0 or l1Reg < 0:\n raise ValueError('Regularization parameters must be non-negative.')\n \n if outDirectory is not None and outDirectory != '':\n outDirectory = outDirectory + '\\\\'\n else:\n outDirectory = ''\n # initialize, compile, and train model\n #finish preparing data\n #class labels must be made into binary arrays\n binaryClasses = np.zeros((numObservations, numSequences, numClasses))\n # tell cost function which timesteps to ignore\n sampleWeights = np.ones((numObservations, numSequences))\n #eh...just use for loops\n for i in range(numObservations):\n for j in range(numSequences):\n if classes[i,j] >= 0:\n binaryClasses[i,j, classes[i,j]] = 1\n else:\n sampleWeights[i,j] = 0\n sequences = sequences.transpose((1,0,2))\n binaryClasses = binaryClasses.transpose((1,0,2))\n sampleWeights = sampleWeights.T\n \n trainData = [sequences[trainRange,:,:], binaryClasses[trainRange,:,:], sampleWeights[trainRange, :]]\n valData = [sequences[valRange,:,:], binaryClasses[valRange,:,:], sampleWeights[valRange, :]]\n testData = [sequences[testRange, :, :], binaryClasses[testRange, :, :], sampleWeights[testRange, :]]\n \n modelFile = outDirectory + 'Keras'+modelFile\n weightsFile = modelFile+'_Weights'\n completedEpochs = 0\n if (trainMode == 'overwrite') or (not os.path.isfile(modelFile+'.json') or not os.path.isfile(weightsFile+'.h5')):\n model = Sequential()\n #add masking layer to indicate dummy timesteps\n model.add(Masking(0, input_shape=(numObservations, numFeatures)))\n if dropoutI:\n model.add(Dropout(dropoutI))\n for i in range(numLayers):\n if useGRU:\n model.add(GRU(output_dim=numNodesPerLayer, return_sequences=True,\n W_regularizer=l2(l2Reg)))\n else:\n model.add(LSTM(output_dim=numNodesPerLayer, return_sequences=True,\n W_regularizer=l2(l2Reg)))\n if dropoutH:\n model.add(Dropout(dropoutH))\n model.add(TimeDistributed(Dense(output_dim=numClasses, activation='softmax', \n W_regularizer = l2(l2Reg))))\n else:\n model = model_from_json(open(modelFile+'.json', 'rb').read())\n model.load_weights(weightsFile+'.h5')\n \n #compile model and training objective function\n sgd = SGD(lr=learningRate)\n rms = RMSprop(lr=learningRate)\n adagrad = Adagrad(lr=learningRate)\n model.compile(loss='categorical_crossentropy', optimizer=rms,\n sample_weight_mode='temporal', metrics=['accuracy'])\n checkp = [ModelCheckpoint(weightsFile + '.h5', save_best_only = True)]\n if callbacks is None:\n callbacks = checkp\n else:\n callbacks += checkp\n try:\n if trainMode != 'skip':\n completedEpochs = model.fit(x=trainData[0], y=trainData[1], sample_weight=trainData[2],\n validation_data = valData, batch_size = batchSize, \n nb_epoch = numEpochs, callbacks = callbacks,\n verbose = 2)\n completedEpochs = len(completedEpochs.history['loss'])\n except KeyboardInterrupt:\n if(not queryUser('Training interrupted. Compute test statistics?')):\n return 0, float('nan'), float('nan'), float('nan') \n #retrieve the best weights based upon validation set loss\n if os.path.isfile(weightsFile+'.h5'):\n model.load_weights(weightsFile+'.h5')\n scores = model.test_on_batch(x=testData[0], y=testData[1], sample_weight=testData[2])\n predictedClasses = model.predict_classes(x=testData[0])\n scores[1] = accuracy(classes[:, testRange].T, predictedClasses)\n scores.append(balancedAccuracy(classes[:, testRange].T, predictedClasses))\n scores.append(weightedAccuracy(classes[:, testRange].T, predictedClasses, forgetFactor=0))\n print(\"Test loss of %.5f\\nFrame-wise accuracy of %.5f\\nSequence-wise accuracy of %.5f\\nFinal frame accuracy of %0.5f\" % (scores[0], scores[1], scores[2], scores[3]))\n if trainMode != 'skip':\n modelString = model.to_json()\n open(modelFile + '.json', 'wb').write(modelString)\n model.save_weights(weightsFile + '.h5', overwrite=True)\n print('Model and weights saved to %s and %s.' % (modelFile+'.json', weightsFile+'.h5'))\n return completedEpochs, scores[0], scores[1], scores[2], scores[3]","def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\n cells = []\n for i in range(layer_num):\n if rnn_type.endswith('lstm'):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n elif rnn_type.endswith('gru'):\n cell = tc.rnn.GRUCell(num_units=hidden_size)\n elif rnn_type.endswith('rnn'):\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\n else:\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\n return cells","def get_rnn(X, rnn_size, seq_len, batch_size, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0, is_training=False,\n cell_name=\"BasicLSTM\", bidirectional=False):\n with tf.device(\"/cpu:0\"):\n # Convert input tensor to python list (along the sequence length dimention)\n word_embeddings = tf.split(1, seq_len, X)\n word_embeddings = [tf.squeeze(embed_, [1]) for embed_ in word_embeddings]\n\n # if is_training and keep_prob < 1:\n # word_embeddings = [tf.nn.dropout(input_, keep_prob) for input_ in word_embeddings]\n\n def get_cell():\n if cell_name == \"GRU\": # GRU\n cell = rnn_cell.GRUCell(rnn_size)\n elif cell_name == \"LSTM\": # LSTM\n cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\n else:\n cell = rnn_cell.BasicLSTMCell(rnn_size)\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\n cell = rnn_cell.DropoutWrapper(cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\n cell = rnn_cell.MultiRNNCell([cell] * num_layers)\n initial_state = cell.zero_state(batch_size, tf.float32)\n return cell, initial_state\n\n if bidirectional:\n with tf.variable_scope(\"forward\"):\n cell_fw, initial_state_fw = get_cell()\n with tf.variable_scope(\"backward\"):\n cell_bw, initial_state_bw = get_cell()\n return rnn.bidirectional_rnn(cell_fw, cell_bw, word_embeddings,\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw)\n else:\n cell, initial_state = get_cell()\n return rnn.rnn(cell, word_embeddings, initial_state=initial_state)","def __call__(self, inputs, state, scope=None):\n with tf.variable_scope(scope or type(self).__name__): # \"GRUCell\"\n with tf.variable_scope(\"Gates\"): # Reset gate and update gate.\n # We start with bias of 1.0 to not reset and not update.\n r, u = tf.split(1, 2, linear([inputs, state],\n 2 * self._num_units, True, 1.0))\n r, u = tf.nn.sigmoid(r), tf.nn.sigmoid(u)\n with tf.variable_scope(\"Candidate\"):\n c = self._activation(linear([inputs, r * state],\n self._num_units, True))\n new_h = u * state + (1 - u) * c\n return tf.concat(1, [new_h, r, u]), new_h","def generator(self, x, reuse=None, name=\"\"):\n with tf.variable_scope('generator-%s' % name, reuse=reuse):\n\n def d(x, f, name=''):\n x = t.conv2d(x, f=f, k=3, s=2, name='gen-d-conv2d-%s' % name)\n x = t.instance_norm(x, name='gen-d-ins_norm-%s' % name)\n x = tf.nn.relu(x)\n return x\n\n def R(x, f, name=''):\n x = t.conv2d(x, f=f, k=3, s=1, name='gen-R-conv2d-%s-0' % name)\n x = t.conv2d(x, f=f, k=3, s=1, name='gen-R-conv2d-%s-1' % name)\n x = t.instance_norm(x, name='gen-R-ins_norm-%s' % name)\n x = tf.nn.relu(x)\n return x\n\n def u(x, f, name=''):\n x = t.deconv2d(x, f=f, k=3, s=2, name='gen-u-deconv2d-%s' % name)\n x = t.instance_norm(x, name='gen-u-ins_norm-%s' % name)\n x = tf.nn.relu(x)\n return x\n\n x = t.conv2d(x, f=self.gf_dim, k=7, s=1, name='gen-conv2d-0')\n\n x = d(x, self.gf_dim * 2, name='1')\n x = d(x, self.gf_dim * 4, name='2')\n\n for i in range(1, 7):\n x = R(x, self.gf_dim * 4, name=str(i))\n\n x = u(x, self.gf_dim * 4, name='1')\n x = u(x, self.gf_dim * 2, name='2')\n\n logits = t.conv2d(x, f=3, k=7, s=1, name='gen-conv2d-1')\n prob = tf.nn.tanh(logits)\n\n return prob","def custom_rnn(cell, inputs, initial_state=None, dtype=None,\r\n sequence_length=None, scope=None):\r\n\r\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\r\n raise TypeError(\"cell must be an instance of RNNCell\")\r\n if not nest.is_sequence(inputs):\r\n raise TypeError(\"inputs must be a sequence\")\r\n if not inputs:\r\n raise ValueError(\"inputs must not be empty\")\r\n\r\n outputs = []\r\n states = []\r\n # Create a new scope in which the caching device is either\r\n # determined by the parent scope, or is set to place the cached\r\n # Variable using the same placement as for the rest of the RNN.\r\n with vs.variable_scope(scope or \"RNN\") as varscope:\r\n if varscope.caching_device is None:\r\n varscope.set_caching_device(lambda op: op.device)\r\n\r\n # Obtain the first sequence of the input\r\n first_input = inputs\r\n while nest.is_sequence(first_input):\r\n first_input = first_input[0]\r\n\r\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\r\n # TODO(lukaszkaiser): remove EmbeddingWrapper\r\n if first_input.get_shape().ndims != 1:\r\n\r\n input_shape = first_input.get_shape().with_rank_at_least(2)\r\n fixed_batch_size = input_shape[0]\r\n\r\n flat_inputs = nest.flatten(inputs)\r\n for flat_input in flat_inputs:\r\n input_shape = flat_input.get_shape().with_rank_at_least(2)\r\n batch_size, input_size = input_shape[0], input_shape[1:]\r\n fixed_batch_size.merge_with(batch_size)\r\n for i, size in enumerate(input_size):\r\n if size.value is None:\r\n raise ValueError(\r\n \"Input size (dimension %d of inputs) must be accessible via \"\r\n \"shape inference, but saw value None.\" % i)\r\n else:\r\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\r\n\r\n if fixed_batch_size.value:\r\n batch_size = fixed_batch_size.value\r\n else:\r\n batch_size = array_ops.shape(first_input)[0]\r\n if initial_state is not None:\r\n state = initial_state\r\n else:\r\n if not dtype:\r\n raise ValueError(\"If no initial_state is provided, \"\r\n \"dtype must be specified\")\r\n state = cell.zero_state(batch_size, dtype)\r\n\r\n if sequence_length is not None: # Prepare variables\r\n sequence_length = ops.convert_to_tensor(\r\n sequence_length, name=\"sequence_length\")\r\n if sequence_length.get_shape().ndims not in (None, 1):\r\n raise ValueError(\r\n \"sequence_length must be a vector of length batch_size\")\r\n def _create_zero_output(output_size):\r\n # convert int to TensorShape if necessary\r\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\r\n output = array_ops.zeros(\r\n array_ops.pack(size), _infer_state_dtype(dtype, state))\r\n shape = _state_size_with_prefix(\r\n output_size, prefix=[fixed_batch_size.value])\r\n output.set_shape(tensor_shape.TensorShape(shape))\r\n return output\r\n\r\n output_size = cell.output_size\r\n flat_output_size = nest.flatten(output_size)\r\n flat_zero_output = tuple(\r\n _create_zero_output(size) for size in flat_output_size)\r\n zero_output = nest.pack_sequence_as(structure=output_size,\r\n flat_sequence=flat_zero_output)\r\n\r\n sequence_length = math_ops.to_int32(sequence_length)\r\n min_sequence_length = math_ops.reduce_min(sequence_length)\r\n max_sequence_length = math_ops.reduce_max(sequence_length)\r\n\r\n for time, input_ in enumerate(inputs):\r\n if time > 0: varscope.reuse_variables()\r\n # pylint: disable=cell-var-from-loop\r\n call_cell = lambda: cell(input_, state)\r\n # pylint: enable=cell-var-from-loop\r\n if sequence_length is not None:\r\n (output, state) = _rnn_step(\r\n time=time,\r\n sequence_length=sequence_length,\r\n min_sequence_length=min_sequence_length,\r\n max_sequence_length=max_sequence_length,\r\n zero_output=zero_output,\r\n state=state,\r\n call_cell=call_cell,\r\n state_size=cell.state_size)\r\n else:\r\n (output, state) = call_cell()\r\n\r\n outputs.append(output)\r\n states.append(state)\r\n\r\n return (outputs, state, states)","def _build_pnasnet_base(\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\n start_cell_num):\n\n # Find where to place the reduction cells or stride normal cells\n reduction_indices = nasnet_utils.calc_reduction_layers(\n hparams.num_cells, hparams.num_reduction_layers)\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\n\n # Note: The None is prepended to match the behavior of _imagenet_stem()\n cell_outputs = [None, hidden_previous, hidden]\n net = hidden\n\n # Run the cells\n for cell_num in range(start_cell_num, hparams.num_cells):\n is_reduction = cell_num in reduction_indices\n stride = 2 if is_reduction else 1\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\n prev_layer = cell_outputs[-2]\n net = normal_cell(\n net,\n scope='cell_{}'.format(cell_num),\n filter_scaling=filter_scaling,\n stride=stride,\n prev_layer=prev_layer,\n cell_num=true_cell_num)\n true_cell_num += 1\n cell_outputs.append(net)\n\n # Final nonlinearity.\n # Note that we have dropped the final pooling, dropout and softmax layers\n # from the default pnasnet version.\n with tf.variable_scope('final_layer'):\n net = tf.nn.relu(net)\n return net","def __init__(self, context, problem, update_rate=1, debug=False):\n tf.keras.layers.AbstractRNNCell.__init__(self)\n self.context = context\n self.problem = problem\n\n if hasattr(self.context, 'scale'):\n self.scale = self.context.scale\n else:\n self.scale = 1\n\n self.debug = debug\n\n # shape related information\n self.batch_size = self.context.batch_size\n self.dim_x = self.context.dim_x\n self.dim_z = self.context.dim_z\n self.dim_u = self.context.dim_u\n\n # rate at which observations are taken into account\n self.update_rate = tf.ones([], dtype=tf.float32) * update_rate\n\n self.filter_layers = []","def gru_bid_encoder(inputs, sequence_length, hparams, train, name):\n\n with tf.variable_scope(name):\n cell_fw = tf.nn.rnn_cell.MultiRNNCell(\n [_dropout_gru_cell(hparams, train)\n for _ in range(hparams.num_hidden_layers)])\n\n cell_bw = tf.nn.rnn_cell.MultiRNNCell(\n [_dropout_gru_cell(hparams, train)\n for _ in range(hparams.num_hidden_layers)])\n\n ((encoder_fw_outputs, encoder_bw_outputs),\n (encoder_fw_state, encoder_bw_state)) = tf.nn.bidirectional_dynamic_rnn(\n cell_fw,\n cell_bw,\n inputs,\n sequence_length,\n dtype=tf.float32,\n time_major=False)\n\n encoder_outputs = tf.concat((encoder_fw_outputs, encoder_bw_outputs), 2)\n encoder_states = []\n\n for i in range(hparams.num_hidden_layers):\n encoder_state = tf.concat(\n values=(encoder_fw_state[i], encoder_bw_state[i]),\n axis=1,\n name=\"bidirectional_concat\")\n\n encoder_states.append(encoder_state)\n\n encoder_states = tuple(encoder_states)\n return encoder_outputs, encoder_states","def gru_cell(prev_hidden: tf.Tensor, input: tf.Tensor) -> tf.Tensor:\n batch_size, hidden_size = assert_shape(prev_hidden, (None, None))\n _, input_size = assert_shape(input, (batch_size, None))\n dtype = prev_hidden.dtype\n\n weight_i = tf.get_variable(\n \"weight_i\",\n (3, input_size, hidden_size),\n dtype=dtype,\n initializer=tf.glorot_normal_initializer(),\n )\n bias_i = tf.get_variable(\"bias_i\", (3, hidden_size),\n dtype=dtype,\n initializer=tf.zeros_initializer())\n weight_h = tf.get_variable(\n \"weight_h\",\n (3, hidden_size, hidden_size),\n dtype=dtype,\n initializer=tf.glorot_normal_initializer(),\n )\n bias_h = tf.get_variable(\"bias_h\", (3, hidden_size),\n dtype=dtype,\n initializer=tf.zeros_initializer())\n\n reset_i, update_i, candidate_i = tf.unstack(input @ weight_i +\n tf.expand_dims(bias_i, 1))\n reset_h, update_h, candidate_h = tf.unstack(prev_hidden @ weight_h +\n tf.expand_dims(bias_h, 1))\n\n reset = tf.sigmoid(reset_i + reset_h)\n update = tf.sigmoid(update_i + update_h)\n candidate = tf.tanh(candidate_i + reset * candidate_h)\n return (1 - update) * candidate + update * prev_hidden","def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\n # todo 1、获取嵌入层的输出\n embed = get_embed(input_data, vocab_size, embed_dim)\n # todo-2、获取 隐藏层的输出\n rnn_outputs, final_state, final_state1 = build_rnn(\n cell, embed, initial_state=initial_state)\n # 3、构建全连接，获取logits\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\n # [N, n-steps, num_classes]\n return logits, final_state, final_state1","def __init__(self, init_grid=None):\n\n self.height = len(init_grid)\n self.width = len(init_grid[0])\n\n self.grid = [[Cell(self, c) for c in row]\n for row in init_grid]\n\n self.g = nx.Graph()\n self.tangle()","def SRGAN_g(t_image, is_train=False, reuse=False):\n w_init = tf.random_normal_initializer(stddev=0.02)\n b_init = None # tf.constant_initializer(value=0.0)\n g_init = tf.random_normal_initializer(1., 0.02)\n\n with tf.variable_scope(\"SRGAN_g\", reuse=reuse) as vs:\n # tl.layers.set_name_reuse(reuse) # remove for TL 1.8.0+\n n = InputLayer(t_image, name='in')\n n = ReshapeLayer(n, [-1, 512, 512, 1], name = 'reshape')\n n = Conv2d(n, 64, (3, 3), (1, 1), act=tf.nn.relu, padding='SAME', W_init=w_init, name='n64s1/c')\n temp = n\n\n # B residual blocks\n for i in range(16):\n nn = Conv2d(n, 64, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, b_init=b_init, name='n64s1/c1/%s' % i)\n nn = BatchNormLayer(nn, act=tf.nn.relu, is_train=is_train, gamma_init=g_init, name='n64s1/b1/%s' % i)\n nn = Conv2d(nn, 64, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, b_init=b_init, name='n64s1/c2/%s' % i)\n nn = BatchNormLayer(nn, is_train=is_train, gamma_init=g_init, name='n64s1/b2/%s' % i)\n nn = ElementwiseLayer([n, nn], tf.add, name='b_residual_add/%s' % i)\n n = nn\n\n\n n = Conv2d(n, 64, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, b_init=b_init, name='n64s1/c/m')\n\n n = BatchNormLayer(n, is_train=is_train, gamma_init=g_init, name='n64s1/b/m')\n n = ElementwiseLayer([n, temp], tf.add, name='add3')\n # B residual blacks end\n\n n = Conv2d(n, 3, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, name='n256s1/1')\n return n","def __init__(self, model, num_classes=-1, hidden_size=128, type='gru', **kwargs):\n super(CNNRNN, self).__init__(**kwargs)\n self.feats = model is None\n with self.name_scope():\n if model is not None:\n self.td = TimeDistributed(model.backbone)\n if type == 'lstm':\n self.rnn = mx.gluon.rnn.LSTM(hidden_size, layout=\"NTC\", bidirectional=True)\n else:\n self.rnn = mx.gluon.rnn.GRU(hidden_size, layout=\"NTC\", bidirectional=True)\n self.classes = None\n if num_classes == 0:\n self.classes = model.classes\n elif num_classes > 0:\n self.classes = nn.Dense(num_classes, flatten=True)","def setup_rnn_model(default_ctx,\n num_lstm_layer, \n num_hidden,\n batch_size,\n initializer,\n group2ctx=None, concat_decode=True,\n use_loss=False, buckets=None):\n max_len = n_steps\n max_rnn_exec = None\n rnn_sym = lstm_unroll(num_lstm_layer=num_lstm_layer,\n num_hidden=num_hidden)\n arg_names = rnn_sym.list_arguments()\n internals = rnn_sym.get_internals()\n\n input_shapes = {}\n for name in arg_names:\n if name.endswith(\"init_c\") or name.endswith(\"init_h\"):\n input_shapes[name] = (batch_size, num_hidden)\n elif name.endswith(\"data\"):\n input_shapes[name] = (batch_size,MAX_LEN)\n elif name == \"labels\":\n input_shapes[name] = (batch_size,MAX_LEN)\n elif name.endswith(\"label\"):\n input_shapes[name] = (batch_size, )\n else:\n pass\n\n arg_shape, out_shape, aux_shape = rnn_sym.infer_shape(**input_shapes)\n # bind arrays\n arg_arrays = []\n args_grad = {}\n for shape, name in zip(arg_shape, arg_names):\n group = internals[name].attr(\"ctx_group\")\n ctx = group2ctx[group] if group is not None else default_ctx\n arg_arrays.append(mx.nd.zeros(shape, ctx))\n if is_param_name(name):\n args_grad[name] = mx.nd.zeros(shape, ctx)\n if not name.startswith(\"t\"):\n print(\"%s group=%s, ctx=%s\" % (name, group, str(ctx)))\n \n #bind with shared executor\n rnn_exec = None\n rnn_exec = rnn_sym.bind(default_ctx, args=arg_arrays,\n args_grad=args_grad,\n grad_req=\"add\", group2ctx=group2ctx)\n max_rnn_exec = rnn_exec\n \n\n param_blocks = []\n arg_dict = dict(zip(arg_names, rnn_exec.arg_arrays))\n for i, name in enumerate(arg_names):\n if is_param_name(name):\n initializer(name, arg_dict[name])\n param_blocks.append((i, arg_dict[name], args_grad[name], name))\n else:\n assert name not in args_grad\n\n out_dict = dict(zip(rnn_sym.list_outputs(), rnn_exec.outputs))\n\n init_states = [LSTMState(c=arg_dict[\"l%d_init_c\" % i],\n h=arg_dict[\"l%d_init_h\" % i]) for i in range(num_lstm_layer)]\n\n seq_data = rnn_exec.arg_dict[\"data\"]\n # we don't need to store the last state \n last_states = None\n\n seq_outputs = [out_dict[\"sm_output\"]]\n seq_labels = [rnn_exec.arg_dict[\"labels\"]]\n\n model = LSTMModel(rnn_exec=rnn_exec, symbol=rnn_sym,\n init_states=init_states, last_states=last_states,\n seq_data=seq_data, seq_labels=seq_labels, seq_outputs=seq_outputs,\n param_blocks=param_blocks)\n return model","def mkrngs(self):\n self.bkg[[0, -1]] = False\n bkgr = self.Time[self.bkg ^ np.roll(self.bkg, -1)]\n self.bkgrng = np.reshape(bkgr, [bkgr.size // 2, 2])\n\n self.sig[[0, -1]] = False\n sigr = self.Time[self.sig ^ np.roll(self.sig, 1)]\n self.sigrng = np.reshape(sigr, [sigr.size // 2, 2])\n\n self.trn[[0, -1]] = False\n trnr = self.Time[self.trn ^ np.roll(self.trn, 1)]\n self.trnrng = np.reshape(trnr, [trnr.size // 2, 2])","def build_lstm_cell(num_units, dropout):\n cell = tf.nn.rnn_cell.LSTMCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result","def add_model(self, inputs):\n size = self.config.hidden_size\n forget_bias = self.config.forget_bias\n input_cell = self.config.input_cell\n\n if input_cell == 'BasicLSTMCell':\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\n print 'Using Basic LSTM Cell \\n'\n\n elif input_cell == 'LSTMCell':\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\n print 'Using LSTM Cell \\n'\n\n elif input_cell == 'GRUCell':\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\n print 'Using GRU Cell \\n'\n\n else:\n print \"Please Specify a Correct Cell Type\"\n\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\n input_keep_prob=self.config.dropout)\n\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\n \n print 'Number of Hidden Layers ', self.config.num_layers\n \n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\n rnn_outputs = []\n state = self.initial_state\n\n with tf.variable_scope('RNNLM') as scope:\n for time_step in range(self.config.num_steps):\n if time_step > 0: scope.reuse_variables()\n (cell_output, state) = cell(inputs[:, time_step, :], state)\n rnn_outputs.append(cell_output)\n self.final_state = state\n\n return rnn_outputs","def mgcResnet(block_type, block_repeat, **kwargs):\n \n \n def_vals = {\"input_img_rows\" : 72,\n \"input_img_cols\" : 72,\n \"channels\" : 1,\n \"nb_classes\" : 13\n } # default parameters value\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n input_img_rows = kwargs['input_img_rows']\n input_img_cols = kwargs['input_img_cols']\n channels = kwargs['channels']\n nb_classes = kwargs['nb_classes']\n \n # block_type residual block option\n if block_type == 'basic':\n block_fn = resnet.basic_block\n elif block_type == 'bottleneck':\n block_fn = resnet.bottleneck\n\n model = resnet.ResnetBuilder.build((channels, input_img_rows, input_img_cols), nb_classes, block_fn, block_repeat)\n return model","def __init__(self, input_dim, hidden_dim, bias=True, node_n=48, dtype=float):\n super(GCNGRU_Block, self).__init__()\n self.hidden_dim = hidden_dim\n self.node_n = node_n\n\n self.gc1 = GraphConvolution(input_dim + hidden_dim, 2*self.hidden_dim, node_n=node_n, bias=bias)\n self.gc2 = GraphConvolution(input_dim + hidden_dim, self.hidden_dim, node_n=node_n, bias=bias)","def resnet10(shortcut_type, num_classes, in_channels):\n model = ResNet(BasicBlock, [1, 1, 1, 1], shortcut_type, num_classes, in_channels)\n return model","def __init__(self, num_gpus):\n\n super(Generator, self).__init__()\n n_in = Z\n n_out = IMG_CHANNELS\n\n feature_map = IMG_SIZE\n kernel_size = 4\n stride = 2\n padding = 1\n bias = False\n\n self.num_gpus = num_gpus\n\n self.network = nn.Sequential(\n # input is latent variable space Z\n nn.ConvTranspose2d(n_in, feature_map * 8, kernel_size, 1, 0, bias=bias),\n nn.BatchNorm2d(feature_map * 8),\n nn.ReLU(inplace=True),\n\n # nodes = feature_map * 4\n nn.ConvTranspose2d(feature_map * 8, feature_map * 4, kernel_size, stride, padding, bias=bias),\n nn.BatchNorm2d(feature_map * 4),\n nn.ReLU(inplace=True),\n\n # nodes = feature_map * 2\n nn.ConvTranspose2d(feature_map * 4, feature_map * 2, kernel_size, stride, padding, bias=bias),\n nn.BatchNorm2d(feature_map * 2),\n nn.ReLU(inplace=True),\n\n # nodes = feature_map\n nn.ConvTranspose2d(feature_map * 2, feature_map, kernel_size, stride, padding, bias=bias),\n nn.BatchNorm2d(feature_map),\n nn.ReLU(inplace=True),\n\n # nodes = output image size\n nn.ConvTranspose2d(feature_map, n_out, kernel_size, stride, padding, bias=bias),\n nn.Tanh()\n )","def __call__(self, inputs, state, scope=None, debug=False):\n # B is batch size.\n\n # 1) Use read_ind to find memory location to read from\n # as input.\n\n # inputs.read_ind: (B, 1)\n # memory: (B, mem_size, embed_size)\n read_ind = tf.to_int32(inputs.read_ind)\n batch_size = tf.shape(read_ind)[0]\n if debug:\n print('batch size is', batch_size)\n print('read ind is', read_ind)\n mem_ind = tf.range(batch_size)\n\n # read_mem_ind: (B, 1)\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\n # read_ind: (B, 2)\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\n if debug:\n print('processed read ind is', read_ind)\n\n # inner_inputs: (B, embed_size)\n inner_inputs = tf.gather_nd(state.memory, read_ind)\n if debug:\n print('inner_inputs is', inner_inputs)\n\n inner_state = state.inner_state\n\n # 2) Run the inner RNNCell.\n \n # inner_outputs: (B, embed_size)\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\n\n if debug:\n print('inner_outputs is', inner_outputs)\n\n # 3) Compute logits for valid indices (using logit_masks\n # to mask out padded valid indices (-1)).\n \n # valid_indices: (B, max_n_valid_indices)\n valid_indices = tf.to_int32(inputs.valid_indices)\n if debug:\n print('valid_indices is', valid_indices)\n \n # Logit mask: (B, max_n_valid_indices)\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\n logit_masks = tf.cast(logit_masks, tf.float32)\n\n if debug:\n print('logit_masks is', logit_masks)\n\n # Normalize indices to be at least 0.\n valid_indices = tf.maximum(valid_indices, 0)\n\n # valid_indices: (B, max_n_valid_indices, 1)\n valid_indices = tf.expand_dims(valid_indices, -1)\n if debug:\n print('valid_indices is', valid_indices)\n print('mem_ind is', mem_ind)\n\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # valid_mem_ind: (B, 1, 1)\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\n if debug:\n print('valid_mem_ind is', valid_mem_ind)\n\n # valid_mem_ind: (B, max_n_valid_indices, 1)\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\n\n # valid_indices: (B, max_n_valid_indices, 2)\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\n # index into the right memory location.\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\n\n if debug:\n print('valid_indices is', valid_indices)\n\n # select all the valid slots. \n # valid_values: (B, max_n_valid_indices, embed_size)\n valid_values = tf.gather_nd(state.memory, valid_indices)\n if debug:\n print('valid_values is', valid_values)\n \n # expanded_inner_outputs: (B, 1, embed_size)\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\n if debug:\n print('expanded_inner_outputs is', expanded_inner_outputs)\n\n # valid_values: (B, embed_size, max_n_valid_indices)\n valid_values = tf.transpose(valid_values, [0, 2, 1])\n if debug:\n print('valid_values is', valid_values)\n\n # logits: (B, 1, max_n_valid_indices)\n logits = tf.matmul(expanded_inner_outputs, valid_values)\n \n if debug:\n print('logits is', logits)\n\n # logits: (B, max_n_valid_indices)\n logits = tf.squeeze(logits, axis=[1])\n if debug:\n print('logits is', logits)\n\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\n\n outputs = masked_logits\n # 4) Write the output of the inner RNN to a memory\n # location (write_ind), using write_masks to mask out\n # padded write_ind (-1).\n \n # write_ind: (B, 1)\n write_ind = tf.cast(inputs.write_ind, tf.int32)\n if debug:\n print('write_ind is', write_ind)\n\n # write mask: (B, 1)\n write_masks = tf.greater_equal(inputs.write_ind, 0)\n if debug:\n print('write_masks greater_equal', write_masks)\n\n write_masks = tf.cast(write_masks, tf.float32)\n\n # write mask: (B, 1, 1)\n write_masks = tf.expand_dims(write_masks, [-1])\n\n if debug:\n print('write_masks is', write_masks)\n\n # Normalize write_ind to be above 0.\n # write_ind: (B, 1)\n write_ind = tf.maximum(write_ind, 0)\n\n # write_mem_ind: (B, 1)\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # write_ind: (B, 2)\n # Second dimension is [b_i, write_index]\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\n if debug:\n print('write_ind is', write_ind)\n\n if debug:\n print('masked_logits is', masked_logits)\n print('memory is', state.memory)\n\n # write_mat: (B, mem_size, embed_size)\n write_mat = tf.scatter_nd(\n write_ind, inner_outputs, shape=tf.shape(state.memory))\n\n if debug:\n print('@' * 50)\n print('write_mat is', write_mat)\n print('write_mask is', write_masks)\n print('@' * 50)\n\n masked_write_mat = write_mat * write_masks\n new_memory = state.memory + masked_write_mat\n \n state = MemoryStateTuple(new_memory, new_inner_state)\n if debug:\n print('state is', state)\n \n return (outputs, state)","def _grads(val, r):\n return grad(val, r, grad_outputs=torch.ones_like(val))[0]","def BuildCoreGraph(self):\n # Input ids, with dynamic shape depending on input.\n # Should be shape [batch_size, max_time] and contain integer word indices.\n self.input_w_ = tf.placeholder(tf.int32, [None, None], name=\"w\")\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_], name=\"w\")\n\n # Initial hidden state. You'll need to overwrite this with cell.zero_state\n # once you construct your RNN cell.\n self.initial_h_ = None\n #tf.placeholder(tf.int32, [self.H,], name=\"h_i\")\n #tf.Variable(tf.random_normal([H,]), name=\"h_i\")\n\n # Final hidden state. You'll need to overwrite this with the output from\n # tf.nn.dynamic_rnn so that you can pass it in to the next batch (if\n # applicable).\n self.final_h_ = None\n #tf.placeholder(tf.int32, [self.H,], name=\"h_f\")\n #tf.Variable(tf.random_normal([H,]), name=\"h_f\")\n\n # Output logits, which can be used by loss functions or for prediction.\n # Overwrite this with an actual Tensor of shape\n # [batch_size, max_time, V].\n self.logits_ = None\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_, self.V], name=\"logits\")\n #tf.Variable(tf.random_normal([self.batch_size_, self.max_time_, self.V]), name=\"logits\")\n\n # Should be the same shape as inputs_w_\n self.target_y_ = tf.placeholder(tf.int32, [None, None], name=\"y\")\n #tf.placeholder(tf.int32, [None, None], name=\"y\")\n\n # Replace this with an actual loss function\n self.loss_ = None\n #tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.labels_, logits=self.logits_),0)#don't forget last parameter\n\n # Get dynamic shape info from inputs\n with tf.name_scope(\"batch_size\"):\n self.batch_size_ = tf.shape(self.input_w_)[0]\n with tf.name_scope(\"max_time\"):\n self.max_time_ = tf.shape(self.input_w_)[1]\n\n # Get sequence length from input_w_.\n # TL;DR: pass this to dynamic_rnn.\n # This will be a vector with elements ns[i] = len(input_w_[i])\n # You can override this in feed_dict if you want to have different-length\n # sequences in the same batch, although you shouldn't need to for this\n # assignment.\n self.ns_ = tf.tile([self.max_time_], [self.batch_size_, ], name=\"ns\")#update this for project\n\n #### YOUR CODE HERE ####\n # See hints in instructions!\n\n # Construct embedding layer\n #self.W_in_ = tf.get_variable(\"W_in\", shape=[self.V, self.H], \n #initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n #self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\n \n #self.W_in_ = tf.get_variable(tf.random_uniform([self.V, self.H], -1.0, 1.0), name=\"W_in\")\n #Variable(tf.random_uniform([V, M], -1.0, 1.0), name=\"C\")\n # embedding_lookup gives shape (batch_size, N, M)\n #x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\n \n with tf.name_scope(\"embedding_layer\"):\n self.W_in_ = tf.get_variable(\"W_in\", shape=[self.V, self.H], \n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\n\n\n\n # Construct RNN/LSTM cell and recurrent layer.\n with tf.name_scope(\"recurrent_layer\"):\n self.cell_ = MakeFancyRNNCell(self.H, self.dropout_keep_prob_, self.num_layers)\n self.initial_h_ = self.cell_.zero_state(self.batch_size_,tf.float32)\n self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=self.x_, \n sequence_length=self.ns_, initial_state=self.initial_h_,\n dtype=tf.float32)\n #print(self.outputs_.get_shape())\n #self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=x_, \n #sequence_length=self.ns_, initial_state=self.initial_h_,\n #dtype=tf.float32)\n \n #W1_ = tf.Variable(tf.random_normal([N*M,H]), name=\"W1\")\n #b1_ = tf.Variable(tf.zeros([H,], dtype=tf.float32), name=\"b1\")\n #h_ = tf.tanh(tf.matmul(x_, W1_) + b1_, name=\"h\")\n\n\n\n\n\n # Softmax output layer, over vocabulary. Just compute logits_ here.\n # Hint: the matmul3d function will be useful here; it's a drop-in\n # replacement for tf.matmul that will handle the \"time\" dimension\n # properly.\n with tf.name_scope(\"softmax_output_layer\"):\n self.W_out_ = tf.get_variable(\"W_out\", shape=[self.H, self.V], \n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n #tf.get_variable(tf.random_uniform([self.H, self.V], -1.0, 1.0), name=\"W_out\")\n\n self.b_out_ = tf.get_variable(\"b_out\", shape=[self.V,], \n initializer = tf.zeros_initializer())\n #self.b_out_ = tf.get_variable(\"b_out\", shape=[self.V,], initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\n #tf.get_variable(tf.random_uniform([self.V,], -1.0, 1.0), name=\"b_out\")\n\n self.logits_ = tf.add(matmul3d(self.outputs_, self.W_out_), self.b_out_, name=\"logits\")\n #print(self.logits_.get_shape())\n\n\n\n # Loss computation (true loss, for prediction)\n with tf.name_scope(\"loss_computation\"):\n per_example_loss_ = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.target_y_, \n logits=self.logits_, \n name=\"per_example_loss\")\n self.loss_ = tf.reduce_mean(per_example_loss_, name=\"loss\")\n\n\n\n #### END(YOUR CODE) ####","def resnet_9blocks(pretrained=False, **kwargs):\n return ResnetGenerator(\n 9, **kwargs\n )","def __init__(self,\n num_units,\n forget_bias=1.0,\n state_is_tuple=True,\n activation=None,\n reuse=None,\n name=None):\n super(MaskedBasicLSTMCell, self).__init__(\n num_units,\n forget_bias=forget_bias,\n state_is_tuple=state_is_tuple,\n activation=activation,\n reuse=reuse,\n name=name)","def gen_CASTEP_supercell(CASTEP_cell,na,nb,nc):\n nruter=dict()\n nruter[\"na\"]=na\n nruter[\"nb\"]=nb\n nruter[\"nc\"]=nc\n nruter[\"lattvec\"]=np.array(CASTEP_cell[\"lattvec\"])\n nruter[\"lattvec\"][:,0]*=na\n nruter[\"lattvec\"][:,1]*=nb\n nruter[\"lattvec\"][:,2]*=nc\n nruter[\"elements\"]=copy.copy(CASTEP_cell[\"elements\"])\n nruter[\"numbers\"]=na*nb*nc*CASTEP_cell[\"numbers\"]\n nruter[\"positions\"]=np.empty((3,CASTEP_cell[\"positions\"].shape[1]*na*nb*nc))\n pos=0\n for pos,(k,j,i,iat) in enumerate(itertools.product(xrange(nc),\n xrange(nb),\n xrange(na),\n xrange(\n CASTEP_cell[\"positions\"].shape[1]))):\n nruter[\"positions\"][:,pos]=(CASTEP_cell[\"positions\"][:,iat]+[i,j,k])/[\n na,nb,nc]\n nruter[\"types\"]=[]\n for i in xrange(na*nb*nc):\n nruter[\"types\"].extend(CASTEP_cell[\"types\"])\n # print \"supercell\", nruter\n return nruter","def _build_rnn_graph_lstm(self, inputs, config, is_training):\n cell = util.create_lstm_cell(is_training, config)\n state = util.get_zero_state_for_the_cell(cell, config)\n\n self.initial_state = state\n with tf.variable_scope(\"RNN\"):\n inputs = tf.unstack(inputs, num=self.num_steps, axis=1)\n outputs, state = tf.contrib.rnn.static_rnn(cell, inputs,\n initial_state=self.initial_state)\n output = tf.reshape(tf.concat(outputs, 1), [-1, config.hidden_size])\n return output, state","def compile_model(network):\n # Get our network parameters.\n max_depth = network['max_depth']\n base_score = network['base_score']\n colsample_bylevel = network['colsample_bylevel']\n colsample_bytree = network['colsample_bytree']\n gamma = network['gamma']\n learning_rate = network['learning_rate']\n min_child_weight = network['min_child_weight']\n tree_method = network['tree_method']\n\n model = xgb.XGBRegressor(nthread=-1, n_estimators=5000,\n # booster=booster,\n max_depth=max_depth,\n base_score=base_score,\n colsample_bylevel=colsample_bylevel,\n colsample_bytree=colsample_bytree,\n gamma=gamma,\n learning_rate=learning_rate,\n min_child_weight=min_child_weight,\n tree_method=tree_method)\n\n return model","def setup(self):\n rnn_type = 'gru'\n n_hidden = 24\n\n flopper = Flipflopper(rnn_type=rnn_type, n_hidden=n_hidden)\n stim = flopper.generate_flipflop_trials()\n # train the model\n # flopper.train(stim, 4000, save_model=True)\n\n # if a trained model has been saved, it may also be loaded\n flopper.load_model()\n\n self.weights = flopper.model.get_layer(flopper.hps['rnn_type']).get_weights()\n self.output_weights = flopper.model.get_layer('dense').get_weights()\n self.activations = np.vstack(flopper.get_activations(stim))\n self.outputs = np.vstack(stim['output'])\n # self.activations = self.outputs @ self.output_weights[0].T # this will make for idealized activations\n\n self.sGru = SerializedGru(self.weights, n_hidden) # helper class to serialize gru\n\n self.complex_activations = self.activations @ (1/4 * self.sGru.h_c_inv) # transform activations to complex system\n # self.complex_activations = np.vstack((np.zeros(n_hidden), self.complex_activations[:-1, :]))\n\n inputs = np.vstack(stim['inputs'])\n self.sGru.handle_inputs(inputs)"],"string":"[\n \"def _initialize_gru_cell(self, num_units):\\n return gru_cell.LayerNormGRUCell(\\n num_units,\\n w_initializer=self.uniform_initializer,\\n u_initializer=random_orthonormal_initializer,\\n b_initializer=tf.constant_initializer(0.0))\",\n \"def build_rnn_cell(type, num_units, dropout):\\n cell = tf.nn.rnn_cell.BasicRNNCell(num_units)\\n if dropout:\\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\\n output_keep_prob=1-dropout)\\n return result\",\n \"def rnn(input_size, rnn_size, rnn_len):\\n num_rnn_layers = rnn_len\\n assert num_rnn_layers >= 1\\n hidden_size = rnn_size\\n\\n gru = nn.GRU(input_size=input_size, hidden_size=hidden_size, num_layers=num_rnn_layers, bias=True, batch_first=True, dropout=0, bidirectional=False)\\n return gru\",\n \"def create_rnn_cell(num_units,\\n num_layers,\\n num_residual_layers,\\n dropout,\\n mode,\\n num_gpus,\\n base_gpu=0,\\n single_cell_fn=None,\\n all_layer_outputs=False):\\n cell_list = _cell_list(\\n num_units=num_units,\\n num_layers=num_layers,\\n num_residual_layers=num_residual_layers,\\n dropout=dropout,\\n mode=mode,\\n num_gpus=num_gpus,\\n base_gpu=base_gpu,\\n single_cell_fn=single_cell_fn)\\n\\n if len(cell_list) == 1: # Single layer.\\n return cell_list[0]\\n else: # Multi layers\\n print(all_layer_outputs, \\\"all_layer_outputs\\\")\\n\\n if all_layer_outputs:\\n return MultiRNNCell(cell_list)\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(RCRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = ResidualCNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=2,\\n )\\n #self.rnn2 = BidirectionalGRU(\\n # n_in=nb_in*2,\\n # n_hidden=n_RNN_cell,\\n # dropout=dropout_recurrent,\\n # num_layers=1,\\n #)\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.relu = nn.ReLU()\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def _single_cell(num_units,\\n dropout,\\n mode,\\n residual_connection=False,\\n device_str=None):\\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\\n\\n # Cell Type\\n utils.print_out(\\\" GRU\\\", new_line=False)\\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n utils.print_out(\\n \\\" %s, dropout=%g \\\" % (type(single_cell).__name__, dropout),\\n new_line=False)\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\\n utils.print_out(\\\" %s\\\" % type(single_cell).__name__, new_line=False)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\\n utils.print_out(\\n \\\" %s, device=%s\\\" % (type(single_cell).__name__, device_str),\\n new_line=False)\\n\\n return single_cell\",\n \"def init_gru(rnn):\\n\\n def _concat_init(tensor, init_funcs):\\n (length, fan_out) = tensor.shape\\n fan_in = length // len(init_funcs)\\n\\n for (i, init_func) in enumerate(init_funcs):\\n init_func(tensor[i * fan_in: (i + 1) * fan_in, :])\\n\\n def _inner_uniform(tensor):\\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\\n\\n for i in range(rnn.num_layers):\\n _concat_init(\\n getattr(rnn, 'weight_ih_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, _inner_uniform]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\\n\\n _concat_init(\\n getattr(rnn, 'weight_hh_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)\",\n \"def compile_gru_model(input_dim=101, output_dim=4563, recur_layers=3, nodes=1000,\\n conv_context=11, conv_border_mode='valid', conv_stride=2,\\n initialization='glorot_uniform', batch_norm=True, num_gpu=1):\\n logger.info(\\\"Building gru model\\\")\\n # Main acoustic input\\n acoustic_input = Input(shape=(None, input_dim), name='acoustic_input')\\n\\n # Setup the network\\n #conv_1d = Conv1D(nodes, conv_context, name='conv_1d',\\n # padding='same', strides=conv_stride,\\n # kernel_initializer=initialization,\\n # activation='relu')(acoustic_input)\\n conv_1d = Convolution1D(nodes, conv_context, name='conv1d',\\n border_mode=conv_border_mode,\\n subsample_length=conv_stride, init=initialization,\\n activation='relu')(acoustic_input)\\n if batch_norm:\\n output = normalization.BatchNormalization(name='bn_conv_1d')(conv_1d, training=True)\\n else:\\n output = conv_1d\\n\\n for r in range(recur_layers):\\n # output = GRU(nodes, activation='relu',\\n # name='rnn_{}'.format(r + 1), init=initialization,\\n # return_sequences=True)(output)\\n output = Bidirectional(GRU(nodes, return_sequences=True),name='bi_lstm_{}'.format(r + 1))(output)\\n if batch_norm:\\n bn_layer = normalization.BatchNormalization(name='bn_rnn_{}'.format(r + 1),moving_mean_initializer='zeros')\\n output = bn_layer(output, training=True)\\n\\n network_output = TimeDistributed(Dense(\\n output_dim+1, name='dense', activation='softmax', init=initialization,\\n ))(output)\\n model = Model(input=acoustic_input, output=network_output)\\n #model.conv_output_length = lambda x: conv_output_length(\\n # x, conv_context, conv_border_mode, conv_stride)\\n # model = ParallelModel(model, num_gpu)\\n return model\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\\n super(ConvGRUCell, self).__init__()\\n self.height, self.width = input_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.hidden_dim = hidden_dim\\n self.bias = bias\\n self.dtype = dtype\\n\\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\\n\\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\\n out_channels=self.hidden_dim, # for candidate neural memory\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\",\n \"def __init__(\\n self,\\n input_size,\\n hidden_size,\\n num_layers=1,\\n bidirectional=False,\\n dropout=0,\\n **kwargs\\n ):\\n super(GRU, self).__init__(\\n 'gru', input_size, hidden_size,\\n num_layers, bidirectional, dropout, **kwargs\\n )\",\n \"def build_multi_rnn(cells):\\n return tf.nn.rnn_cell.MultiRNNCell(cells)\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(CRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = CNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=n_layers_RNN,\\n )\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def init_gru(rnn):\\n \\n def _concat_init(tensor, init_funcs):\\n (length, fan_out) = tensor.shape\\n fan_in = length // len(init_funcs)\\n \\n for (i, init_func) in enumerate(init_funcs):\\n init_func(tensor[i * fan_in : (i + 1) * fan_in, :])\\n \\n def _inner_uniform(tensor):\\n fan_in = nn.init._calculate_correct_fan(tensor, 'fan_in')\\n nn.init.uniform_(tensor, -math.sqrt(3 / fan_in), math.sqrt(3 / fan_in))\\n \\n for i in range(rnn.num_layers):\\n _concat_init(\\n getattr(rnn, 'weight_ih_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, _inner_uniform]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_ih_l{}'.format(i)), 0)\\n\\n _concat_init(\\n getattr(rnn, 'weight_hh_l{}'.format(i)),\\n [_inner_uniform, _inner_uniform, nn.init.orthogonal_]\\n )\\n torch.nn.init.constant_(getattr(rnn, 'bias_hh_l{}'.format(i)), 0)\",\n \"def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\\n if is_train:\\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\\n return cell\",\n \"def make_cell(self, unit_type, num_units, forget_bias, dropout,\\n mode, residual_connection=False):\\n\\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\\n dropout = dropout if mode == tf.contrib.learn.ModeKeys.TRAIN else 0.0\\n\\n # Cell Type\\n if unit_type == \\\"lstm\\\":\\n cell = tf.contrib.rnn.BasicLSTMCell(\\n num_units,\\n forget_bias=forget_bias)\\n elif unit_type == \\\"gru\\\":\\n cell = tf.contrib.rnn.GRUCell(num_units)\\n elif unit_type == \\\"layer_norm_lstm\\\":\\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units,\\n forget_bias=forget_bias,\\n layer_norm=True)\\n else:\\n raise ValueError(\\\"Unknown unit type %s!\\\" % unit_type)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n cell = tf.contrib.rnn.DropoutWrapper(\\n cell=cell, input_keep_prob=(1.0 - dropout))\\n\\n # Residual\\n if residual_connection:\\n cell = tf.contrib.rnn.ResidualWrapper(cell)\\n\\n return cell\",\n \"def rnn_gru(\\n nclass,\\n input_shape=(187, 1),\\n recurrent_layers=[64, 128],\\n dense_layers=[64, 16],\\n dropout=0.2,\\n binary=False,\\n):\\n if not binary:\\n loss = losses.sparse_categorical_crossentropy\\n last_activation = activations.softmax\\n else:\\n loss = losses.binary_crossentropy\\n last_activation = activations.sigmoid\\n return_sequences = True\\n\\n inp = Input(shape=input_shape)\\n x = inp\\n for i, neurons in enumerate(recurrent_layers):\\n x = GRU(neurons, return_sequences=return_sequences)(x)\\n x = Dropout(rate=dropout)(x)\\n return_sequences = False\\n for i, neurons in enumerate(dense_layers):\\n x = Dense(neurons, name=f\\\"dense_{i+1}\\\", activation=\\\"relu\\\")(x)\\n x = Dense(nclass, name=\\\"Output\\\", activation=last_activation)(x)\\n\\n model = models.Model(inputs=inp, outputs=x)\\n opt = optimizers.Adam(0.001)\\n model.compile(optimizer=opt, loss=loss, metrics=[\\\"acc\\\"])\\n model.summary()\\n return model\",\n \"def __init__(self, num_nodes, h_dim, out_dim, num_rels,\\n num_bases=-1, num_hidden_layers=1, dropout=0.5, bias=False):\\n super(RGCN, self).__init__()\\n self.num_nodes = num_nodes\\n self.h_dim = h_dim\\n self.out_dim = out_dim\\n self.num_rels = num_rels\\n self.num_bases = num_bases\\n self.num_hidden_layers = num_hidden_layers\\n self.dropout = dropout\\n self.bias = bias\\n\\n self.layers = nn.ModuleList()\\n # create rgcn layers\\n self.build_model()\",\n \"def build_gru_model(num_features,\\n embedding_size=None,\\n kernel_size=None,\\n filters=None,\\n pool_size=None,\\n gru_output_size=None):\\n # Embedding\\n if embedding_size is None:\\n embedding_size = 64\\n\\n # Convolution\\n if kernel_size is None:\\n kernel_size = 5\\n if filters is None:\\n filters = 64\\n if pool_size is None:\\n pool_size = 4\\n\\n # GRU\\n if gru_output_size is None:\\n gru_output_size = 70\\n\\n print('Build model...')\\n\\n gru_model = models.gru(num_features,\\n embedding_size=embedding_size,\\n kernel_size=kernel_size,\\n filters=filters,\\n pool_size=pool_size,\\n gru_output_size=gru_output_size)\\n\\n return gru_model\",\n \"def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\\n if layer_type == \\\"layernorm_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\\n else:\\n if layer_type == \\\"lstm\\\":\\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\\n elif layer_type == \\\"gru\\\":\\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_gru\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\\n else:\\n raise ValueError(\\\"Error: not supported rnn type:{}\\\".format(layer_type))\\n\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, output_keep_prob=dropout_keep_prob)\\n return cell\",\n \"def build_rnn(cell, inputs):\\n #_,initial_state = get_init_cell(batch_size, rnn_size)\\n \\n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name='final_state')\\n\\n return (output, final_state)\",\n \"def _create_rnn_cells(self, is_list=False):\\n\\n stacked_rnn = []\\n for _ in range(self.num_layers):\\n single_cell = self._rnn_single_cell()\\n stacked_rnn.append(single_cell)\\n\\n if is_list:\\n return stacked_rnn\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(\\n cells=stacked_rnn,\\n state_is_tuple=True)\",\n \"def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\\n #====================================================================================#\\n # ----------PROBLEM 2----------\\n #====================================================================================#\\n # YOUR CODE HERE\\n # raise NotImplementedError\\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\\n ## step 1 - inputs are first embedded by an MLP\\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\\n # print(\\\"after build_mlp x = \\\", x)\\n ## step 2 - passed to a GRU cell\\n # as \\\"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\\\"hidden\\\", dtype=tf.float32)\\\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\\n # after build_mlp x = Tensor(\\\"continuous_logits/continuous_logits/fc1/BiasAdd:0\\\", shape=(?, 1, 32), dtype=float32)\\n # x = tf.squeeze(x, axis=1)\\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\\n # print(\\\"dynamic_rnn build_mlp x = \\\", x, \\\" h = \\\", h)\\n return x, h\",\n \"def MakeFancyRNNCell(H, keep_prob, num_layers=1):\\n cells = []\\n for _ in range(num_layers):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cells.append(cell)\\n return tf.nn.rnn_cell.MultiRNNCell(cells)\",\n \"def __init__(self, rnn_cell, batch_size,\\n input_size, num_outputs):\\n super().__init__(name='RNNCellStateModel')\\n self._rnn_cell = rnn_cell\\n self._batch_size = batch_size\\n self._input_size = input_size\\n self._num_outputs = num_outputs\",\n \"def __init__(self,input_dim, hidden_dim, kernel_sizes, num_layers,gb_hidden_size):\\r\\n\\r\\n super().__init__()\\r\\n\\r\\n self.input_size = input_dim\\r\\n self.input_dim =input_dim\\r\\n\\r\\n if type(hidden_dim) != list:\\r\\n self.hidden_sizes = [hidden_dim]*num_layers\\r\\n else:\\r\\n assert len(hidden_dim) == num_layers, '`hidden_sizes` must have the same length as n_layers'\\r\\n self.hidden_sizes = hidden_dim\\r\\n if type(kernel_sizes) != list:\\r\\n self.kernel_sizes = [kernel_sizes]*num_layers\\r\\n else:\\r\\n assert len(kernel_sizes) == num_layers, '`kernel_sizes` must have the same length as n_layers'\\r\\n self.kernel_sizes = kernel_sizes\\r\\n\\r\\n self.n_layers = num_layers\\r\\n\\r\\n cells = nn.ModuleList()\\r\\n squenceCells=nn.ModuleList()\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n if i == 0:\\r\\n input_dim = self.input_size\\r\\n else:\\r\\n input_dim = self.hidden_sizes[i-1]\\r\\n\\r\\n cell = ConvGRUCell(self.input_dim[i], self.hidden_sizes[i], 3)\\r\\n\\r\\n cells.append(cell)\\r\\n\\r\\n self.cells = cells\\r\\n\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n squenceCell = SequenceGRU(gb_hidden_size[i])\\r\\n\\r\\n squenceCells.append(squenceCell)\\r\\n\\r\\n self.squenceCells = squenceCells\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias):\\n super(ModGRUCell, self).__init__()\\n\\n self.height, self.width = input_size\\n self.input_dim = input_dim\\n self.hidden_dim = hidden_dim\\n\\n self.kernel_size = kernel_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.bias = bias\\n\\n self.conv1 = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\\n out_channels=1,\\n kernel_size=self.kernel_size,\\n padding=self.padding,\\n bias=self.bias)\\n \\n self.conv2 = nn.Conv2d(in_channels=self.input_dim,\\n out_channels=self.hidden_dim,\\n kernel_size=self.kernel_size,\\n padding=self.padding,\\n bias=self.bias)\",\n \"def param_init_gru(options, params, prefix='gru', nin=None, dim=None):\\n\\tif nin == None:\\n\\t\\tnin = options['dim_proj']\\n\\tif dim == None:\\n\\t\\tdim = options['dim_proj']\\n\\tW = numpy.concatenate([norm_weight(nin,dim),\\n\\t\\t\\t\\t\\t\\t norm_weight(nin,dim)], axis=1)\\n\\tparams[_p(prefix,'W')] = W\\n\\tparams[_p(prefix,'b')] = numpy.zeros((2 * dim,)).astype('float32')\\n\\tU = numpy.concatenate([ortho_weight(dim),\\n\\t\\t\\t\\t\\t\\t ortho_weight(dim)], axis=1)\\n\\tparams[_p(prefix,'U')] = U\\n\\n\\tWx = norm_weight(nin, dim)\\n\\tparams[_p(prefix,'Wx')] = Wx\\n\\tUx = ortho_weight(dim)\\n\\tparams[_p(prefix,'Ux')] = Ux\\n\\tparams[_p(prefix,'bx')] = numpy.zeros((dim,)).astype('float32')\\n\\n\\treturn params\",\n \"def __init__(self,\\n num_units,\\n num_dims=1,\\n input_dims=None,\\n output_dims=None,\\n priority_dims=None,\\n non_recurrent_dims=None,\\n tied=False,\\n cell_fn=None,\\n non_recurrent_fn=None,\\n state_is_tuple=True,\\n output_is_tuple=True):\\n if not state_is_tuple:\\n logging.warning('%s: Using a concatenated state is slower and will '\\n 'soon be deprecated. Use state_is_tuple=True.', self)\\n if not output_is_tuple:\\n logging.warning('%s: Using a concatenated output is slower and will '\\n 'soon be deprecated. Use output_is_tuple=True.', self)\\n\\n if num_dims < 1:\\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\\n\\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\\n priority_dims, non_recurrent_dims,\\n non_recurrent_fn or nn.relu, tied,\\n num_units)\\n\\n self._state_is_tuple = state_is_tuple\\n self._output_is_tuple = output_is_tuple\\n\\n if cell_fn is None:\\n my_cell_fn = functools.partial(\\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\\n else:\\n my_cell_fn = lambda: cell_fn(num_units)\\n if tied:\\n self._cells = [my_cell_fn()] * num_dims\\n else:\\n self._cells = [my_cell_fn() for _ in range(num_dims)]\\n if not isinstance(self._cells[0], rnn.RNNCell):\\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\\n type(self._cells[0]))\\n\\n if self._output_is_tuple:\\n self._output_size = tuple(self._cells[0].output_size\\n for _ in self._config.outputs)\\n else:\\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\\n\\n if self._state_is_tuple:\\n self._state_size = tuple(self._cells[0].state_size\\n for _ in self._config.recurrents)\\n else:\\n self._state_size = self._cell_state_size() * len(self._config.recurrents)\",\n \"def rnn_gru_bidir(\\n nclass,\\n input_shape=(187, 1),\\n recurrent_layers=[64, 128],\\n dense_layers=[64, 16],\\n dropout=0.2,\\n binary=False,\\n):\\n if not binary:\\n loss = losses.sparse_categorical_crossentropy\\n last_activation = activations.softmax\\n else:\\n loss = losses.binary_crossentropy\\n last_activation = \\\"sigmoid\\\"\\n return_sequences = True\\n\\n inp = Input(shape=input_shape)\\n x = inp\\n for i, neurons in enumerate(recurrent_layers):\\n layer = GRU(neurons, return_sequences=return_sequences)\\n x = Bidirectional(layer)(x)\\n x = Dropout(rate=dropout)(x)\\n return_sequences = False\\n for i, neurons in enumerate(dense_layers):\\n x = Dense(neurons, name=f\\\"dense_{i+1}\\\", activation=\\\"relu\\\")(x)\\n x = Dense(nclass, name=\\\"Output\\\", activation=last_activation)(x)\\n\\n model = models.Model(inputs=inp, outputs=x)\\n opt = optimizers.Adam(0.001)\\n model.compile(optimizer=opt, loss=loss, metrics=[\\\"acc\\\"])\\n model.summary()\\n return model\",\n \"def __call__(self, inputs, state, scope=None, *args, **kwargs):\\r\\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\\r\\n # Instead, it is up to subclasses to provide a proper build\\r\\n # method. See the class docstring for more details.\\r\\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\\r\\n *args, **kwargs)\",\n \"def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\\n readout_init, readout_apply = stax.Dense(num_outputs)\\n\\n def init_fun(key, input_shape):\\n \\\"\\\"\\\"Initialize the components of the RNN.\\n\\n Args:\\n key: Jax PRNGkey used to initialize the parameters.\\n input_shape: tuple representing the input shape, should be\\n (batch_size, sequence_length).\\n\\n Returns:\\n shapes: set of tuples representing the shapes after applying\\n the Embedding, RNN Cell, and Readout layers.\\n network_params: tuple of network parameters, containing the\\n embedding, RNN cell, and readout parameters.\\n \\\"\\\"\\\"\\n\\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\\n\\n # Initialize the Embedding for the input tokens.\\n emb_shape, emb_params = emb_init(emb_key, input_shape)\\n\\n # The cell is defined for a single update step, which is why we ignore\\n # the sequence dimension (emb_shape[1]) here.\\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\\n\\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\\n\\n shapes = (emb_shape, rnn_shape, output_shape)\\n network_params = (emb_params, rnn_params, readout_params)\\n\\n return shapes, network_params\\n\\n def apply_fun(network_params, tokens):\\n \\\"\\\"\\\"Applies the RNN on a batch of input sequences.\\n\\n Args:\\n network_params: tuple of network parameters (see init_fun).\\n tokens: batch of inputs, with shape (batch_size, sequence_length).\\n\\n Returns:\\n outputs: network outputs, at every step along the sequence.\\n \\\"\\\"\\\"\\n emb_params, rnn_params, readout_params = network_params\\n\\n # Apply the embedding.\\n inputs = emb_apply(emb_params, tokens)\\n\\n # Run the RNN.\\n initial_states = cell.get_initial_state(rnn_params,\\n batch_size=tokens.shape[0])\\n return unroll.unroll_rnn(initial_states, inputs,\\n functools.partial(cell.batch_apply, rnn_params),\\n functools.partial(readout_apply, readout_params))\\n\\n return init_fun, apply_fun, emb_apply, readout_apply\",\n \"def GRU(previous_hidden_state, x):\\n # R Gate\\n r = tf.sigmoid(tf.matmul(x, Wr) + \\\\\\n tf.matmul(previous_hidden_state, Ur) + br)\\n # U Gate\\n u = tf.sigmoid(tf.matmul(x, Wu) + \\\\\\n tf.matmul(previous_hidden_state, Uu) + bu)\\n # Final Memory cell\\n c = tf.tanh(tf.matmul(x, Wh) + \\\\\\n tf.matmul( tf.multiply(r, previous_hidden_state), Uh) + bh)\\n # Current Hidden state\\n current_hidden_state = tf.multiply( (1 - u), previous_hidden_state ) + \\\\\\n tf.multiply( u, c )\\n return current_hidden_state\",\n \"def build_rnn(cell, inputs):\\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name=\\\"final_state\\\")\\n\\n return outputs, final_state\",\n \"def get_gru_node_gene(key, config):\\n gene1 = GruNodeGene(key, config, input_keys=[-1], input_keys_full=[-1, -2])\\n gene1.activation = 'a'\\n gene1.bias_hh = np.zeros(gene1.bias_hh.shape)\\n gene1.bias_ih = np.zeros(gene1.bias_ih.shape)\\n gene1.weight_hh = np.zeros(gene1.weight_hh.shape)\\n gene1.weight_ih_full = np.zeros(gene1.weight_ih_full.shape)\\n gene1.update_weight_ih()\\n gene2 = GruNodeGene(key, config, input_keys=[-1], input_keys_full=[-1, -3])\\n gene2.activation = 'b'\\n gene2.bias_hh = np.ones(gene2.bias_hh.shape)\\n gene2.bias_ih = np.ones(gene2.bias_ih.shape)\\n gene2.weight_hh = np.ones(gene2.weight_hh.shape)\\n gene2.weight_ih_full = np.ones(gene2.weight_ih_full.shape)\\n gene2.update_weight_ih()\\n return gene1, gene2\",\n \"def __init__(\\n self,\\n model_type,\\n num_features,\\n num_classes,\\n reparam_mode,\\n prior_mode,\\n latent_size,\\n sample_size=1,\\n num_layers=2,\\n struct_dropout_mode=(\\\"standard\\\", 0.6),\\n dropout=True,\\n with_relu=True,\\n val_use_mean=True,\\n reparam_all_layers=True,\\n normalize=True,\\n is_cuda=False,\\n ):\\n super(GNN, self).__init__()\\n self.model_type = model_type\\n self.num_features = num_features\\n self.num_classes = num_classes\\n self.normalize = normalize\\n self.reparam_mode = reparam_mode\\n self.prior_mode = prior_mode\\n self.struct_dropout_mode = struct_dropout_mode\\n self.dropout = dropout\\n self.latent_size = latent_size\\n self.sample_size = sample_size\\n self.num_layers = num_layers\\n self.with_relu = with_relu\\n self.val_use_mean = val_use_mean\\n self.reparam_all_layers = reparam_all_layers\\n self.is_cuda = is_cuda\\n self.device = torch.device(self.is_cuda if isinstance(self.is_cuda, str) else \\\"cuda\\\" if self.is_cuda else \\\"cpu\\\")\\n\\n self.init()\",\n \"def _create_rnn_cell(num_units, num_layers, mode):\\n\\n cell_list = []\\n for i in range(num_layers):\\n single_cell = STLSTMCell(name=\\\"stlstm\\\",\\n num_units=num_units,\\n st_activation=tf.nn.relu,\\n st_kernel_initializer=tf.glorot_uniform_initializer(),\\n st_num_layers=2,\\n st_residual=True)\\n cell_list.append(single_cell)\\n\\n return cell_list\",\n \"def __init__(self, input_size, hidden_size, output_size, model=\\\"gru\\\", n_layers=1):\\n \\n super(CharRNN, self).__init__()\\n\\n self.input_size = input_size\\n self.hidden_size = hidden_size\\n self.output_size = output_size\\n self.n_layers = n_layers\\n\\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\\n \\n self.model = model\\n if model.lower() == \\\"lstm\\\":\\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\\n else: # model is GRU\\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\\n\\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer\",\n \"def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\\n if rnn_type.endswith('lstm'):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n elif rnn_type.endswith('gru'):\\n cell = tc.rnn.GRUCell(num_units=hidden_size)\\n elif rnn_type.endswith('rnn'):\\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\\n else:\\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n if layer_num > 1:\\n cell = tc.rnn.MultiRNNCell([cell] * layer_num, state_is_tuple=True)\\n return cell\",\n \"def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\\n residual_connection=False, device_str=None):\\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\\n dropout = dropout if mode == \\\"train\\\" else 0.0\\n # Cell Type\\n if unit_type == \\\"lstm\\\":\\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\\n\\n elif unit_type == \\\"gru\\\":\\n single_cell = tf.contrib.rnn.GRUCell(num_units)\\n\\n elif unit_type == \\\"layer_norm_lstm\\\":\\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units,layer_norm=True)\\n else:\\n raise ValueError(\\\"Unknown unit type %s!\\\" % unit_type)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.contrib.rnn.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\\n\\n return single_cell\",\n \"def rnn_cell(hprev, zt, name=None, reuse=False):\\n nin = zt.shape[-1].value\\n nout = hprev.shape[-1].value\\n with tf.variable_scope(name, default_name=\\\"rnn\\\", values=[hprev, zt], reuse=reuse):\\n wz = get_variable_wrap(\\\"kernel/input\\\", [nin, nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n wh = get_variable_wrap(\\\"kernel/hidden\\\", [nout, nout],dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n bh = get_variable_wrap(\\\"bias\\\", [nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n \\n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)\",\n \"def __call__(self, inputs, state, scope=None):\\n with vs.variable_scope(scope or type(self).__name__): # \\\"GRUCell\\\" \\n with vs.variable_scope(\\\"Gates\\\"): # Reset gate and update gate. \\n # We start with bias of 1.0 to not reset and not update. \\n r, u = array_ops.split(1, 2, rnn_cell.linear([inputs, state],\\n 2 * self._num_units, True, 1.0))\\n r, u = tf.sigmoid(r), tf.sigmoid(u)\\n with vs.variable_scope(\\\"Candidate\\\"):\\n c = self._activation(rnn_cell.linear([inputs, r * state], self._num_units, True))\\n new_h = u * state + (1 - u) * c\\n return new_h, new_h\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = rnn.LSTMBlockCell(layer_size)\\n cell = rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return rnn.MultiRNNCell(cells)\",\n \"def constructCell():\\n\\t\\tself.weightGenerate()\",\n \"def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\\n is_training=False, cell_name=\\\"GRU\\\", bidirectional=False, swap_memory=False):\\n batch_size = tf.shape(X)[0]\\n if bidirectional:\\n rnn_size /= 2\\n\\n def get_cell():\\n if cell_name == \\\"GRU\\\": # GRU\\n _cell = rnn_cell.GRUCell(rnn_size)\\n elif cell_name == \\\"LSTM\\\": # LSTM\\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\\n else:\\n raise ValueError(\\\"Unrecognized Cell Name: {0}\\\".format(cell_name))\\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\\n _initial_state = _cell.zero_state(batch_size, tf.float32)\\n return _cell, _initial_state\\n\\n if bidirectional:\\n with tf.variable_scope(\\\"forward\\\"):\\n cell_fw, initial_state_fw = get_cell()\\n with tf.variable_scope(\\\"backward\\\"):\\n cell_bw, initial_state_bw = get_cell()\\n return rnn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, X, sequence_length=seq_len,\\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\\n else:\\n cell, initial_state = get_cell()\\n return rnn.dynamic_rnn(\\n cell, X, sequence_length=seq_len, initial_state=initial_state,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\",\n \"def __init__(self, encoder_type=\\\"uni\\\", num_layers=1,\\n cell_type=\\\"gru\\\", num_units=512, dropout=0.8,\\n dtype=tf.float32):\\n\\n self.encoder_type = encoder_type\\n self.num_layers = num_layers\\n self.cell_type = cell_type\\n self.num_units = num_units\\n self.dropout = dropout\\n self.dtype = dtype\",\n \"def __init__(self, cell, attn_inputs, \\n attn_size, attn_vec_size,\\n output_size=None, input_size=None, \\n state_is_tuple=True, attn_masks=None,\\n merge_output_attn='linear',\\n reuse=None):\\n if not isinstance(cell, rnn.RNNCell):\\n raise TypeError(\\\"The parameter cell is not RNNCell.\\\")\\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\\n raise ValueError(\\\"Cell returns tuple of states, but the flag \\\"\\n \\\"state_is_tuple is not set. State size is: %s\\\"\\n % str(cell.state_size))\\n if not state_is_tuple:\\n logging.warn(\\n \\\"%s: Using a concatenated state is slower and will soon be \\\"\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\n\\n self._state_is_tuple = state_is_tuple\\n\\n if not state_is_tuple:\\n raise NotImplementedError\\n\\n self._cell = cell\\n self._input_size = input_size\\n self._output_size = output_size\\n if output_size is None:\\n self._output_size = cell.output_size\\n self._attn_size = attn_size\\n self._reuse = reuse\\n self._attn_inputs = attn_inputs\\n self._attn_vec_size = attn_vec_size\\n self.attn_masks = attn_masks\\n self.merge_output_attn = merge_output_attn\",\n \"def get_init_cell(batch_size, rnn_size):\\n\\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\\n num_of_layers = 3\\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name='initial_state')\\n \\n return (cell, initial_state)\",\n \"def gru_cell(self, Xt, h_t_minus_1):\\n # 1.update gate: decides how much past information is kept and how much new information is added.\\n z_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_z) + tf.matmul(h_t_minus_1,self.U_z) + self.b_z) # z_t:[batch_size,self.hidden_size]\\n # 2.reset gate: controls how much the past state contributes to the candidate state.\\n r_t = tf.nn.sigmoid(tf.matmul(Xt, self.W_r) + tf.matmul(h_t_minus_1,self.U_r) + self.b_r) # r_t:[batch_size,self.hidden_size]\\n # candiate state h_t~\\n h_t_candiate = tf.nn.tanh(tf.matmul(Xt, self.W_h) +r_t * (tf.matmul(h_t_minus_1, self.U_h)) + self.b_h) # h_t_candiate:[batch_size,self.hidden_size]\\n # new state: a linear combine of pervious hidden state and the current new state h_t~\\n h_t = (1 - z_t) * h_t_minus_1 + z_t * h_t_candiate # h_t:[batch_size*num_sentences,hidden_size]\\n return h_t\",\n \"def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\\n is_batch_norm, is_bidirectional):\\n if is_batch_norm:\\n input_data = tf.keras.layers.BatchNormalization(\\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\\n rnn_layer = rnn_cell(\\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\\n name=\\\"rnn_{}\\\".format(layer_id))\\n if is_bidirectional:\\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\\\"sum\\\")\\n\\n return rnn_layer(input_data)\",\n \"def bidirectional_gru_encoder(cell_fw, cell_bw, embedding, init_state, batch_input_fw, batch_input_bw, batch_mask):\\n # Forward direction\\n outputs_fw, _ = gru_encoder(cell_fw, embedding, init_state, batch_input_fw, batch_mask)\\n\\n # Backward direction\\n outputs_bw, _ = gru_encoder(cell_bw, embedding, init_state, batch_input_bw, batch_mask)\\n\\n outputs = [tf.concat(1, [fw, bw]) for fw, bw in zip(outputs_fw, outputs_bw)]\\n return outputs\",\n \"def convert_rnn(g, op, block):\\n\\n def generate_lstm(\\n input_seqs,\\n hidden_state,\\n cell_state,\\n w_inp,\\n w_hid,\\n b_inp,\\n b_hid,\\n f_act,\\n g_act,\\n h_act,\\n backwards=False,\\n ):\\n \\\"\\\"\\\"Implementation of LSTM cell for paddlepaddle of TVM\\\"\\\"\\\"\\n\\n h_list = []\\n seq_length = len(input_seqs)\\n for i in range(seq_length):\\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\\n step = _op.squeeze(step, axis=[0])\\n gates = _op.nn.dense(step, w_inp) + _op.nn.dense(hidden_state, w_hid)\\n if b_inp is not None:\\n gates += b_inp\\n if b_hid is not None:\\n gates += b_hid\\n i, f, c, o = _op.split(gates, 4, axis=-1)\\n\\n i = f_act(i)\\n f = f_act(f)\\n\\n c = g_act(c)\\n C = f * cell_state + i * c\\n\\n o = f_act(o)\\n\\n H = o * h_act(C)\\n\\n hidden_state = H\\n cell_state = C\\n h_list.append(_op.expand_dims(H, axis=0))\\n\\n if backwards:\\n h_list = h_list[::-1]\\n\\n # Concatenate outputs and add back in direction axis.\\n concatenated = _op.concatenate(h_list, 0)\\n output = _op.expand_dims(concatenated, axis=1)\\n hidden_state = _op.expand_dims(hidden_state, axis=0)\\n cell_state = _op.expand_dims(cell_state, axis=0)\\n\\n return output, hidden_state, cell_state\\n\\n def generate_gru(\\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, rz_act, n_act, backwards=False\\n ):\\n \\\"\\\"\\\"Implementation of GRU cell for paddlepaddle of TVM\\\"\\\"\\\"\\n\\n h_list = []\\n seq_length = len(input_seqs)\\n for i in range(seq_length):\\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\\n step = _op.squeeze(step, axis=[0])\\n xwt = _op.nn.dense(step, w_inp)\\n hwt = _op.nn.dense(hidden_state, w_hid)\\n if b_inp is not None:\\n xwt += b_inp\\n if b_hid is not None:\\n hwt += b_hid\\n i_r, i_z, i_n = _op.split(xwt, 3, axis=-1)\\n h_r, h_z, h_n = _op.split(hwt, 3, axis=-1)\\n\\n r_gate = rz_act(i_r + h_r)\\n z_gate = rz_act(i_z + h_z)\\n n_gate = n_act(i_n + r_gate * h_n)\\n\\n hidden_state = (hidden_state - n_gate) * z_gate + n_gate\\n h_list.append(_op.expand_dims(hidden_state, axis=0))\\n\\n if backwards:\\n h_list = h_list[::-1]\\n\\n # Concatenate outputs and add back in direction axis.\\n concatenated = _op.concatenate(h_list, 0)\\n output = _op.expand_dims(concatenated, axis=1)\\n hidden_state = _op.expand_dims(hidden_state, axis=0)\\n\\n return output, hidden_state\\n\\n def generate_simplernn(\\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, n_act, backwards=False\\n ):\\n \\\"\\\"\\\"Implementation of SimpleRNN cell for paddlepaddle of TVM\\\"\\\"\\\"\\n\\n h_list = []\\n seq_length = len(input_seqs)\\n for i in range(seq_length):\\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\\n step = _op.squeeze(step, axis=[0])\\n xwt = _op.nn.dense(step, w_inp)\\n hwt = _op.nn.dense(hidden_state, w_hid)\\n if b_inp is not None:\\n xwt += b_inp\\n if b_hid is not None:\\n hwt += b_hid\\n\\n n_gate = n_act(xwt + hwt)\\n\\n hidden_state = n_gate\\n h_list.append(_op.expand_dims(hidden_state, axis=0))\\n\\n if backwards:\\n h_list = h_list[::-1]\\n\\n # Concatenate outputs and add back in direction axis.\\n concatenated = _op.concatenate(h_list, 0)\\n output = _op.expand_dims(concatenated, axis=1)\\n hidden_state = _op.expand_dims(hidden_state, axis=0)\\n\\n return output, hidden_state\\n\\n def make_param_inputs(g, node, layer, hidden_size, num_layers):\\n \\\"\\\"\\\"Param for weight and bias.\\\"\\\"\\\"\\n\\n bidirect_len = 4 if node.attr(\\\"is_bidirec\\\") else 2\\n all_layer_param_len = len(node.input(\\\"WeightList\\\"))\\n weight_list = node.input(\\\"WeightList\\\")[: all_layer_param_len // 2]\\n bias_list = node.input(\\\"WeightList\\\")[all_layer_param_len // 2 :]\\n\\n layer_weight_list = weight_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\\n layer_bias_list = bias_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\\n param_list = layer_weight_list + layer_bias_list\\n param_list_len = len(param_list)\\n\\n input_weights = param_list[0 : param_list_len // 2 : 2]\\n hidden_weights = param_list[1 : param_list_len // 2 : 2]\\n\\n input_bias = param_list[param_list_len // 2 : param_list_len : 2]\\n hidden_bias = param_list[param_list_len // 2 + 1 : param_list_len : 2]\\n\\n return input_weights, hidden_weights, input_bias, hidden_bias\\n\\n def make_init_param_inputs(g, node, layer):\\n \\\"\\\"\\\"Init param for inputs.\\\"\\\"\\\"\\n\\n mode = node.attr(\\\"mode\\\")\\n if mode == \\\"LSTM\\\":\\n all_init_h, all_init_c = node.input(\\\"PreState\\\")\\n bidirect_len = 2 if node.attr(\\\"is_bidirec\\\") else 1\\n init_h = _op.strided_slice(\\n g.get_node(all_init_h),\\n [layer * bidirect_len],\\n [layer * bidirect_len + bidirect_len],\\n axes=[0],\\n )\\n init_c = _op.strided_slice(\\n g.get_node(all_init_c),\\n [layer * bidirect_len],\\n [layer * bidirect_len + bidirect_len],\\n axes=[0],\\n )\\n return init_h, init_c\\n all_init_h = node.input(\\\"PreState\\\")[0]\\n bidirect_len = 2 if node.attr(\\\"is_bidirec\\\") else 1\\n init_h = _op.strided_slice(\\n g.get_node(all_init_h),\\n [layer * bidirect_len],\\n [layer * bidirect_len + bidirect_len],\\n axes=[0],\\n )\\n return init_h\\n\\n hidden_size = op.attr(\\\"hidden_size\\\")\\n num_layers = op.attr(\\\"num_layers\\\")\\n is_bidirec = op.attr(\\\"is_bidirec\\\")\\n mode = op.attr(\\\"mode\\\")\\n\\n input_x = g.get_node(op.input(\\\"Input\\\")[0])\\n\\n num_directions = 1\\n if is_bidirec:\\n num_directions = 2\\n\\n x_shape = infer_shape(input_x)\\n time_steps = x_shape[0]\\n x_steps = _op.split(input_x, indices_or_sections=time_steps, axis=0)\\n for layer in range(num_layers):\\n input_weights, hidden_weights, input_bias, hidden_bias = make_param_inputs(\\n g, op, layer, hidden_size, num_layers\\n )\\n if mode == \\\"LSTM\\\":\\n init_h, init_c = make_init_param_inputs(g, op, layer)\\n init_hs = _op.split(init_h, num_directions)\\n init_cs = _op.split(init_c, num_directions)\\n result_output = []\\n result_H = []\\n result_C = []\\n for i in range(num_directions):\\n H_t = _op.squeeze(init_hs[i], axis=[0])\\n C_t = _op.squeeze(init_cs[i], axis=[0])\\n W = g.get_node(input_weights[i])\\n R = g.get_node(hidden_weights[i])\\n WB = g.get_node(input_bias[i])\\n RB = g.get_node(hidden_bias[i])\\n output, H, C = generate_lstm(\\n input_seqs=x_steps,\\n hidden_state=H_t,\\n cell_state=C_t,\\n w_inp=W,\\n w_hid=R,\\n b_inp=WB,\\n b_hid=RB,\\n f_act=_op.sigmoid,\\n g_act=_op.tanh,\\n h_act=_op.tanh,\\n backwards=i == 1,\\n )\\n result_output.append(output)\\n result_H.append(H)\\n result_C.append(C)\\n output = _op.concatenate(result_output, axis=1)\\n H = _op.concatenate(result_H, axis=0)\\n C = _op.concatenate(result_C, axis=0)\\n elif mode == \\\"GRU\\\":\\n init_h = make_init_param_inputs(g, op, layer)\\n init_hs = _op.split(init_h, num_directions)\\n result_output = []\\n result_H = []\\n for i in range(num_directions):\\n H_t = _op.squeeze(init_hs[i], axis=[0])\\n W = g.get_node(input_weights[i])\\n R = g.get_node(hidden_weights[i])\\n WB = g.get_node(input_bias[i])\\n RB = g.get_node(hidden_bias[i])\\n output, H = generate_gru(\\n input_seqs=x_steps,\\n hidden_state=H_t,\\n w_inp=W,\\n w_hid=R,\\n b_inp=WB,\\n b_hid=RB,\\n rz_act=_op.sigmoid,\\n n_act=_op.tanh,\\n backwards=i == 1,\\n )\\n result_output.append(output)\\n result_H.append(H)\\n output = _op.concatenate(result_output, axis=1)\\n H = _op.concatenate(result_H, axis=0)\\n elif mode == \\\"RNN_TANH\\\":\\n init_h = make_init_param_inputs(g, op, layer)\\n init_hs = _op.split(init_h, num_directions)\\n result_output = []\\n result_H = []\\n for i in range(num_directions):\\n H_t = _op.squeeze(init_hs[i], axis=[0])\\n W = g.get_node(input_weights[i])\\n R = g.get_node(hidden_weights[i])\\n WB = g.get_node(input_bias[i])\\n RB = g.get_node(hidden_bias[i])\\n output, H = generate_simplernn(\\n input_seqs=x_steps,\\n hidden_state=H_t,\\n w_inp=W,\\n w_hid=R,\\n b_inp=WB,\\n b_hid=RB,\\n n_act=_op.tanh,\\n backwards=i == 1,\\n )\\n result_output.append(output)\\n result_H.append(H)\\n output = _op.concatenate(result_output, axis=1)\\n H = _op.concatenate(result_H, axis=0)\\n\\n output = _op.transpose(output, axes=[0, 2, 1, 3])\\n output = _op.reshape(output, newshape=(0, 0, -1))\\n x_steps = _op.split(output, indices_or_sections=time_steps, axis=0)\\n\\n g.add_node(op.output(\\\"Out\\\")[0], output)\",\n \"def get_init_cell(batch_size, rnn_size):\\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name=\\\"initial_state\\\")\\n\\n return cell, initial_state\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embed = get_embed(input_data, vocab_size, embed_dim) \\n output, final_state = build_rnn(cell, embed)\\n \\n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\\n #final_state = tf.identity(final_state, name='final_state') \\n return logits, final_state\",\n \"def __init__(self, cell, input_keep_prob=1.0, output_keep_prob=1.0,\\n state_keep_prob=1.0, variational_recurrent=False,\\n input_size=None, dtype=None, seed=None,\\n dropout_state_filter_visitor=None):\\n if not _like_rnncell(cell):\\n raise TypeError(\\\"The parameter cell is not a RNNCell.\\\")\\n if (dropout_state_filter_visitor is not None\\n and not callable(dropout_state_filter_visitor)):\\n raise TypeError(\\\"dropout_state_filter_visitor must be callable\\\")\\n self._dropout_state_filter = (\\n dropout_state_filter_visitor or _default_dropout_state_filter_visitor)\\n with ops.name_scope(\\\"DropoutWrapperInit\\\"):\\n def tensor_and_const_value(v):\\n tensor_value = ops.convert_to_tensor(v)\\n const_value = tensor_util.constant_value(tensor_value)\\n return (tensor_value, const_value)\\n for prob, attr in [(input_keep_prob, \\\"input_keep_prob\\\"),\\n (state_keep_prob, \\\"state_keep_prob\\\"),\\n (output_keep_prob, \\\"output_keep_prob\\\")]:\\n tensor_prob, const_prob = tensor_and_const_value(prob)\\n if const_prob is not None:\\n if const_prob < 0 or const_prob > 1:\\n raise ValueError(\\\"Parameter %s must be between 0 and 1: %d\\\"\\n % (attr, const_prob))\\n setattr(self, \\\"_%s\\\" % attr, float(const_prob))\\n else:\\n setattr(self, \\\"_%s\\\" % attr, tensor_prob)\\n\\n # Set cell, variational_recurrent, seed before running the code below\\n self._cell = cell\\n self._variational_recurrent = variational_recurrent\\n self._seed = seed\\n\\n self._recurrent_input_noise = None\\n self._recurrent_state_noise = None\\n self._recurrent_output_noise = None\\n\\n if variational_recurrent:\\n if dtype is None:\\n raise ValueError(\\n \\\"When variational_recurrent=True, dtype must be provided\\\")\\n\\n def convert_to_batch_shape(s):\\n # Prepend a 1 for the batch dimension; for recurrent\\n # variational dropout we use the same dropout mask for all\\n # batch elements.\\n return array_ops.concat(\\n ([1], tensor_shape.TensorShape(s).as_list()), 0)\\n\\n def batch_noise(s, inner_seed):\\n shape = convert_to_batch_shape(s)\\n return random_ops.random_uniform(shape, seed=inner_seed, dtype=dtype)\\n\\n if (not isinstance(self._input_keep_prob, numbers.Real) or\\n self._input_keep_prob < 1.0):\\n if input_size is None:\\n raise ValueError(\\n \\\"When variational_recurrent=True and input_keep_prob < 1.0 or \\\"\\n \\\"is unknown, input_size must be provided\\\")\\n self._recurrent_input_noise = _enumerated_map_structure_up_to(\\n input_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"input\\\", i)),\\n input_size)\\n self._recurrent_state_noise = _enumerated_map_structure_up_to(\\n cell.state_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"state\\\", i)),\\n cell.state_size)\\n self._recurrent_output_noise = _enumerated_map_structure_up_to(\\n cell.output_size,\\n lambda i, s: batch_noise(s, inner_seed=self._gen_seed(\\\"output\\\", i)),\\n cell.output_size)\",\n \"def __init__(self, num_nodes, num_features, num_timesteps_input,\\n num_timesteps_output, gcn_type='normal', hidden_size=64, num_comps=10):\\n super(KRNN, self).__init__()\\n self.encoders = nn.ModuleList()\\n self.decoders = nn.ModuleList()\\n self.linears = nn.ModuleList()\\n\\n self.num_timesteps_output = num_timesteps_output\\n\\n for r in range(num_comps):\\n self.encoders.append(\\n nn.GRU(num_features, hidden_size)\\n )\\n self.decoders.append(\\n nn.GRUCell(1, hidden_size)\\n )\\n self.linears.append(\\n nn.Linear(hidden_size, 1)\\n )\\n\\n self.embed = nn.Parameter(torch.FloatTensor(num_nodes, num_comps))\\n self.embed.data.normal_()\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embedding = get_embed(input_data, vocab_size, rnn_size)\\n outputs, final_state = build_rnn(cell, embedding)\\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\\n\\n return logits, final_state\",\n \"def build(self, input_tensors, is_training, lengths=None, hparams=None):\\n input_tensor = input_tensors[-1]\\n rnn_cell = tf.compat.v1.nn.rnn_cell.BasicRNNCell(\\n num_units=self._output_size, activation=tf.nn.tanh)\\n net, _ = tf.compat.v1.nn.dynamic_rnn(\\n rnn_cell, input_tensor, sequence_length=lengths, dtype=tf.float32)\\n\\n if self._skip:\\n net += _add_projection_if_needed(input_tensor, net)\\n\\n return input_tensors + [net]\",\n \"def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\\n\\t\\treturn _mh.create_rnn_cell(\\n\\t\\t\\tunit_type=hparams.unit_type,\\n\\t\\t\\tnum_units=self.num_units,\\n\\t\\t\\tnum_layers=num_layers,\\n\\t\\t\\tnum_residual_layers=num_residual_layers,\\n\\t\\t\\tforget_bias=hparams.forget_bias,\\n\\t\\t\\tdropout=hparams.dropout,\\n\\t\\t\\tmode=self.mode)\",\n \"def _rnn_relu_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):\\n if b_ih is None:\\n igates = P.MatMul(False, True)(inputs, w_ih)\\n hgates = P.MatMul(False, True)(hidden, w_hh)\\n else:\\n igates = P.MatMul(False, True)(inputs, w_ih) + b_ih\\n hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh\\n return P.ReLU()(igates + hgates)\",\n \"def _rnn_cells(self) -> RNNCellTuple:\\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\\n if attn_len and not cells:\\n # Add attention wrapper to first layer.\\n cell = tf.contrib.rnn.AttentionCellWrapper(\\n cell, attn_len, state_is_tuple=True)\\n cell = tf.contrib.rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return tf.contrib.rnn.MultiRNNCell(cells)\",\n \"def __init__(self,\\n num_units,\\n forget_bias=1.0,\\n activation=None,\\n reuse=None,\\n layer_norm: bool=False,\\n norm_shift: float=0.0,\\n norm_gain: float=1.0, # layer normalization\\n dropout_keep_prob_in: float = 1.0,\\n dropout_keep_prob_h: float=1.0,\\n dropout_keep_prob_out: float=1.0,\\n dropout_keep_prob_gate: float=1.0,\\n dropout_keep_prob_forget: float=1.0,\\n dropout_prob_seed: int=None,\\n variational_dropout: bool=False,\\n recurrent_dropout: bool=False\\n ):\\n super(CustomLSTMCell, self).__init__(_reuse=reuse)\\n self._num_units = num_units\\n self._forget_bias = forget_bias\\n self._activation = activation or math_ops.tanh\\n\\n self._layer_norm = layer_norm\\n self._g = norm_gain\\n self._b = norm_shift\\n\\n self._recurrent_dropout = recurrent_dropout\\n self._variational_dropout = variational_dropout\\n \\n self._seed = dropout_prob_seed\\n self._keep_prob_i = dropout_keep_prob_in\\n self._keep_prob_g = dropout_keep_prob_gate\\n self._keep_prob_f = dropout_keep_prob_forget\\n self._keep_prob_o = dropout_keep_prob_out\\n self._keep_prob_h = dropout_keep_prob_h\",\n \"def gru_layer(tparams, state_below, options, prefix='gru', mask=None, **kwargs):\\n\\tnsteps = state_below.shape[0]\\n\\tif state_below.ndim == 3:\\n\\t\\tn_samples = state_below.shape[1]\\n\\telse:\\n\\t\\tn_samples = 1\\n\\n\\tdim = tparams[_p(prefix,'Ux')].shape[1]\\n\\n\\tif mask == None:\\n\\t\\tmask = tensor.alloc(1., state_below.shape[0], 1)\\n\\n\\tdef _slice(_x, n, dim):\\n\\t\\tif _x.ndim == 3:\\n\\t\\t\\treturn _x[:, :, n*dim:(n+1)*dim]\\n\\t\\treturn _x[:, n*dim:(n+1)*dim]\\n\\n\\tstate_below_ = tensor.dot(state_below, tparams[_p(prefix, 'W')]) + tparams[_p(prefix, 'b')]\\n\\tstate_belowx = tensor.dot(state_below, tparams[_p(prefix, 'Wx')]) + tparams[_p(prefix, 'bx')]\\n\\tU = tparams[_p(prefix, 'U')]\\n\\tUx = tparams[_p(prefix, 'Ux')]\\n\\n\\tdef _step_slice(m_, x_, xx_, h_, U, Ux):\\n\\t\\tpreact = tensor.dot(h_, U)\\n\\t\\tpreact += x_\\n\\n\\t\\tr = tensor.nnet.sigmoid(_slice(preact, 0, dim))\\n\\t\\tu = tensor.nnet.sigmoid(_slice(preact, 1, dim))\\n\\n\\t\\tpreactx = tensor.dot(h_, Ux)\\n\\t\\tpreactx = preactx * r\\n\\t\\tpreactx = preactx + xx_\\n\\n\\t\\th = tensor.tanh(preactx)\\n\\n\\t\\th = u * h_ + (1. - u) * h\\n\\t\\th = m_[:,None] * h + (1. - m_)[:,None] * h_\\n\\n\\t\\treturn h\\n\\n\\tseqs = [mask, state_below_, state_belowx]\\n\\t_step = _step_slice\\n\\n\\trval, updates = theano.scan(_step,\\n\\t\\t\\t\\t\\t\\t\\t\\tsequences=seqs,\\n\\t\\t\\t\\t\\t\\t\\t\\toutputs_info = [tensor.alloc(0., n_samples, dim)],\\n\\t\\t\\t\\t\\t\\t\\t\\tnon_sequences = [tparams[_p(prefix, 'U')],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t tparams[_p(prefix, 'Ux')]],\\n\\t\\t\\t\\t\\t\\t\\t\\tname=_p(prefix, '_layers'),\\n\\t\\t\\t\\t\\t\\t\\t\\tn_steps=nsteps,\\n\\t\\t\\t\\t\\t\\t\\t\\tprofile=profile,\\n\\t\\t\\t\\t\\t\\t\\t\\tstrict=True)\\n\\trval = [rval]\\n\\treturn rval\",\n \"def __init__(self, num_units,\\n use_peepholes=False, cell_clip=None,\\n initializer=None, num_proj=None, proj_clip=None,\\n num_unit_shards=None, num_proj_shards=None,\\n forget_bias=1.0, state_is_tuple=False,\\n activation=None, trainable=None, name=None, dtype=None, residual_connection=False, **kwargs):\\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\\n if not state_is_tuple:\\n logging.warn(\\\"%s: Using a concatenated state is slower and will soon be \\\"\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\n if num_unit_shards is not None or num_proj_shards is not None:\\n logging.warn(\\n \\\"%s: The num_unit_shards and proj_unit_shards parameters are \\\"\\n \\\"depreca ted and will be removed in Jan 2017. \\\"\\n \\\"Use a variable scope with a partitioner instead.\\\", self)\\n if context.executing_eagerly() and context.num_gpus() > 0:\\n logging.warn(\\\"%s: Note that this cell is not optimized for performance. \\\"\\n \\\"Please use tf.contrib.cudnn_rnn.CudnnLSTM for better \\\"\\n \\\"performance on GPU.\\\", self)\\n self._num_units = num_units\\n self._use_peepholes = use_peepholes\\n self._cell_clip = cell_clip\\n self._initializer = initializers.get(initializer)\\n self._num_proj = num_proj\\n self._proj_clip = proj_clip\\n self._num_unit_shards = num_unit_shards\\n self._num_proj_shards = num_proj_shards\\n self._forget_bias = forget_bias\\n self._state_is_tuple = state_is_tuple\\n self.residual_connection = residual_connection\\n self._kernel = None\\n self._bias = None\\n self._w_f_diag = None\\n self._w_i_diag = None\\n self._w_o_diag = None\\n self._proj_kernel = None\\n if activation:\\n self._activation = activations.get(activation)\\n else:\\n self._activation = math_ops.tanh\\n\\n if num_proj:\\n self.state_size = [num_proj, num_units]\\n self._output_size = num_proj\\n\\n else:\\n self._state_size = [num_units, num_units]\\n self._output_size = num_units\",\n \"def __call__(self, inputs, state, scope=None):\\n with tf.variable_scope(scope or type(self).__name__): # \\\"GRUCell\\\"\\n with tf.variable_scope(\\\"Gates\\\"): # Reset gate and update gate.\\n # We start with bias of 1.0 to not reset and not udpate.\\n #pudb.set_trace()\\n # k1 x k2 x Ox x Oh where k1 x k2 is the convolutional kernel spatial\\n # size.\\n Wzconv = tf.nn.conv2d(inputs, self.W_z, [1,1,1,1], padding='SAME')\\n Uzconv = tf.nn.conv2d(state, self.U_z, [1,1,1,1], padding='SAME')\\n Wrconv = tf.nn.conv2d(inputs, self.W_r, [1,1,1,1], padding='SAME')\\n Urconv = tf.nn.conv2d(state, self.U_r, [1,1,1,1], padding='SAME')\\n # sig(W_r * x_t + U_r * h_t-1 )\\n u = tf.sigmoid(Wzconv + Uzconv)\\n r = tf.sigmoid(Wrconv + Urconv)\\n with tf.variable_scope(\\\"Candidate\\\"):\\n # tanh(W * x_t + U * (r_t dot h_t-1) not confident yet.\\n Wconv = tf.nn.conv2d(inputs, self.W, [1,1,1,1], padding='SAME')\\n Uconv = tf.nn.conv2d(r*state, self.U, [1,1,1,1], padding='SAME')\\n c = tf.tanh(tf.add(Wconv,Uconv))\\n new_h = u * state + (1 - u) * c\\n # output, state is (batch_size, H=7, W=7, num_units)\\n return new_h, new_h\",\n \"def rnn_cell_loop(self):\\n\\n\\t\\t# Set up initial state\\n\\t\\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\\t\\t\\t# Spike\\n\\t\\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\\t\\t\\t\\t\\t# State\\n\\t\\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\\n\\t\\tself.h = [self.h]\\n\\t\\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\\n\\n\\t\\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\t\\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\n\\t\\t# Apply the EI mask to the recurrent weights\\n\\t\\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\\n\\n\\t\\t# Set up latency buffer if being used\\n\\t\\tif par['use_latency']:\\n\\t\\t\\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\\n\\t\\t\\tself.state_buffer = deque(self.state_buffer)\\n\\t\\t\\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\\n\\t\\t\\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\\n\\n\\t\\t# Set up output record\\n\\t\\tself.output = []\\n\\t\\tself.syn_x = []\\n\\t\\tself.syn_u = []\\n\\n\\t\\ty = 0.\\n\\t\\tfor t in range(par['num_time_steps']):\\n\\t\\t\\tself.t = t \\t\\t# For latency calculations\\n\\n\\t\\t\\tif par['cell_type'] == 'rate':\\n\\t\\t\\t\\traise Exception('Rate cell not yet implemented.')\\n\\t\\t\\telif par['cell_type'] == 'adex':\\n\\t\\t\\t\\tif t < 10:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\t\\t\\t\\tself.syn_x.append(syn_x)\\n\\t\\t\\t\\tself.syn_u.append(syn_u)\\n\\n\\t\\t\\telif par['cell_type'] == 'lif':\\n\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\n\\t\\t# Stack records\\n\\t\\tself.output = tf.stack(self.output, axis=0)\\n\\t\\tself.h = tf.stack(self.h, axis=0)\\n\\t\\tself.h_out = tf.stack(self.h_out, axis=0)\\n\\t\\tself.syn_x = tf.stack(self.syn_x, axis=0)\\n\\t\\tself.syn_u = tf.stack(self.syn_u, axis=0)\",\n \"def create_model(self, model_input, vocab_size, num_frames, is_training=True, **unused_params):\\n gru_size = FLAGS.gru_cells\\n number_of_layers = FLAGS.gru_layers\\n backward = FLAGS.gru_backward\\n random_frames = FLAGS.gru_random_sequence\\n iterations = FLAGS.iterations\\n \\n if random_frames:\\n num_frames_2 = tf.cast(tf.expand_dims(num_frames, 1), tf.float32)\\n model_input = utils.SampleRandomFrames(model_input, num_frames_2,\\n iterations)\\n \\n if backward:\\n model_input = tf.reverse_sequence(model_input, num_frames, seq_axis=1) \\n \\n stacked_GRU = tf.contrib.rnn.MultiRNNCell(\\n [\\n tf.contrib.rnn.GRUCell(gru_size)\\n for _ in range(number_of_layers)\\n ], state_is_tuple=False)\\n\\n loss = 0.0\\n with tf.variable_scope(\\\"RNN\\\"):\\n outputs, state = tf.nn.dynamic_rnn(stacked_GRU, model_input,\\n sequence_length=num_frames,\\n dtype=tf.float32)\\n\\n aggregated_model = getattr(video_level_models,\\n FLAGS.video_level_classifier_model)\\n return aggregated_model().create_model(\\n model_input=state,\\n vocab_size=vocab_size,\\n is_training=is_training,\\n **unused_params)\",\n \"def model_create_gru(input_dim, output_dim, n_features, n_houses, x_train, y_train, x_test, y_test, early=None):\\r\\n model = Sequential()\\r\\n for _ in range(nn_hparams['num_layers']):\\r\\n model.add(GRU(nn_hparams['units'], activation=nn_hparams['activation'], input_shape=(input_dim,n_features), return_sequences=True))\\r\\n model.add(Dropout(nn_hparams['dropout']))\\r\\n model.add(Flatten())\\r\\n model.add(Dense(y_train.shape[1]*y_train.shape[2]))\\r\\n custom_optimizer = getattr(optimizers, nn_hparams['optimizer'])(lr=nn_hparams['learning_rate'], beta_1=nn_hparams['beta_1'], beta_2=nn_hparams['beta_2'])\\r\\n model.compile(optimizer=custom_optimizer, loss=nn_hparams['loss'])\\r\\n y_train = y_train.reshape((y_train.shape[0], y_train.shape[1]*y_train.shape[2]))\\r\\n y_test = y_test.reshape((y_test.shape[0], y_test.shape[1]*y_test.shape[2]))\\r\\n if early:\\r\\n model.fit(x_train, y_train, validation_data=(x_test,y_test), epochs=nn_hparams['epochs'], verbose=1, callbacks=[early])\\r\\n else:\\r\\n model.fit(x_train, y_train, validation_data=(x_test,y_test), epochs=nn_hparams['epochs'], verbose=1)\\r\\n model_loss = model.evaluate(x_train, y_train, verbose=0)\\r\\n \\r\\n return model, model_loss\",\n \"def single_cell(\\n cell_class,\\n cell_params,\\n dp_input_keep_prob=1.0,\\n dp_output_keep_prob=1.0,\\n recurrent_keep_prob=1.0,\\n input_weight_keep_prob=1.0,\\n recurrent_weight_keep_prob=1.0,\\n weight_variational=False,\\n dropout_seed=None,\\n zoneout_prob=0.,\\n training=True,\\n residual_connections=False,\\n awd_initializer=False,\\n variational_recurrent=False, # in case they want to use DropoutWrapper\\n dtype=None,\\n):\\n if awd_initializer:\\n val = 1.0/math.sqrt(cell_params['num_units'])\\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\\n if recurrent_keep_prob < 1.0:\\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\\n if input_weight_keep_prob < 1.0:\\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\\n if recurrent_weight_keep_prob < 1.0:\\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\\n if weight_variational:\\n cell_params['weight_variational'] = weight_variational # which is basically True\\n if dropout_seed:\\n cell_params['dropout_seed'] = dropout_seed\\n\\n\\n cell = cell_class(**cell_params)\\n if residual_connections:\\n cell = ResidualWrapper(cell)\\n if zoneout_prob > 0. and (\\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\\n ):\\n raise ValueError(\\n \\\"Currently applying both dropout and zoneout on the same cell.\\\"\\n \\\"This is currently not supported.\\\"\\n )\\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\\n cell = DropoutWrapper(\\n cell,\\n input_keep_prob=dp_input_keep_prob,\\n output_keep_prob=dp_output_keep_prob,\\n variational_recurrent=variational_recurrent,\\n dtype=dtype,\\n seed=dropout_seed\\n )\\n if zoneout_prob > 0.:\\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\\n return cell\",\n \"def trainGestureRNN(numLayers, numNodesPerLayer, useGRU, batchSize,\\n numEpochs, learningRate, l1Reg, l2Reg, dropoutI, dropoutH,\\n sequences, classes, trainRange, valRange, testRange,\\n numClasses, numObservations, numSequences, numFeatures,\\n modelFile, callbacks = None, \\n outDirectory = '', trainMode = 'continue'):\\n trainModes = ['continue', 'overwrite', 'skip']\\n \\n if trainMode.lower() not in trainModes:\\n raise ValueError(\\\"Parameter 'trainMode' must be one of 'continue', 'overwrite', or 'skip'\\\")\\n \\n if dropoutI < 0 or dropoutH < 0 or l2Reg < 0 or l1Reg < 0:\\n raise ValueError('Regularization parameters must be non-negative.')\\n \\n if outDirectory is not None and outDirectory != '':\\n outDirectory = outDirectory + '\\\\\\\\'\\n else:\\n outDirectory = ''\\n # initialize, compile, and train model\\n #finish preparing data\\n #class labels must be made into binary arrays\\n binaryClasses = np.zeros((numObservations, numSequences, numClasses))\\n # tell cost function which timesteps to ignore\\n sampleWeights = np.ones((numObservations, numSequences))\\n #eh...just use for loops\\n for i in range(numObservations):\\n for j in range(numSequences):\\n if classes[i,j] >= 0:\\n binaryClasses[i,j, classes[i,j]] = 1\\n else:\\n sampleWeights[i,j] = 0\\n sequences = sequences.transpose((1,0,2))\\n binaryClasses = binaryClasses.transpose((1,0,2))\\n sampleWeights = sampleWeights.T\\n \\n trainData = [sequences[trainRange,:,:], binaryClasses[trainRange,:,:], sampleWeights[trainRange, :]]\\n valData = [sequences[valRange,:,:], binaryClasses[valRange,:,:], sampleWeights[valRange, :]]\\n testData = [sequences[testRange, :, :], binaryClasses[testRange, :, :], sampleWeights[testRange, :]]\\n \\n modelFile = outDirectory + 'Keras'+modelFile\\n weightsFile = modelFile+'_Weights'\\n completedEpochs = 0\\n if (trainMode == 'overwrite') or (not os.path.isfile(modelFile+'.json') or not os.path.isfile(weightsFile+'.h5')):\\n model = Sequential()\\n #add masking layer to indicate dummy timesteps\\n model.add(Masking(0, input_shape=(numObservations, numFeatures)))\\n if dropoutI:\\n model.add(Dropout(dropoutI))\\n for i in range(numLayers):\\n if useGRU:\\n model.add(GRU(output_dim=numNodesPerLayer, return_sequences=True,\\n W_regularizer=l2(l2Reg)))\\n else:\\n model.add(LSTM(output_dim=numNodesPerLayer, return_sequences=True,\\n W_regularizer=l2(l2Reg)))\\n if dropoutH:\\n model.add(Dropout(dropoutH))\\n model.add(TimeDistributed(Dense(output_dim=numClasses, activation='softmax', \\n W_regularizer = l2(l2Reg))))\\n else:\\n model = model_from_json(open(modelFile+'.json', 'rb').read())\\n model.load_weights(weightsFile+'.h5')\\n \\n #compile model and training objective function\\n sgd = SGD(lr=learningRate)\\n rms = RMSprop(lr=learningRate)\\n adagrad = Adagrad(lr=learningRate)\\n model.compile(loss='categorical_crossentropy', optimizer=rms,\\n sample_weight_mode='temporal', metrics=['accuracy'])\\n checkp = [ModelCheckpoint(weightsFile + '.h5', save_best_only = True)]\\n if callbacks is None:\\n callbacks = checkp\\n else:\\n callbacks += checkp\\n try:\\n if trainMode != 'skip':\\n completedEpochs = model.fit(x=trainData[0], y=trainData[1], sample_weight=trainData[2],\\n validation_data = valData, batch_size = batchSize, \\n nb_epoch = numEpochs, callbacks = callbacks,\\n verbose = 2)\\n completedEpochs = len(completedEpochs.history['loss'])\\n except KeyboardInterrupt:\\n if(not queryUser('Training interrupted. Compute test statistics?')):\\n return 0, float('nan'), float('nan'), float('nan') \\n #retrieve the best weights based upon validation set loss\\n if os.path.isfile(weightsFile+'.h5'):\\n model.load_weights(weightsFile+'.h5')\\n scores = model.test_on_batch(x=testData[0], y=testData[1], sample_weight=testData[2])\\n predictedClasses = model.predict_classes(x=testData[0])\\n scores[1] = accuracy(classes[:, testRange].T, predictedClasses)\\n scores.append(balancedAccuracy(classes[:, testRange].T, predictedClasses))\\n scores.append(weightedAccuracy(classes[:, testRange].T, predictedClasses, forgetFactor=0))\\n print(\\\"Test loss of %.5f\\\\nFrame-wise accuracy of %.5f\\\\nSequence-wise accuracy of %.5f\\\\nFinal frame accuracy of %0.5f\\\" % (scores[0], scores[1], scores[2], scores[3]))\\n if trainMode != 'skip':\\n modelString = model.to_json()\\n open(modelFile + '.json', 'wb').write(modelString)\\n model.save_weights(weightsFile + '.h5', overwrite=True)\\n print('Model and weights saved to %s and %s.' % (modelFile+'.json', weightsFile+'.h5'))\\n return completedEpochs, scores[0], scores[1], scores[2], scores[3]\",\n \"def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\\n cells = []\\n for i in range(layer_num):\\n if rnn_type.endswith('lstm'):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n elif rnn_type.endswith('gru'):\\n cell = tc.rnn.GRUCell(num_units=hidden_size)\\n elif rnn_type.endswith('rnn'):\\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\\n else:\\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\\n return cells\",\n \"def get_rnn(X, rnn_size, seq_len, batch_size, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0, is_training=False,\\n cell_name=\\\"BasicLSTM\\\", bidirectional=False):\\n with tf.device(\\\"/cpu:0\\\"):\\n # Convert input tensor to python list (along the sequence length dimention)\\n word_embeddings = tf.split(1, seq_len, X)\\n word_embeddings = [tf.squeeze(embed_, [1]) for embed_ in word_embeddings]\\n\\n # if is_training and keep_prob < 1:\\n # word_embeddings = [tf.nn.dropout(input_, keep_prob) for input_ in word_embeddings]\\n\\n def get_cell():\\n if cell_name == \\\"GRU\\\": # GRU\\n cell = rnn_cell.GRUCell(rnn_size)\\n elif cell_name == \\\"LSTM\\\": # LSTM\\n cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\\n else:\\n cell = rnn_cell.BasicLSTMCell(rnn_size)\\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\\n cell = rnn_cell.DropoutWrapper(cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\\n cell = rnn_cell.MultiRNNCell([cell] * num_layers)\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n return cell, initial_state\\n\\n if bidirectional:\\n with tf.variable_scope(\\\"forward\\\"):\\n cell_fw, initial_state_fw = get_cell()\\n with tf.variable_scope(\\\"backward\\\"):\\n cell_bw, initial_state_bw = get_cell()\\n return rnn.bidirectional_rnn(cell_fw, cell_bw, word_embeddings,\\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw)\\n else:\\n cell, initial_state = get_cell()\\n return rnn.rnn(cell, word_embeddings, initial_state=initial_state)\",\n \"def __call__(self, inputs, state, scope=None):\\n with tf.variable_scope(scope or type(self).__name__): # \\\"GRUCell\\\"\\n with tf.variable_scope(\\\"Gates\\\"): # Reset gate and update gate.\\n # We start with bias of 1.0 to not reset and not update.\\n r, u = tf.split(1, 2, linear([inputs, state],\\n 2 * self._num_units, True, 1.0))\\n r, u = tf.nn.sigmoid(r), tf.nn.sigmoid(u)\\n with tf.variable_scope(\\\"Candidate\\\"):\\n c = self._activation(linear([inputs, r * state],\\n self._num_units, True))\\n new_h = u * state + (1 - u) * c\\n return tf.concat(1, [new_h, r, u]), new_h\",\n \"def generator(self, x, reuse=None, name=\\\"\\\"):\\n with tf.variable_scope('generator-%s' % name, reuse=reuse):\\n\\n def d(x, f, name=''):\\n x = t.conv2d(x, f=f, k=3, s=2, name='gen-d-conv2d-%s' % name)\\n x = t.instance_norm(x, name='gen-d-ins_norm-%s' % name)\\n x = tf.nn.relu(x)\\n return x\\n\\n def R(x, f, name=''):\\n x = t.conv2d(x, f=f, k=3, s=1, name='gen-R-conv2d-%s-0' % name)\\n x = t.conv2d(x, f=f, k=3, s=1, name='gen-R-conv2d-%s-1' % name)\\n x = t.instance_norm(x, name='gen-R-ins_norm-%s' % name)\\n x = tf.nn.relu(x)\\n return x\\n\\n def u(x, f, name=''):\\n x = t.deconv2d(x, f=f, k=3, s=2, name='gen-u-deconv2d-%s' % name)\\n x = t.instance_norm(x, name='gen-u-ins_norm-%s' % name)\\n x = tf.nn.relu(x)\\n return x\\n\\n x = t.conv2d(x, f=self.gf_dim, k=7, s=1, name='gen-conv2d-0')\\n\\n x = d(x, self.gf_dim * 2, name='1')\\n x = d(x, self.gf_dim * 4, name='2')\\n\\n for i in range(1, 7):\\n x = R(x, self.gf_dim * 4, name=str(i))\\n\\n x = u(x, self.gf_dim * 4, name='1')\\n x = u(x, self.gf_dim * 2, name='2')\\n\\n logits = t.conv2d(x, f=3, k=7, s=1, name='gen-conv2d-1')\\n prob = tf.nn.tanh(logits)\\n\\n return prob\",\n \"def custom_rnn(cell, inputs, initial_state=None, dtype=None,\\r\\n sequence_length=None, scope=None):\\r\\n\\r\\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\\r\\n raise TypeError(\\\"cell must be an instance of RNNCell\\\")\\r\\n if not nest.is_sequence(inputs):\\r\\n raise TypeError(\\\"inputs must be a sequence\\\")\\r\\n if not inputs:\\r\\n raise ValueError(\\\"inputs must not be empty\\\")\\r\\n\\r\\n outputs = []\\r\\n states = []\\r\\n # Create a new scope in which the caching device is either\\r\\n # determined by the parent scope, or is set to place the cached\\r\\n # Variable using the same placement as for the rest of the RNN.\\r\\n with vs.variable_scope(scope or \\\"RNN\\\") as varscope:\\r\\n if varscope.caching_device is None:\\r\\n varscope.set_caching_device(lambda op: op.device)\\r\\n\\r\\n # Obtain the first sequence of the input\\r\\n first_input = inputs\\r\\n while nest.is_sequence(first_input):\\r\\n first_input = first_input[0]\\r\\n\\r\\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\\r\\n # TODO(lukaszkaiser): remove EmbeddingWrapper\\r\\n if first_input.get_shape().ndims != 1:\\r\\n\\r\\n input_shape = first_input.get_shape().with_rank_at_least(2)\\r\\n fixed_batch_size = input_shape[0]\\r\\n\\r\\n flat_inputs = nest.flatten(inputs)\\r\\n for flat_input in flat_inputs:\\r\\n input_shape = flat_input.get_shape().with_rank_at_least(2)\\r\\n batch_size, input_size = input_shape[0], input_shape[1:]\\r\\n fixed_batch_size.merge_with(batch_size)\\r\\n for i, size in enumerate(input_size):\\r\\n if size.value is None:\\r\\n raise ValueError(\\r\\n \\\"Input size (dimension %d of inputs) must be accessible via \\\"\\r\\n \\\"shape inference, but saw value None.\\\" % i)\\r\\n else:\\r\\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\\r\\n\\r\\n if fixed_batch_size.value:\\r\\n batch_size = fixed_batch_size.value\\r\\n else:\\r\\n batch_size = array_ops.shape(first_input)[0]\\r\\n if initial_state is not None:\\r\\n state = initial_state\\r\\n else:\\r\\n if not dtype:\\r\\n raise ValueError(\\\"If no initial_state is provided, \\\"\\r\\n \\\"dtype must be specified\\\")\\r\\n state = cell.zero_state(batch_size, dtype)\\r\\n\\r\\n if sequence_length is not None: # Prepare variables\\r\\n sequence_length = ops.convert_to_tensor(\\r\\n sequence_length, name=\\\"sequence_length\\\")\\r\\n if sequence_length.get_shape().ndims not in (None, 1):\\r\\n raise ValueError(\\r\\n \\\"sequence_length must be a vector of length batch_size\\\")\\r\\n def _create_zero_output(output_size):\\r\\n # convert int to TensorShape if necessary\\r\\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\\r\\n output = array_ops.zeros(\\r\\n array_ops.pack(size), _infer_state_dtype(dtype, state))\\r\\n shape = _state_size_with_prefix(\\r\\n output_size, prefix=[fixed_batch_size.value])\\r\\n output.set_shape(tensor_shape.TensorShape(shape))\\r\\n return output\\r\\n\\r\\n output_size = cell.output_size\\r\\n flat_output_size = nest.flatten(output_size)\\r\\n flat_zero_output = tuple(\\r\\n _create_zero_output(size) for size in flat_output_size)\\r\\n zero_output = nest.pack_sequence_as(structure=output_size,\\r\\n flat_sequence=flat_zero_output)\\r\\n\\r\\n sequence_length = math_ops.to_int32(sequence_length)\\r\\n min_sequence_length = math_ops.reduce_min(sequence_length)\\r\\n max_sequence_length = math_ops.reduce_max(sequence_length)\\r\\n\\r\\n for time, input_ in enumerate(inputs):\\r\\n if time > 0: varscope.reuse_variables()\\r\\n # pylint: disable=cell-var-from-loop\\r\\n call_cell = lambda: cell(input_, state)\\r\\n # pylint: enable=cell-var-from-loop\\r\\n if sequence_length is not None:\\r\\n (output, state) = _rnn_step(\\r\\n time=time,\\r\\n sequence_length=sequence_length,\\r\\n min_sequence_length=min_sequence_length,\\r\\n max_sequence_length=max_sequence_length,\\r\\n zero_output=zero_output,\\r\\n state=state,\\r\\n call_cell=call_cell,\\r\\n state_size=cell.state_size)\\r\\n else:\\r\\n (output, state) = call_cell()\\r\\n\\r\\n outputs.append(output)\\r\\n states.append(state)\\r\\n\\r\\n return (outputs, state, states)\",\n \"def _build_pnasnet_base(\\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\\n start_cell_num):\\n\\n # Find where to place the reduction cells or stride normal cells\\n reduction_indices = nasnet_utils.calc_reduction_layers(\\n hparams.num_cells, hparams.num_reduction_layers)\\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\\n\\n # Note: The None is prepended to match the behavior of _imagenet_stem()\\n cell_outputs = [None, hidden_previous, hidden]\\n net = hidden\\n\\n # Run the cells\\n for cell_num in range(start_cell_num, hparams.num_cells):\\n is_reduction = cell_num in reduction_indices\\n stride = 2 if is_reduction else 1\\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\\n prev_layer = cell_outputs[-2]\\n net = normal_cell(\\n net,\\n scope='cell_{}'.format(cell_num),\\n filter_scaling=filter_scaling,\\n stride=stride,\\n prev_layer=prev_layer,\\n cell_num=true_cell_num)\\n true_cell_num += 1\\n cell_outputs.append(net)\\n\\n # Final nonlinearity.\\n # Note that we have dropped the final pooling, dropout and softmax layers\\n # from the default pnasnet version.\\n with tf.variable_scope('final_layer'):\\n net = tf.nn.relu(net)\\n return net\",\n \"def __init__(self, context, problem, update_rate=1, debug=False):\\n tf.keras.layers.AbstractRNNCell.__init__(self)\\n self.context = context\\n self.problem = problem\\n\\n if hasattr(self.context, 'scale'):\\n self.scale = self.context.scale\\n else:\\n self.scale = 1\\n\\n self.debug = debug\\n\\n # shape related information\\n self.batch_size = self.context.batch_size\\n self.dim_x = self.context.dim_x\\n self.dim_z = self.context.dim_z\\n self.dim_u = self.context.dim_u\\n\\n # rate at which observations are taken into account\\n self.update_rate = tf.ones([], dtype=tf.float32) * update_rate\\n\\n self.filter_layers = []\",\n \"def gru_bid_encoder(inputs, sequence_length, hparams, train, name):\\n\\n with tf.variable_scope(name):\\n cell_fw = tf.nn.rnn_cell.MultiRNNCell(\\n [_dropout_gru_cell(hparams, train)\\n for _ in range(hparams.num_hidden_layers)])\\n\\n cell_bw = tf.nn.rnn_cell.MultiRNNCell(\\n [_dropout_gru_cell(hparams, train)\\n for _ in range(hparams.num_hidden_layers)])\\n\\n ((encoder_fw_outputs, encoder_bw_outputs),\\n (encoder_fw_state, encoder_bw_state)) = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw,\\n cell_bw,\\n inputs,\\n sequence_length,\\n dtype=tf.float32,\\n time_major=False)\\n\\n encoder_outputs = tf.concat((encoder_fw_outputs, encoder_bw_outputs), 2)\\n encoder_states = []\\n\\n for i in range(hparams.num_hidden_layers):\\n encoder_state = tf.concat(\\n values=(encoder_fw_state[i], encoder_bw_state[i]),\\n axis=1,\\n name=\\\"bidirectional_concat\\\")\\n\\n encoder_states.append(encoder_state)\\n\\n encoder_states = tuple(encoder_states)\\n return encoder_outputs, encoder_states\",\n \"def gru_cell(prev_hidden: tf.Tensor, input: tf.Tensor) -> tf.Tensor:\\n batch_size, hidden_size = assert_shape(prev_hidden, (None, None))\\n _, input_size = assert_shape(input, (batch_size, None))\\n dtype = prev_hidden.dtype\\n\\n weight_i = tf.get_variable(\\n \\\"weight_i\\\",\\n (3, input_size, hidden_size),\\n dtype=dtype,\\n initializer=tf.glorot_normal_initializer(),\\n )\\n bias_i = tf.get_variable(\\\"bias_i\\\", (3, hidden_size),\\n dtype=dtype,\\n initializer=tf.zeros_initializer())\\n weight_h = tf.get_variable(\\n \\\"weight_h\\\",\\n (3, hidden_size, hidden_size),\\n dtype=dtype,\\n initializer=tf.glorot_normal_initializer(),\\n )\\n bias_h = tf.get_variable(\\\"bias_h\\\", (3, hidden_size),\\n dtype=dtype,\\n initializer=tf.zeros_initializer())\\n\\n reset_i, update_i, candidate_i = tf.unstack(input @ weight_i +\\n tf.expand_dims(bias_i, 1))\\n reset_h, update_h, candidate_h = tf.unstack(prev_hidden @ weight_h +\\n tf.expand_dims(bias_h, 1))\\n\\n reset = tf.sigmoid(reset_i + reset_h)\\n update = tf.sigmoid(update_i + update_h)\\n candidate = tf.tanh(candidate_i + reset * candidate_h)\\n return (1 - update) * candidate + update * prev_hidden\",\n \"def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\\n # todo 1、获取嵌入层的输出\\n embed = get_embed(input_data, vocab_size, embed_dim)\\n # todo-2、获取 隐藏层的输出\\n rnn_outputs, final_state, final_state1 = build_rnn(\\n cell, embed, initial_state=initial_state)\\n # 3、构建全连接，获取logits\\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\\n # [N, n-steps, num_classes]\\n return logits, final_state, final_state1\",\n \"def __init__(self, init_grid=None):\\n\\n self.height = len(init_grid)\\n self.width = len(init_grid[0])\\n\\n self.grid = [[Cell(self, c) for c in row]\\n for row in init_grid]\\n\\n self.g = nx.Graph()\\n self.tangle()\",\n \"def SRGAN_g(t_image, is_train=False, reuse=False):\\n w_init = tf.random_normal_initializer(stddev=0.02)\\n b_init = None # tf.constant_initializer(value=0.0)\\n g_init = tf.random_normal_initializer(1., 0.02)\\n\\n with tf.variable_scope(\\\"SRGAN_g\\\", reuse=reuse) as vs:\\n # tl.layers.set_name_reuse(reuse) # remove for TL 1.8.0+\\n n = InputLayer(t_image, name='in')\\n n = ReshapeLayer(n, [-1, 512, 512, 1], name = 'reshape')\\n n = Conv2d(n, 64, (3, 3), (1, 1), act=tf.nn.relu, padding='SAME', W_init=w_init, name='n64s1/c')\\n temp = n\\n\\n # B residual blocks\\n for i in range(16):\\n nn = Conv2d(n, 64, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, b_init=b_init, name='n64s1/c1/%s' % i)\\n nn = BatchNormLayer(nn, act=tf.nn.relu, is_train=is_train, gamma_init=g_init, name='n64s1/b1/%s' % i)\\n nn = Conv2d(nn, 64, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, b_init=b_init, name='n64s1/c2/%s' % i)\\n nn = BatchNormLayer(nn, is_train=is_train, gamma_init=g_init, name='n64s1/b2/%s' % i)\\n nn = ElementwiseLayer([n, nn], tf.add, name='b_residual_add/%s' % i)\\n n = nn\\n\\n\\n n = Conv2d(n, 64, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, b_init=b_init, name='n64s1/c/m')\\n\\n n = BatchNormLayer(n, is_train=is_train, gamma_init=g_init, name='n64s1/b/m')\\n n = ElementwiseLayer([n, temp], tf.add, name='add3')\\n # B residual blacks end\\n\\n n = Conv2d(n, 3, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, name='n256s1/1')\\n return n\",\n \"def __init__(self, model, num_classes=-1, hidden_size=128, type='gru', **kwargs):\\n super(CNNRNN, self).__init__(**kwargs)\\n self.feats = model is None\\n with self.name_scope():\\n if model is not None:\\n self.td = TimeDistributed(model.backbone)\\n if type == 'lstm':\\n self.rnn = mx.gluon.rnn.LSTM(hidden_size, layout=\\\"NTC\\\", bidirectional=True)\\n else:\\n self.rnn = mx.gluon.rnn.GRU(hidden_size, layout=\\\"NTC\\\", bidirectional=True)\\n self.classes = None\\n if num_classes == 0:\\n self.classes = model.classes\\n elif num_classes > 0:\\n self.classes = nn.Dense(num_classes, flatten=True)\",\n \"def setup_rnn_model(default_ctx,\\n num_lstm_layer, \\n num_hidden,\\n batch_size,\\n initializer,\\n group2ctx=None, concat_decode=True,\\n use_loss=False, buckets=None):\\n max_len = n_steps\\n max_rnn_exec = None\\n rnn_sym = lstm_unroll(num_lstm_layer=num_lstm_layer,\\n num_hidden=num_hidden)\\n arg_names = rnn_sym.list_arguments()\\n internals = rnn_sym.get_internals()\\n\\n input_shapes = {}\\n for name in arg_names:\\n if name.endswith(\\\"init_c\\\") or name.endswith(\\\"init_h\\\"):\\n input_shapes[name] = (batch_size, num_hidden)\\n elif name.endswith(\\\"data\\\"):\\n input_shapes[name] = (batch_size,MAX_LEN)\\n elif name == \\\"labels\\\":\\n input_shapes[name] = (batch_size,MAX_LEN)\\n elif name.endswith(\\\"label\\\"):\\n input_shapes[name] = (batch_size, )\\n else:\\n pass\\n\\n arg_shape, out_shape, aux_shape = rnn_sym.infer_shape(**input_shapes)\\n # bind arrays\\n arg_arrays = []\\n args_grad = {}\\n for shape, name in zip(arg_shape, arg_names):\\n group = internals[name].attr(\\\"ctx_group\\\")\\n ctx = group2ctx[group] if group is not None else default_ctx\\n arg_arrays.append(mx.nd.zeros(shape, ctx))\\n if is_param_name(name):\\n args_grad[name] = mx.nd.zeros(shape, ctx)\\n if not name.startswith(\\\"t\\\"):\\n print(\\\"%s group=%s, ctx=%s\\\" % (name, group, str(ctx)))\\n \\n #bind with shared executor\\n rnn_exec = None\\n rnn_exec = rnn_sym.bind(default_ctx, args=arg_arrays,\\n args_grad=args_grad,\\n grad_req=\\\"add\\\", group2ctx=group2ctx)\\n max_rnn_exec = rnn_exec\\n \\n\\n param_blocks = []\\n arg_dict = dict(zip(arg_names, rnn_exec.arg_arrays))\\n for i, name in enumerate(arg_names):\\n if is_param_name(name):\\n initializer(name, arg_dict[name])\\n param_blocks.append((i, arg_dict[name], args_grad[name], name))\\n else:\\n assert name not in args_grad\\n\\n out_dict = dict(zip(rnn_sym.list_outputs(), rnn_exec.outputs))\\n\\n init_states = [LSTMState(c=arg_dict[\\\"l%d_init_c\\\" % i],\\n h=arg_dict[\\\"l%d_init_h\\\" % i]) for i in range(num_lstm_layer)]\\n\\n seq_data = rnn_exec.arg_dict[\\\"data\\\"]\\n # we don't need to store the last state \\n last_states = None\\n\\n seq_outputs = [out_dict[\\\"sm_output\\\"]]\\n seq_labels = [rnn_exec.arg_dict[\\\"labels\\\"]]\\n\\n model = LSTMModel(rnn_exec=rnn_exec, symbol=rnn_sym,\\n init_states=init_states, last_states=last_states,\\n seq_data=seq_data, seq_labels=seq_labels, seq_outputs=seq_outputs,\\n param_blocks=param_blocks)\\n return model\",\n \"def mkrngs(self):\\n self.bkg[[0, -1]] = False\\n bkgr = self.Time[self.bkg ^ np.roll(self.bkg, -1)]\\n self.bkgrng = np.reshape(bkgr, [bkgr.size // 2, 2])\\n\\n self.sig[[0, -1]] = False\\n sigr = self.Time[self.sig ^ np.roll(self.sig, 1)]\\n self.sigrng = np.reshape(sigr, [sigr.size // 2, 2])\\n\\n self.trn[[0, -1]] = False\\n trnr = self.Time[self.trn ^ np.roll(self.trn, 1)]\\n self.trnrng = np.reshape(trnr, [trnr.size // 2, 2])\",\n \"def build_lstm_cell(num_units, dropout):\\n cell = tf.nn.rnn_cell.LSTMCell(num_units)\\n if dropout:\\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\\n output_keep_prob=1-dropout)\\n return result\",\n \"def add_model(self, inputs):\\n size = self.config.hidden_size\\n forget_bias = self.config.forget_bias\\n input_cell = self.config.input_cell\\n\\n if input_cell == 'BasicLSTMCell':\\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\\n print 'Using Basic LSTM Cell \\\\n'\\n\\n elif input_cell == 'LSTMCell':\\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\\n print 'Using LSTM Cell \\\\n'\\n\\n elif input_cell == 'GRUCell':\\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\\n print 'Using GRU Cell \\\\n'\\n\\n else:\\n print \\\"Please Specify a Correct Cell Type\\\"\\n\\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\\n input_keep_prob=self.config.dropout)\\n\\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\\n \\n print 'Number of Hidden Layers ', self.config.num_layers\\n \\n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\\n rnn_outputs = []\\n state = self.initial_state\\n\\n with tf.variable_scope('RNNLM') as scope:\\n for time_step in range(self.config.num_steps):\\n if time_step > 0: scope.reuse_variables()\\n (cell_output, state) = cell(inputs[:, time_step, :], state)\\n rnn_outputs.append(cell_output)\\n self.final_state = state\\n\\n return rnn_outputs\",\n \"def mgcResnet(block_type, block_repeat, **kwargs):\\n \\n \\n def_vals = {\\\"input_img_rows\\\" : 72,\\n \\\"input_img_cols\\\" : 72,\\n \\\"channels\\\" : 1,\\n \\\"nb_classes\\\" : 13\\n } # default parameters value\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n input_img_rows = kwargs['input_img_rows']\\n input_img_cols = kwargs['input_img_cols']\\n channels = kwargs['channels']\\n nb_classes = kwargs['nb_classes']\\n \\n # block_type residual block option\\n if block_type == 'basic':\\n block_fn = resnet.basic_block\\n elif block_type == 'bottleneck':\\n block_fn = resnet.bottleneck\\n\\n model = resnet.ResnetBuilder.build((channels, input_img_rows, input_img_cols), nb_classes, block_fn, block_repeat)\\n return model\",\n \"def __init__(self, input_dim, hidden_dim, bias=True, node_n=48, dtype=float):\\n super(GCNGRU_Block, self).__init__()\\n self.hidden_dim = hidden_dim\\n self.node_n = node_n\\n\\n self.gc1 = GraphConvolution(input_dim + hidden_dim, 2*self.hidden_dim, node_n=node_n, bias=bias)\\n self.gc2 = GraphConvolution(input_dim + hidden_dim, self.hidden_dim, node_n=node_n, bias=bias)\",\n \"def resnet10(shortcut_type, num_classes, in_channels):\\n model = ResNet(BasicBlock, [1, 1, 1, 1], shortcut_type, num_classes, in_channels)\\n return model\",\n \"def __init__(self, num_gpus):\\n\\n super(Generator, self).__init__()\\n n_in = Z\\n n_out = IMG_CHANNELS\\n\\n feature_map = IMG_SIZE\\n kernel_size = 4\\n stride = 2\\n padding = 1\\n bias = False\\n\\n self.num_gpus = num_gpus\\n\\n self.network = nn.Sequential(\\n # input is latent variable space Z\\n nn.ConvTranspose2d(n_in, feature_map * 8, kernel_size, 1, 0, bias=bias),\\n nn.BatchNorm2d(feature_map * 8),\\n nn.ReLU(inplace=True),\\n\\n # nodes = feature_map * 4\\n nn.ConvTranspose2d(feature_map * 8, feature_map * 4, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 4),\\n nn.ReLU(inplace=True),\\n\\n # nodes = feature_map * 2\\n nn.ConvTranspose2d(feature_map * 4, feature_map * 2, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 2),\\n nn.ReLU(inplace=True),\\n\\n # nodes = feature_map\\n nn.ConvTranspose2d(feature_map * 2, feature_map, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map),\\n nn.ReLU(inplace=True),\\n\\n # nodes = output image size\\n nn.ConvTranspose2d(feature_map, n_out, kernel_size, stride, padding, bias=bias),\\n nn.Tanh()\\n )\",\n \"def __call__(self, inputs, state, scope=None, debug=False):\\n # B is batch size.\\n\\n # 1) Use read_ind to find memory location to read from\\n # as input.\\n\\n # inputs.read_ind: (B, 1)\\n # memory: (B, mem_size, embed_size)\\n read_ind = tf.to_int32(inputs.read_ind)\\n batch_size = tf.shape(read_ind)[0]\\n if debug:\\n print('batch size is', batch_size)\\n print('read ind is', read_ind)\\n mem_ind = tf.range(batch_size)\\n\\n # read_mem_ind: (B, 1)\\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n # read_ind: (B, 2)\\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\\n if debug:\\n print('processed read ind is', read_ind)\\n\\n # inner_inputs: (B, embed_size)\\n inner_inputs = tf.gather_nd(state.memory, read_ind)\\n if debug:\\n print('inner_inputs is', inner_inputs)\\n\\n inner_state = state.inner_state\\n\\n # 2) Run the inner RNNCell.\\n \\n # inner_outputs: (B, embed_size)\\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\\n\\n if debug:\\n print('inner_outputs is', inner_outputs)\\n\\n # 3) Compute logits for valid indices (using logit_masks\\n # to mask out padded valid indices (-1)).\\n \\n # valid_indices: (B, max_n_valid_indices)\\n valid_indices = tf.to_int32(inputs.valid_indices)\\n if debug:\\n print('valid_indices is', valid_indices)\\n \\n # Logit mask: (B, max_n_valid_indices)\\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\\n logit_masks = tf.cast(logit_masks, tf.float32)\\n\\n if debug:\\n print('logit_masks is', logit_masks)\\n\\n # Normalize indices to be at least 0.\\n valid_indices = tf.maximum(valid_indices, 0)\\n\\n # valid_indices: (B, max_n_valid_indices, 1)\\n valid_indices = tf.expand_dims(valid_indices, -1)\\n if debug:\\n print('valid_indices is', valid_indices)\\n print('mem_ind is', mem_ind)\\n\\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # valid_mem_ind: (B, 1, 1)\\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\\n if debug:\\n print('valid_mem_ind is', valid_mem_ind)\\n\\n # valid_mem_ind: (B, max_n_valid_indices, 1)\\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\\n\\n # valid_indices: (B, max_n_valid_indices, 2)\\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\\n # index into the right memory location.\\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\\n\\n if debug:\\n print('valid_indices is', valid_indices)\\n\\n # select all the valid slots. \\n # valid_values: (B, max_n_valid_indices, embed_size)\\n valid_values = tf.gather_nd(state.memory, valid_indices)\\n if debug:\\n print('valid_values is', valid_values)\\n \\n # expanded_inner_outputs: (B, 1, embed_size)\\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\\n if debug:\\n print('expanded_inner_outputs is', expanded_inner_outputs)\\n\\n # valid_values: (B, embed_size, max_n_valid_indices)\\n valid_values = tf.transpose(valid_values, [0, 2, 1])\\n if debug:\\n print('valid_values is', valid_values)\\n\\n # logits: (B, 1, max_n_valid_indices)\\n logits = tf.matmul(expanded_inner_outputs, valid_values)\\n \\n if debug:\\n print('logits is', logits)\\n\\n # logits: (B, max_n_valid_indices)\\n logits = tf.squeeze(logits, axis=[1])\\n if debug:\\n print('logits is', logits)\\n\\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\\n\\n outputs = masked_logits\\n # 4) Write the output of the inner RNN to a memory\\n # location (write_ind), using write_masks to mask out\\n # padded write_ind (-1).\\n \\n # write_ind: (B, 1)\\n write_ind = tf.cast(inputs.write_ind, tf.int32)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n # write mask: (B, 1)\\n write_masks = tf.greater_equal(inputs.write_ind, 0)\\n if debug:\\n print('write_masks greater_equal', write_masks)\\n\\n write_masks = tf.cast(write_masks, tf.float32)\\n\\n # write mask: (B, 1, 1)\\n write_masks = tf.expand_dims(write_masks, [-1])\\n\\n if debug:\\n print('write_masks is', write_masks)\\n\\n # Normalize write_ind to be above 0.\\n # write_ind: (B, 1)\\n write_ind = tf.maximum(write_ind, 0)\\n\\n # write_mem_ind: (B, 1)\\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # write_ind: (B, 2)\\n # Second dimension is [b_i, write_index]\\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n if debug:\\n print('masked_logits is', masked_logits)\\n print('memory is', state.memory)\\n\\n # write_mat: (B, mem_size, embed_size)\\n write_mat = tf.scatter_nd(\\n write_ind, inner_outputs, shape=tf.shape(state.memory))\\n\\n if debug:\\n print('@' * 50)\\n print('write_mat is', write_mat)\\n print('write_mask is', write_masks)\\n print('@' * 50)\\n\\n masked_write_mat = write_mat * write_masks\\n new_memory = state.memory + masked_write_mat\\n \\n state = MemoryStateTuple(new_memory, new_inner_state)\\n if debug:\\n print('state is', state)\\n \\n return (outputs, state)\",\n \"def _grads(val, r):\\n return grad(val, r, grad_outputs=torch.ones_like(val))[0]\",\n \"def BuildCoreGraph(self):\\n # Input ids, with dynamic shape depending on input.\\n # Should be shape [batch_size, max_time] and contain integer word indices.\\n self.input_w_ = tf.placeholder(tf.int32, [None, None], name=\\\"w\\\")\\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_], name=\\\"w\\\")\\n\\n # Initial hidden state. You'll need to overwrite this with cell.zero_state\\n # once you construct your RNN cell.\\n self.initial_h_ = None\\n #tf.placeholder(tf.int32, [self.H,], name=\\\"h_i\\\")\\n #tf.Variable(tf.random_normal([H,]), name=\\\"h_i\\\")\\n\\n # Final hidden state. You'll need to overwrite this with the output from\\n # tf.nn.dynamic_rnn so that you can pass it in to the next batch (if\\n # applicable).\\n self.final_h_ = None\\n #tf.placeholder(tf.int32, [self.H,], name=\\\"h_f\\\")\\n #tf.Variable(tf.random_normal([H,]), name=\\\"h_f\\\")\\n\\n # Output logits, which can be used by loss functions or for prediction.\\n # Overwrite this with an actual Tensor of shape\\n # [batch_size, max_time, V].\\n self.logits_ = None\\n #tf.placeholder(tf.int32, [self.batch_size_, self.max_time_, self.V], name=\\\"logits\\\")\\n #tf.Variable(tf.random_normal([self.batch_size_, self.max_time_, self.V]), name=\\\"logits\\\")\\n\\n # Should be the same shape as inputs_w_\\n self.target_y_ = tf.placeholder(tf.int32, [None, None], name=\\\"y\\\")\\n #tf.placeholder(tf.int32, [None, None], name=\\\"y\\\")\\n\\n # Replace this with an actual loss function\\n self.loss_ = None\\n #tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.labels_, logits=self.logits_),0)#don't forget last parameter\\n\\n # Get dynamic shape info from inputs\\n with tf.name_scope(\\\"batch_size\\\"):\\n self.batch_size_ = tf.shape(self.input_w_)[0]\\n with tf.name_scope(\\\"max_time\\\"):\\n self.max_time_ = tf.shape(self.input_w_)[1]\\n\\n # Get sequence length from input_w_.\\n # TL;DR: pass this to dynamic_rnn.\\n # This will be a vector with elements ns[i] = len(input_w_[i])\\n # You can override this in feed_dict if you want to have different-length\\n # sequences in the same batch, although you shouldn't need to for this\\n # assignment.\\n self.ns_ = tf.tile([self.max_time_], [self.batch_size_, ], name=\\\"ns\\\")#update this for project\\n\\n #### YOUR CODE HERE ####\\n # See hints in instructions!\\n\\n # Construct embedding layer\\n #self.W_in_ = tf.get_variable(\\\"W_in\\\", shape=[self.V, self.H], \\n #initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n #self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\\n \\n #self.W_in_ = tf.get_variable(tf.random_uniform([self.V, self.H], -1.0, 1.0), name=\\\"W_in\\\")\\n #Variable(tf.random_uniform([V, M], -1.0, 1.0), name=\\\"C\\\")\\n # embedding_lookup gives shape (batch_size, N, M)\\n #x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\\n \\n with tf.name_scope(\\\"embedding_layer\\\"):\\n self.W_in_ = tf.get_variable(\\\"W_in\\\", shape=[self.V, self.H], \\n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n self.x_ = tf.nn.embedding_lookup(self.W_in_, self.input_w_)\\n\\n\\n\\n # Construct RNN/LSTM cell and recurrent layer.\\n with tf.name_scope(\\\"recurrent_layer\\\"):\\n self.cell_ = MakeFancyRNNCell(self.H, self.dropout_keep_prob_, self.num_layers)\\n self.initial_h_ = self.cell_.zero_state(self.batch_size_,tf.float32)\\n self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=self.x_, \\n sequence_length=self.ns_, initial_state=self.initial_h_,\\n dtype=tf.float32)\\n #print(self.outputs_.get_shape())\\n #self.outputs_, self.final_h_ = tf.nn.dynamic_rnn(self.cell_, inputs=x_, \\n #sequence_length=self.ns_, initial_state=self.initial_h_,\\n #dtype=tf.float32)\\n \\n #W1_ = tf.Variable(tf.random_normal([N*M,H]), name=\\\"W1\\\")\\n #b1_ = tf.Variable(tf.zeros([H,], dtype=tf.float32), name=\\\"b1\\\")\\n #h_ = tf.tanh(tf.matmul(x_, W1_) + b1_, name=\\\"h\\\")\\n\\n\\n\\n\\n\\n # Softmax output layer, over vocabulary. Just compute logits_ here.\\n # Hint: the matmul3d function will be useful here; it's a drop-in\\n # replacement for tf.matmul that will handle the \\\"time\\\" dimension\\n # properly.\\n with tf.name_scope(\\\"softmax_output_layer\\\"):\\n self.W_out_ = tf.get_variable(\\\"W_out\\\", shape=[self.H, self.V], \\n initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n #tf.get_variable(tf.random_uniform([self.H, self.V], -1.0, 1.0), name=\\\"W_out\\\")\\n\\n self.b_out_ = tf.get_variable(\\\"b_out\\\", shape=[self.V,], \\n initializer = tf.zeros_initializer())\\n #self.b_out_ = tf.get_variable(\\\"b_out\\\", shape=[self.V,], initializer = tf.random_uniform_initializer(minval=-1.0, maxval=1.0))\\n #tf.get_variable(tf.random_uniform([self.V,], -1.0, 1.0), name=\\\"b_out\\\")\\n\\n self.logits_ = tf.add(matmul3d(self.outputs_, self.W_out_), self.b_out_, name=\\\"logits\\\")\\n #print(self.logits_.get_shape())\\n\\n\\n\\n # Loss computation (true loss, for prediction)\\n with tf.name_scope(\\\"loss_computation\\\"):\\n per_example_loss_ = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.target_y_, \\n logits=self.logits_, \\n name=\\\"per_example_loss\\\")\\n self.loss_ = tf.reduce_mean(per_example_loss_, name=\\\"loss\\\")\\n\\n\\n\\n #### END(YOUR CODE) ####\",\n \"def resnet_9blocks(pretrained=False, **kwargs):\\n return ResnetGenerator(\\n 9, **kwargs\\n )\",\n \"def __init__(self,\\n num_units,\\n forget_bias=1.0,\\n state_is_tuple=True,\\n activation=None,\\n reuse=None,\\n name=None):\\n super(MaskedBasicLSTMCell, self).__init__(\\n num_units,\\n forget_bias=forget_bias,\\n state_is_tuple=state_is_tuple,\\n activation=activation,\\n reuse=reuse,\\n name=name)\",\n \"def gen_CASTEP_supercell(CASTEP_cell,na,nb,nc):\\n nruter=dict()\\n nruter[\\\"na\\\"]=na\\n nruter[\\\"nb\\\"]=nb\\n nruter[\\\"nc\\\"]=nc\\n nruter[\\\"lattvec\\\"]=np.array(CASTEP_cell[\\\"lattvec\\\"])\\n nruter[\\\"lattvec\\\"][:,0]*=na\\n nruter[\\\"lattvec\\\"][:,1]*=nb\\n nruter[\\\"lattvec\\\"][:,2]*=nc\\n nruter[\\\"elements\\\"]=copy.copy(CASTEP_cell[\\\"elements\\\"])\\n nruter[\\\"numbers\\\"]=na*nb*nc*CASTEP_cell[\\\"numbers\\\"]\\n nruter[\\\"positions\\\"]=np.empty((3,CASTEP_cell[\\\"positions\\\"].shape[1]*na*nb*nc))\\n pos=0\\n for pos,(k,j,i,iat) in enumerate(itertools.product(xrange(nc),\\n xrange(nb),\\n xrange(na),\\n xrange(\\n CASTEP_cell[\\\"positions\\\"].shape[1]))):\\n nruter[\\\"positions\\\"][:,pos]=(CASTEP_cell[\\\"positions\\\"][:,iat]+[i,j,k])/[\\n na,nb,nc]\\n nruter[\\\"types\\\"]=[]\\n for i in xrange(na*nb*nc):\\n nruter[\\\"types\\\"].extend(CASTEP_cell[\\\"types\\\"])\\n # print \\\"supercell\\\", nruter\\n return nruter\",\n \"def _build_rnn_graph_lstm(self, inputs, config, is_training):\\n cell = util.create_lstm_cell(is_training, config)\\n state = util.get_zero_state_for_the_cell(cell, config)\\n\\n self.initial_state = state\\n with tf.variable_scope(\\\"RNN\\\"):\\n inputs = tf.unstack(inputs, num=self.num_steps, axis=1)\\n outputs, state = tf.contrib.rnn.static_rnn(cell, inputs,\\n initial_state=self.initial_state)\\n output = tf.reshape(tf.concat(outputs, 1), [-1, config.hidden_size])\\n return output, state\",\n \"def compile_model(network):\\n # Get our network parameters.\\n max_depth = network['max_depth']\\n base_score = network['base_score']\\n colsample_bylevel = network['colsample_bylevel']\\n colsample_bytree = network['colsample_bytree']\\n gamma = network['gamma']\\n learning_rate = network['learning_rate']\\n min_child_weight = network['min_child_weight']\\n tree_method = network['tree_method']\\n\\n model = xgb.XGBRegressor(nthread=-1, n_estimators=5000,\\n # booster=booster,\\n max_depth=max_depth,\\n base_score=base_score,\\n colsample_bylevel=colsample_bylevel,\\n colsample_bytree=colsample_bytree,\\n gamma=gamma,\\n learning_rate=learning_rate,\\n min_child_weight=min_child_weight,\\n tree_method=tree_method)\\n\\n return model\",\n \"def setup(self):\\n rnn_type = 'gru'\\n n_hidden = 24\\n\\n flopper = Flipflopper(rnn_type=rnn_type, n_hidden=n_hidden)\\n stim = flopper.generate_flipflop_trials()\\n # train the model\\n # flopper.train(stim, 4000, save_model=True)\\n\\n # if a trained model has been saved, it may also be loaded\\n flopper.load_model()\\n\\n self.weights = flopper.model.get_layer(flopper.hps['rnn_type']).get_weights()\\n self.output_weights = flopper.model.get_layer('dense').get_weights()\\n self.activations = np.vstack(flopper.get_activations(stim))\\n self.outputs = np.vstack(stim['output'])\\n # self.activations = self.outputs @ self.output_weights[0].T # this will make for idealized activations\\n\\n self.sGru = SerializedGru(self.weights, n_hidden) # helper class to serialize gru\\n\\n self.complex_activations = self.activations @ (1/4 * self.sGru.h_c_inv) # transform activations to complex system\\n # self.complex_activations = np.vstack((np.zeros(n_hidden), self.complex_activations[:-1, :]))\\n\\n inputs = np.vstack(stim['inputs'])\\n self.sGru.handle_inputs(inputs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75219285","0.67751324","0.65611047","0.652693","0.65234923","0.6497355","0.6401402","0.6371681","0.6347477","0.6342275","0.62993085","0.6285365","0.6272967","0.6165039","0.61427605","0.6132339","0.610192","0.6040023","0.59487605","0.58486575","0.5812393","0.58020526","0.57976097","0.57498205","0.5718456","0.5678024","0.5666751","0.5657538","0.564559","0.56174296","0.5600809","0.560063","0.5590133","0.5562155","0.5529439","0.55182266","0.5494466","0.548932","0.5476407","0.544775","0.5425902","0.5414445","0.54085094","0.53850454","0.53518","0.53410476","0.5340776","0.53311104","0.5315129","0.5308221","0.52928835","0.52774817","0.5277314","0.5276819","0.5271795","0.52708656","0.526582","0.52517647","0.5242348","0.5241943","0.5233093","0.5229096","0.52183187","0.52163666","0.5207566","0.5205433","0.5193612","0.5172971","0.51652503","0.5153352","0.51523805","0.51092595","0.5087263","0.5083116","0.5075856","0.5055211","0.5054857","0.5051429","0.50283223","0.5019656","0.5008198","0.5004285","0.5002845","0.4990853","0.49805108","0.49777946","0.49674773","0.49553305","0.4949768","0.49372354","0.49287453","0.49242896","0.49240804","0.49223274","0.49218893","0.49179956","0.49169382","0.49130613","0.49101707","0.49012432"],"string":"[\n \"0.75219285\",\n \"0.67751324\",\n \"0.65611047\",\n \"0.652693\",\n \"0.65234923\",\n \"0.6497355\",\n \"0.6401402\",\n \"0.6371681\",\n \"0.6347477\",\n \"0.6342275\",\n \"0.62993085\",\n \"0.6285365\",\n \"0.6272967\",\n \"0.6165039\",\n \"0.61427605\",\n \"0.6132339\",\n \"0.610192\",\n \"0.6040023\",\n \"0.59487605\",\n \"0.58486575\",\n \"0.5812393\",\n \"0.58020526\",\n \"0.57976097\",\n \"0.57498205\",\n \"0.5718456\",\n \"0.5678024\",\n \"0.5666751\",\n \"0.5657538\",\n \"0.564559\",\n \"0.56174296\",\n \"0.5600809\",\n \"0.560063\",\n \"0.5590133\",\n \"0.5562155\",\n \"0.5529439\",\n \"0.55182266\",\n \"0.5494466\",\n \"0.548932\",\n \"0.5476407\",\n \"0.544775\",\n \"0.5425902\",\n \"0.5414445\",\n \"0.54085094\",\n \"0.53850454\",\n \"0.53518\",\n \"0.53410476\",\n \"0.5340776\",\n \"0.53311104\",\n \"0.5315129\",\n \"0.5308221\",\n \"0.52928835\",\n \"0.52774817\",\n \"0.5277314\",\n \"0.5276819\",\n \"0.5271795\",\n \"0.52708656\",\n \"0.526582\",\n \"0.52517647\",\n \"0.5242348\",\n \"0.5241943\",\n \"0.5233093\",\n \"0.5229096\",\n \"0.52183187\",\n \"0.52163666\",\n \"0.5207566\",\n \"0.5205433\",\n \"0.5193612\",\n \"0.5172971\",\n \"0.51652503\",\n \"0.5153352\",\n \"0.51523805\",\n \"0.51092595\",\n \"0.5087263\",\n \"0.5083116\",\n \"0.5075856\",\n \"0.5055211\",\n \"0.5054857\",\n \"0.5051429\",\n \"0.50283223\",\n \"0.5019656\",\n \"0.5008198\",\n \"0.5004285\",\n \"0.5002845\",\n \"0.4990853\",\n \"0.49805108\",\n \"0.49777946\",\n \"0.49674773\",\n \"0.49553305\",\n \"0.4949768\",\n \"0.49372354\",\n \"0.49287453\",\n \"0.49242896\",\n \"0.49240804\",\n \"0.49223274\",\n \"0.49218893\",\n \"0.49179956\",\n \"0.49169382\",\n \"0.49130613\",\n \"0.49101707\",\n \"0.49012432\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75191617"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":88992,"cells":{"query":{"kind":"string","value":"Multi RNN cell wraps a sequence of cells into one cell"},"document":{"kind":"string","value":"def build_multi_rnn(cells):\n return tf.nn.rnn_cell.MultiRNNCell(cells)"},"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 _create_rnn_cells(self, is_list=False):\n\n stacked_rnn = []\n for _ in range(self.num_layers):\n single_cell = self._rnn_single_cell()\n stacked_rnn.append(single_cell)\n\n if is_list:\n return stacked_rnn\n else:\n return tf.nn.rnn_cell.MultiRNNCell(\n cells=stacked_rnn,\n state_is_tuple=True)","def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\n cells = []\n for layer_size in rnn_cell_size:\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\n if attn_len and not cells:\n # Add attention wrapper to first layer.\n cell = tf.contrib.rnn.AttentionCellWrapper(\n cell, attn_len, state_is_tuple=True)\n cell = tf.contrib.rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return tf.contrib.rnn.MultiRNNCell(cells)","def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\n cells = []\n for layer_size in rnn_cell_size:\n cell = rnn.LSTMBlockCell(layer_size)\n cell = rnn.DropoutWrapper(\n cell,\n input_keep_prob=dropout_keep_prob)\n cells.append(cell)\n return rnn.MultiRNNCell(cells)","def get_rnn_cells(self):\n return [self.rnn]","def MakeFancyRNNCell(H, keep_prob, num_layers=1):\n cells = []\n for _ in range(num_layers):\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cells.append(cell)\n return tf.nn.rnn_cell.MultiRNNCell(cells)","def get_rnn_cells(self) -> List[mx.rnn.BaseRNNCell]:\n return self.forward_rnn.get_rnn_cells() + self.reverse_rnn.get_rnn_cells()","def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\n if is_train:\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\n return cell","def _create_rnn_cell(num_units, num_layers, mode):\n\n cell_list = []\n for i in range(num_layers):\n single_cell = STLSTMCell(name=\"stlstm\",\n num_units=num_units,\n st_activation=tf.nn.relu,\n st_kernel_initializer=tf.glorot_uniform_initializer(),\n st_num_layers=2,\n st_residual=True)\n cell_list.append(single_cell)\n\n return cell_list","def multi_batch_rnn(BaseEncoderClass):\n class MultiBatchRNN(BaseEncoderClass):\n def __init__(self, bptt, max_seq, *args, **kwargs):\n self.max_seq = max_seq\n self.bptt = bptt\n super().__init__(*args, **kwargs)\n\n def concat(self, arrs):\n return [torch.cat([l[si] for l in arrs]) for si in range(len(arrs[0]))]\n\n def forward(self, input):\n sl, bs = input.size()\n for l in self.hidden:\n for h in l: h.data.zero_()\n raw_outputs, outputs = [], []\n for i in range(0, sl, self.bptt):\n r, o = super().forward(input[i: min(i + self.bptt, sl)])\n if i > (sl - self.max_seq):\n raw_outputs.append(r)\n outputs.append(o)\n return self.concat(raw_outputs), self.concat(outputs)\n return MultiBatchRNN","def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\n readout_init, readout_apply = stax.Dense(num_outputs)\n\n def init_fun(key, input_shape):\n \"\"\"Initialize the components of the RNN.\n\n Args:\n key: Jax PRNGkey used to initialize the parameters.\n input_shape: tuple representing the input shape, should be\n (batch_size, sequence_length).\n\n Returns:\n shapes: set of tuples representing the shapes after applying\n the Embedding, RNN Cell, and Readout layers.\n network_params: tuple of network parameters, containing the\n embedding, RNN cell, and readout parameters.\n \"\"\"\n\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\n\n # Initialize the Embedding for the input tokens.\n emb_shape, emb_params = emb_init(emb_key, input_shape)\n\n # The cell is defined for a single update step, which is why we ignore\n # the sequence dimension (emb_shape[1]) here.\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\n\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\n\n shapes = (emb_shape, rnn_shape, output_shape)\n network_params = (emb_params, rnn_params, readout_params)\n\n return shapes, network_params\n\n def apply_fun(network_params, tokens):\n \"\"\"Applies the RNN on a batch of input sequences.\n\n Args:\n network_params: tuple of network parameters (see init_fun).\n tokens: batch of inputs, with shape (batch_size, sequence_length).\n\n Returns:\n outputs: network outputs, at every step along the sequence.\n \"\"\"\n emb_params, rnn_params, readout_params = network_params\n\n # Apply the embedding.\n inputs = emb_apply(emb_params, tokens)\n\n # Run the RNN.\n initial_states = cell.get_initial_state(rnn_params,\n batch_size=tokens.shape[0])\n return unroll.unroll_rnn(initial_states, inputs,\n functools.partial(cell.batch_apply, rnn_params),\n functools.partial(readout_apply, readout_params))\n\n return init_fun, apply_fun, emb_apply, readout_apply","def _rnn_cells(self) -> RNNCellTuple:\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))","def build_rnn(cell, inputs):\n #_,initial_state = get_init_cell(batch_size, rnn_size)\n \n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name='final_state')\n\n return (output, final_state)","def build_rnn(cell, inputs):\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\n final_state = tf.identity(final_state, name=\"final_state\")\n\n return outputs, final_state","def rnn_cell_loop(self):\n\n\t\t# Set up initial state\n\t\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\t\t\t# Spike\n\t\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\t\t\t\t\t# State\n\t\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\n\t\tself.h = [self.h]\n\t\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\n\n\t\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\t\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\n\n\t\t# Apply the EI mask to the recurrent weights\n\t\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\n\n\t\t# Set up latency buffer if being used\n\t\tif par['use_latency']:\n\t\t\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\n\t\t\tself.state_buffer = deque(self.state_buffer)\n\t\t\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\n\t\t\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\n\n\t\t# Set up output record\n\t\tself.output = []\n\t\tself.syn_x = []\n\t\tself.syn_u = []\n\n\t\ty = 0.\n\t\tfor t in range(par['num_time_steps']):\n\t\t\tself.t = t \t\t# For latency calculations\n\n\t\t\tif par['cell_type'] == 'rate':\n\t\t\t\traise Exception('Rate cell not yet implemented.')\n\t\t\telif par['cell_type'] == 'adex':\n\t\t\t\tif t < 10:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\telse:\n\t\t\t\t\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\n\t\t\t\t\t\tadapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\t\t\t\tself.syn_x.append(syn_x)\n\t\t\t\tself.syn_u.append(syn_u)\n\n\t\t\telif par['cell_type'] == 'lif':\n\t\t\t\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\n\t\t\t\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\n\n\t\t\t\tself.h_out.append(spike)\n\t\t\t\tself.h.append(state)\n\t\t\t\tself.output.append(y)\n\n\t\t# Stack records\n\t\tself.output = tf.stack(self.output, axis=0)\n\t\tself.h = tf.stack(self.h, axis=0)\n\t\tself.h_out = tf.stack(self.h_out, axis=0)\n\t\tself.syn_x = tf.stack(self.syn_x, axis=0)\n\t\tself.syn_u = tf.stack(self.syn_u, axis=0)","def custom_rnn(cell, inputs, initial_state=None, dtype=None,\r\n sequence_length=None, scope=None):\r\n\r\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\r\n raise TypeError(\"cell must be an instance of RNNCell\")\r\n if not nest.is_sequence(inputs):\r\n raise TypeError(\"inputs must be a sequence\")\r\n if not inputs:\r\n raise ValueError(\"inputs must not be empty\")\r\n\r\n outputs = []\r\n states = []\r\n # Create a new scope in which the caching device is either\r\n # determined by the parent scope, or is set to place the cached\r\n # Variable using the same placement as for the rest of the RNN.\r\n with vs.variable_scope(scope or \"RNN\") as varscope:\r\n if varscope.caching_device is None:\r\n varscope.set_caching_device(lambda op: op.device)\r\n\r\n # Obtain the first sequence of the input\r\n first_input = inputs\r\n while nest.is_sequence(first_input):\r\n first_input = first_input[0]\r\n\r\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\r\n # TODO(lukaszkaiser): remove EmbeddingWrapper\r\n if first_input.get_shape().ndims != 1:\r\n\r\n input_shape = first_input.get_shape().with_rank_at_least(2)\r\n fixed_batch_size = input_shape[0]\r\n\r\n flat_inputs = nest.flatten(inputs)\r\n for flat_input in flat_inputs:\r\n input_shape = flat_input.get_shape().with_rank_at_least(2)\r\n batch_size, input_size = input_shape[0], input_shape[1:]\r\n fixed_batch_size.merge_with(batch_size)\r\n for i, size in enumerate(input_size):\r\n if size.value is None:\r\n raise ValueError(\r\n \"Input size (dimension %d of inputs) must be accessible via \"\r\n \"shape inference, but saw value None.\" % i)\r\n else:\r\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\r\n\r\n if fixed_batch_size.value:\r\n batch_size = fixed_batch_size.value\r\n else:\r\n batch_size = array_ops.shape(first_input)[0]\r\n if initial_state is not None:\r\n state = initial_state\r\n else:\r\n if not dtype:\r\n raise ValueError(\"If no initial_state is provided, \"\r\n \"dtype must be specified\")\r\n state = cell.zero_state(batch_size, dtype)\r\n\r\n if sequence_length is not None: # Prepare variables\r\n sequence_length = ops.convert_to_tensor(\r\n sequence_length, name=\"sequence_length\")\r\n if sequence_length.get_shape().ndims not in (None, 1):\r\n raise ValueError(\r\n \"sequence_length must be a vector of length batch_size\")\r\n def _create_zero_output(output_size):\r\n # convert int to TensorShape if necessary\r\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\r\n output = array_ops.zeros(\r\n array_ops.pack(size), _infer_state_dtype(dtype, state))\r\n shape = _state_size_with_prefix(\r\n output_size, prefix=[fixed_batch_size.value])\r\n output.set_shape(tensor_shape.TensorShape(shape))\r\n return output\r\n\r\n output_size = cell.output_size\r\n flat_output_size = nest.flatten(output_size)\r\n flat_zero_output = tuple(\r\n _create_zero_output(size) for size in flat_output_size)\r\n zero_output = nest.pack_sequence_as(structure=output_size,\r\n flat_sequence=flat_zero_output)\r\n\r\n sequence_length = math_ops.to_int32(sequence_length)\r\n min_sequence_length = math_ops.reduce_min(sequence_length)\r\n max_sequence_length = math_ops.reduce_max(sequence_length)\r\n\r\n for time, input_ in enumerate(inputs):\r\n if time > 0: varscope.reuse_variables()\r\n # pylint: disable=cell-var-from-loop\r\n call_cell = lambda: cell(input_, state)\r\n # pylint: enable=cell-var-from-loop\r\n if sequence_length is not None:\r\n (output, state) = _rnn_step(\r\n time=time,\r\n sequence_length=sequence_length,\r\n min_sequence_length=min_sequence_length,\r\n max_sequence_length=max_sequence_length,\r\n zero_output=zero_output,\r\n state=state,\r\n call_cell=call_cell,\r\n state_size=cell.state_size)\r\n else:\r\n (output, state) = call_cell()\r\n\r\n outputs.append(output)\r\n states.append(state)\r\n\r\n return (outputs, state, states)","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embed = get_embed(input_data, vocab_size, embed_dim) \n output, final_state = build_rnn(cell, embed)\n \n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\n #final_state = tf.identity(final_state, name='final_state') \n return logits, final_state","def rnn(rnn_cell, X, h_0):\n t, m, i = X.shape\n h1, h = h_0.shape\n H = np.zeros((t + 1, h1, h))\n # print(\"HHH\", H.shape)\n H[-1] = np.zeros(h)\n Y = np.zeros((t, i))\n Y = []\n # print(\"XXX\", X.shape)\n # print('this shape?', X.shape)\n # print(\"YYY\", Y.shape)\n h_next = h_0\n for ti in range(t):\n H[ti + 1], y = rnn_cell.forward(h_next, X[ti])\n h_next = H[ti + 1]\n Y.append(y)\n return H, np.array(Y)","def create_rnn_cell(num_units,\n num_layers,\n num_residual_layers,\n dropout,\n mode,\n num_gpus,\n base_gpu=0,\n single_cell_fn=None,\n all_layer_outputs=False):\n cell_list = _cell_list(\n num_units=num_units,\n num_layers=num_layers,\n num_residual_layers=num_residual_layers,\n dropout=dropout,\n mode=mode,\n num_gpus=num_gpus,\n base_gpu=base_gpu,\n single_cell_fn=single_cell_fn)\n\n if len(cell_list) == 1: # Single layer.\n return cell_list[0]\n else: # Multi layers\n print(all_layer_outputs, \"all_layer_outputs\")\n\n if all_layer_outputs:\n return MultiRNNCell(cell_list)\n else:\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)","def build_rnn_cell(type, num_units, dropout):\n cell = tf.nn.rnn_cell.BasicRNNCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result","def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\n if layer_type == \"layernorm_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\n else:\n if layer_type == \"lstm\":\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\n elif layer_type == \"gru\":\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_gru\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\n elif layer_type == \"cudnn_lstm\":\n # pylint: disable=no-member\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\n else:\n raise ValueError(\"Error: not supported rnn type:{}\".format(layer_type))\n\n cell = tf.nn.rnn_cell.DropoutWrapper(\n cell, output_keep_prob=dropout_keep_prob)\n return cell","def _dynamic_rnn_loop(cell: RNNCellBase[State], inputs: torch.Tensor, initial_state: State, sequence_length: torch.LongTensor) ->Tuple[torch.Tensor, State]:\n state = initial_state\n time_steps = inputs.shape[0]\n all_outputs = []\n all_state = map_structure(lambda _: no_map(list), state)\n for i in range(time_steps):\n output, state = cell(inputs[i], state)\n all_outputs.append(output)\n map_structure_zip(lambda xs, x: xs.append(x), (all_state, state))\n final_outputs = torch.stack(all_outputs, dim=0)\n final_outputs = mask_sequences(final_outputs, sequence_length=sequence_length, time_major=True)\n final_state = map_structure(lambda _: no_map(list), state)\n for batch_idx, time_idx in enumerate(sequence_length.tolist()):\n if time_idx > 0:\n map_structure_zip(lambda xs, x: xs.append(x[time_idx - 1][batch_idx]), (final_state, all_state))\n else:\n map_structure_zip(lambda xs, x: xs.append(x[batch_idx]), (final_state, initial_state))\n final_state = map_structure(lambda x: torch.stack(x, dim=0), final_state)\n return final_outputs, final_state","def get_init_cell(batch_size, rnn_size):\n\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\n num_of_layers = 3\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name='initial_state')\n \n return (cell, initial_state)","def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\n # todo 1、获取嵌入层的输出\n embed = get_embed(input_data, vocab_size, embed_dim)\n # todo-2、获取 隐藏层的输出\n rnn_outputs, final_state, final_state1 = build_rnn(\n cell, embed, initial_state=initial_state)\n # 3、构建全连接，获取logits\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\n # [N, n-steps, num_classes]\n return logits, final_state, final_state1","def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\n embedding = get_embed(input_data, vocab_size, rnn_size)\n outputs, final_state = build_rnn(cell, embedding)\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\n\n return logits, final_state","def __init__(self, input_size, hidden_size, output_size, model=\"gru\", n_layers=1):\n \n super(CharRNN, self).__init__()\n\n self.input_size = input_size\n self.hidden_size = hidden_size\n self.output_size = output_size\n self.n_layers = n_layers\n\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\n \n self.model = model\n if model.lower() == \"lstm\":\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\n else: # model is GRU\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\n\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer","def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\n is_batch_norm, is_bidirectional):\n if is_batch_norm:\n input_data = tf.keras.layers.BatchNormalization(\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\n rnn_layer = rnn_cell(\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\n name=\"rnn_{}\".format(layer_id))\n if is_bidirectional:\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\"sum\")\n\n return rnn_layer(input_data)","def encoder_one_way(self, cell, x, seq_len, init_state=None):\n # Output is the outputs at all time steps, state is the last state\n with tf.variable_scope(\"dynamic_rnn\"):\n outputs, state = tf.nn.dynamic_rnn(\\\n cell, x, sequence_length=seq_len, initial_state=init_state,\n dtype=self.floatX)\n # state is a StateTuple class with properties StateTuple.c and StateTuple.h\n return outputs, state","def cell_edges(self):","def _build_rnn(self, n_cells, hidden_layer_size, num_layers,\n batch_size, time_window, lr):\n\n x_anchor = tf.placeholder(shape=[batch_size, n_cells, time_window],\n dtype=tf.float32)\n x_pos = tf.placeholder(shape=[batch_size, n_cells, time_window],\n dtype=tf.float32)\n x_neg = tf.placeholder(shape=[batch_size, n_cells, time_window,],\n dtype=tf.float32)\n\n def embed_rnn(x_in):\n \"\"\"Gives RNN embedding of x_in.\"\"\"\n x_in_flat = tf.reshape(x_in, [batch_size*time_window, n_cells])\n w_in = tf.get_variable(\"w_in\", shape=[n_cells, hidden_layer_size],\n initializer=tf.random_normal_initializer())\n b_in = tf.get_variable(\"b_in\", shape=[hidden_layer_size],\n initializer=tf.random_normal_initializer())\n x_ld_flat = tf.matmul(x_in_flat, w_in) + b_in\n x_ld = tf.reshape(x_ld_flat, [batch_size, time_window, hidden_layer_size])\n\n # stacked LSTM cells\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_layer_size,\n forget_bias=0.0,\n state_is_tuple=True)\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers,\n state_is_tuple=True)\n\n # compute output\n initial_state = cell.zero_state(batch_size, tf.float32)\n outputs, _ = tf.nn.dynamic_rnn(cell, x_ld,\n initial_state=initial_state,\n time_major=False)\n\n # reconstruct and compute loss on last output only\n outputs_unp = tf.unpack(tf.transpose(outputs, [1, 0, 2]))\n embedding = outputs_unp[-1]\n\n return embedding\n\n def distance_squared(embed1, embed2):\n return tf.reduce_sum((embed1 - embed2)**2, 1)\n\n with tf.variable_scope(\"RNN\") as scope:\n\n # embed anchor, positive and negative examples.\n embed_anchor = embed_rnn(tf.transpose(x_anchor, [0, 2, 1]))\n # This enables reusing the RNN for anchor, pos and neg.\n scope.reuse_variables()\n # Check that we are reusing the same RNN using:\n # print(tf.get_variable_scope().reuse)\n embed_pos = embed_rnn(tf.transpose(x_pos, [0, 2, 1]))\n embed_neg = embed_rnn(tf.transpose(x_neg, [0, 2, 1]))\n\n # Loss for each point max(d(anchor, pos)^2 - d(anchor, neg)^2 + 1, 0)\n loss = tf.reduce_sum(tf.nn.relu(distance_squared(embed_anchor,\n embed_pos) -\n distance_squared(embed_anchor,\n embed_neg)\n + 1), 0)\n # train model\n train_step = tf.train.AdagradOptimizer(lr).minimize(loss)\n\n return (x_anchor, x_pos, x_neg, train_step, loss,\n embed_anchor, embed_pos, embed_neg)","def add_model(self, inputs):\n size = self.config.hidden_size\n forget_bias = self.config.forget_bias\n input_cell = self.config.input_cell\n\n if input_cell == 'BasicLSTMCell':\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\n print 'Using Basic LSTM Cell \\n'\n\n elif input_cell == 'LSTMCell':\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\n print 'Using LSTM Cell \\n'\n\n elif input_cell == 'GRUCell':\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\n print 'Using GRU Cell \\n'\n\n else:\n print \"Please Specify a Correct Cell Type\"\n\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\n input_keep_prob=self.config.dropout)\n\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\n \n print 'Number of Hidden Layers ', self.config.num_layers\n \n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\n rnn_outputs = []\n state = self.initial_state\n\n with tf.variable_scope('RNNLM') as scope:\n for time_step in range(self.config.num_steps):\n if time_step > 0: scope.reuse_variables()\n (cell_output, state) = cell(inputs[:, time_step, :], state)\n rnn_outputs.append(cell_output)\n self.final_state = state\n\n return rnn_outputs","def get_init_cell(batch_size, rnn_size):\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\n initial_state = cell.zero_state(batch_size, tf.float32)\n initial_state = tf.identity(initial_state, name=\"initial_state\")\n\n return cell, initial_state","def deep_rnn(rnn_cells, X, h_0):\n T, m, i = X.shape\n layers, _, h = h_0.shape\n H = np.zeros((T + 1, layers, m, h))\n Y = np.zeros((T, m, rnn_cells[-1].Wy.shape[1]))\n H[0] = h_0\n for t in range(T):\n H[t + 1, 0], Y[t] = rnn_cells[0].forward(H[t, 0], X[t])\n for layer in range(1, layers):\n rnn = rnn_cells[layer]\n H[t + 1, layer], Y[t] = rnn.forward(H[t, layer],\n H[t + 1, layer - 1])\n return H, Y","def rnn_cell(hprev, zt, name=None, reuse=False):\n nin = zt.shape[-1].value\n nout = hprev.shape[-1].value\n with tf.variable_scope(name, default_name=\"rnn\", values=[hprev, zt], reuse=reuse):\n wz = get_variable_wrap(\"kernel/input\", [nin, nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n wh = get_variable_wrap(\"kernel/hidden\", [nout, nout],dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n bh = get_variable_wrap(\"bias\", [nout], dtype=tf.float32, \n initializer=tf.random_normal_initializer(0, 0.01))\n \n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)","def __init__(self,input_dim, hidden_dim, kernel_sizes, num_layers,gb_hidden_size):\r\n\r\n super().__init__()\r\n\r\n self.input_size = input_dim\r\n self.input_dim =input_dim\r\n\r\n if type(hidden_dim) != list:\r\n self.hidden_sizes = [hidden_dim]*num_layers\r\n else:\r\n assert len(hidden_dim) == num_layers, '`hidden_sizes` must have the same length as n_layers'\r\n self.hidden_sizes = hidden_dim\r\n if type(kernel_sizes) != list:\r\n self.kernel_sizes = [kernel_sizes]*num_layers\r\n else:\r\n assert len(kernel_sizes) == num_layers, '`kernel_sizes` must have the same length as n_layers'\r\n self.kernel_sizes = kernel_sizes\r\n\r\n self.n_layers = num_layers\r\n\r\n cells = nn.ModuleList()\r\n squenceCells=nn.ModuleList()\r\n\r\n for i in range(self.n_layers):\r\n\r\n if i == 0:\r\n input_dim = self.input_size\r\n else:\r\n input_dim = self.hidden_sizes[i-1]\r\n\r\n cell = ConvGRUCell(self.input_dim[i], self.hidden_sizes[i], 3)\r\n\r\n cells.append(cell)\r\n\r\n self.cells = cells\r\n\r\n\r\n for i in range(self.n_layers):\r\n\r\n squenceCell = SequenceGRU(gb_hidden_size[i])\r\n\r\n squenceCells.append(squenceCell)\r\n\r\n self.squenceCells = squenceCells","def encode_sequence(sequence, rnns, embedder, dropout_amount=0.):\n\n batch_size = 1\n layer_states = []\n for rnn in rnns:\n hidden_size = rnn.weight_hh.size()[1]\n \n # h_0 of shape (batch, hidden_size)\n # c_0 of shape (batch, hidden_size)\n if rnn.weight_hh.is_cuda:\n h_0 = torch.cuda.FloatTensor(batch_size,hidden_size).fill_(0)\n c_0 = torch.cuda.FloatTensor(batch_size,hidden_size).fill_(0)\n else:\n h_0 = torch.zeros(batch_size,hidden_size)\n c_0 = torch.zeros(batch_size,hidden_size)\n\n layer_states.append((h_0, c_0))\n\n outputs = []\n for token in sequence:\n rnn_input = embedder(token)\n (cell_states, hidden_states), output, layer_states = forward_one_multilayer(rnns,rnn_input,layer_states,dropout_amount)\n\n outputs.append(output)\n\n return (cell_states, hidden_states), outputs","def __init__(self, cell, attn_inputs, \n attn_size, attn_vec_size,\n output_size=None, input_size=None, \n state_is_tuple=True, attn_masks=None,\n merge_output_attn='linear',\n reuse=None):\n if not isinstance(cell, rnn.RNNCell):\n raise TypeError(\"The parameter cell is not RNNCell.\")\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\n raise ValueError(\"Cell returns tuple of states, but the flag \"\n \"state_is_tuple is not set. State size is: %s\"\n % str(cell.state_size))\n if not state_is_tuple:\n logging.warn(\n \"%s: Using a concatenated state is slower and will soon be \"\n \"deprecated. Use state_is_tuple=True.\", self)\n\n self._state_is_tuple = state_is_tuple\n\n if not state_is_tuple:\n raise NotImplementedError\n\n self._cell = cell\n self._input_size = input_size\n self._output_size = output_size\n if output_size is None:\n self._output_size = cell.output_size\n self._attn_size = attn_size\n self._reuse = reuse\n self._attn_inputs = attn_inputs\n self._attn_vec_size = attn_vec_size\n self.attn_masks = attn_masks\n self.merge_output_attn = merge_output_attn","def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\n cells = []\n for i in range(layer_num):\n if rnn_type.endswith('lstm'):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n elif rnn_type.endswith('gru'):\n cell = tc.rnn.GRUCell(num_units=hidden_size)\n elif rnn_type.endswith('rnn'):\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\n else:\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\n return cells","def __init__(self, rnn_cell, batch_size,\n input_size, num_outputs):\n super().__init__(name='RNNCellStateModel')\n self._rnn_cell = rnn_cell\n self._batch_size = batch_size\n self._input_size = input_size\n self._num_outputs = num_outputs","def get_rnn(X, rnn_size, seq_len, batch_size, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0, is_training=False,\n cell_name=\"BasicLSTM\", bidirectional=False):\n with tf.device(\"/cpu:0\"):\n # Convert input tensor to python list (along the sequence length dimention)\n word_embeddings = tf.split(1, seq_len, X)\n word_embeddings = [tf.squeeze(embed_, [1]) for embed_ in word_embeddings]\n\n # if is_training and keep_prob < 1:\n # word_embeddings = [tf.nn.dropout(input_, keep_prob) for input_ in word_embeddings]\n\n def get_cell():\n if cell_name == \"GRU\": # GRU\n cell = rnn_cell.GRUCell(rnn_size)\n elif cell_name == \"LSTM\": # LSTM\n cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\n else:\n cell = rnn_cell.BasicLSTMCell(rnn_size)\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\n cell = rnn_cell.DropoutWrapper(cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\n cell = rnn_cell.MultiRNNCell([cell] * num_layers)\n initial_state = cell.zero_state(batch_size, tf.float32)\n return cell, initial_state\n\n if bidirectional:\n with tf.variable_scope(\"forward\"):\n cell_fw, initial_state_fw = get_cell()\n with tf.variable_scope(\"backward\"):\n cell_bw, initial_state_bw = get_cell()\n return rnn.bidirectional_rnn(cell_fw, cell_bw, word_embeddings,\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw)\n else:\n cell, initial_state = get_cell()\n return rnn.rnn(cell, word_embeddings, initial_state=initial_state)","def _propagate(dim_indices, conf, cells, c_prev, m_prev, new_output, new_state,\n first_call):\n if len(dim_indices) == 0:\n return\n\n # Because of the way RNNCells are implemented, we take the last dimension\n # (H_{N-1}) out and feed it as the state of the RNN cell\n # (in `last_dim_output`).\n # The input of the cell (H_0 to H_{N-2}) are concatenated into `cell_inputs`\n if conf.num_dims > 1:\n ls_cell_inputs = [None] * (conf.num_dims - 1)\n for d in conf.dims[:-1]:\n if new_output[d.idx] is None:\n ls_cell_inputs[d.idx] = m_prev[d.idx]\n else:\n ls_cell_inputs[d.idx] = new_output[d.idx]\n cell_inputs = array_ops.concat(ls_cell_inputs, 1)\n else:\n cell_inputs = array_ops.zeros([m_prev[0].get_shape().as_list()[0], 0],\n m_prev[0].dtype)\n\n last_dim_output = (new_output[-1]\n if new_output[-1] is not None else m_prev[-1])\n\n for i in dim_indices:\n d = conf.dims[i]\n if d.non_recurrent_fn:\n if conf.num_dims > 1:\n linear_args = array_ops.concat([cell_inputs, last_dim_output], 1)\n else:\n linear_args = last_dim_output\n with vs.variable_scope('non_recurrent' if conf.tied else\n 'non_recurrent/cell_{}'.format(i)):\n if conf.tied and not (first_call and i == dim_indices[0]):\n vs.get_variable_scope().reuse_variables()\n\n new_output[d.idx] = layers.fully_connected(\n linear_args,\n num_outputs=conf.num_units,\n activation_fn=d.non_recurrent_fn,\n weights_initializer=(vs.get_variable_scope().initializer or\n layers.initializers.xavier_initializer),\n weights_regularizer=vs.get_variable_scope().regularizer)\n else:\n if c_prev[i] is not None:\n cell_state = (c_prev[i], last_dim_output)\n else:\n # for GRU/RNN, the state is just the previous output\n cell_state = last_dim_output\n\n with vs.variable_scope('recurrent' if conf.tied else\n 'recurrent/cell_{}'.format(i)):\n if conf.tied and not (first_call and i == dim_indices[0]):\n vs.get_variable_scope().reuse_variables()\n cell = cells[i]\n new_output[d.idx], new_state[d.idx] = cell(cell_inputs, cell_state)","def get_cell(self, hidden_size, layer_num=1, dropout_keep_prob=None):\n cells = []\n for i in range(layer_num):\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\n if dropout_keep_prob is not None:\n cell = tc.rnn.DropoutWrapper(cell,\n input_keep_prob=dropout_keep_prob,\n output_keep_prob=dropout_keep_prob)\n cells.append(cell)\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\n return cells","def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\n #====================================================================================#\n # ----------PROBLEM 2----------\n #====================================================================================#\n # YOUR CODE HERE\n # raise NotImplementedError\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\n ## step 1 - inputs are first embedded by an MLP\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\n # print(\"after build_mlp x = \", x)\n ## step 2 - passed to a GRU cell\n # as \"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\"hidden\", dtype=tf.float32)\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\n # after build_mlp x = Tensor(\"continuous_logits/continuous_logits/fc1/BiasAdd:0\", shape=(?, 1, 32), dtype=float32)\n # x = tf.squeeze(x, axis=1)\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\n # print(\"dynamic_rnn build_mlp x = \", x, \" h = \", h)\n return x, h","def custom_dynamic_rnn(cell, inputs, inputs_len, initial_state=None):\n batch_size = tf.shape(inputs)[0]\n max_time = tf.shape(inputs)[1]\n\n inputs_ta = tf.TensorArray(dtype=tf.float32, size=max_time)\n inputs_ta = inputs_ta.unstack(tf.transpose(inputs, [1, 0, 2]))\n emit_ta = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0)\n t0 = tf.constant(0, dtype=tf.int32)\n if initial_state is not None:\n s0 = initial_state\n else:\n s0 = cell.zero_state(batch_size, dtype=tf.float32)\n f0 = tf.zeros([batch_size], dtype=tf.bool)\n\n def loop_fn(t, prev_s, emit_ta, finished):\n \"\"\"\n the loop function of rnn\n \"\"\"\n cur_x = inputs_ta.read(t)\n scores, cur_state = cell(cur_x, prev_s)\n\n # copy through\n scores = tf.where(finished, tf.zeros_like(scores), scores)\n\n if isinstance(cell, tc.rnn.LSTMCell):\n cur_c, cur_h = cur_state\n prev_c, prev_h = prev_s\n cur_state = tc.rnn.LSTMStateTuple(tf.where(finished, prev_c, cur_c),\n tf.where(finished, prev_h, cur_h))\n else:\n cur_state = tf.where(finished, prev_s, cur_state)\n\n emit_ta = emit_ta.write(t, scores)\n finished = tf.greater_equal(t + 1, inputs_len)\n return [t + 1, cur_state, emit_ta, finished]\n\n _, state, emit_ta, _ = tf.while_loop(\n cond=lambda _1, _2, _3, finished: tf.logical_not(\n tf.reduce_all(finished)),\n body=loop_fn,\n loop_vars=(t0, s0, emit_ta, f0),\n parallel_iterations=32,\n swap_memory=False)\n\n outputs = tf.transpose(emit_ta.stack(), [1, 0, 2])\n return outputs, state","def _rnn_relu_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):\n if b_ih is None:\n igates = P.MatMul(False, True)(inputs, w_ih)\n hgates = P.MatMul(False, True)(hidden, w_hh)\n else:\n igates = P.MatMul(False, True)(inputs, w_ih) + b_ih\n hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh\n return P.ReLU()(igates + hgates)","def single_cell(\n cell_class,\n cell_params,\n dp_input_keep_prob=1.0,\n dp_output_keep_prob=1.0,\n recurrent_keep_prob=1.0,\n input_weight_keep_prob=1.0,\n recurrent_weight_keep_prob=1.0,\n weight_variational=False,\n dropout_seed=None,\n zoneout_prob=0.,\n training=True,\n residual_connections=False,\n awd_initializer=False,\n variational_recurrent=False, # in case they want to use DropoutWrapper\n dtype=None,\n):\n if awd_initializer:\n val = 1.0/math.sqrt(cell_params['num_units'])\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\n if recurrent_keep_prob < 1.0:\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\n if input_weight_keep_prob < 1.0:\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\n if recurrent_weight_keep_prob < 1.0:\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\n if weight_variational:\n cell_params['weight_variational'] = weight_variational # which is basically True\n if dropout_seed:\n cell_params['dropout_seed'] = dropout_seed\n\n\n cell = cell_class(**cell_params)\n if residual_connections:\n cell = ResidualWrapper(cell)\n if zoneout_prob > 0. and (\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\n ):\n raise ValueError(\n \"Currently applying both dropout and zoneout on the same cell.\"\n \"This is currently not supported.\"\n )\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\n cell = DropoutWrapper(\n cell,\n input_keep_prob=dp_input_keep_prob,\n output_keep_prob=dp_output_keep_prob,\n variational_recurrent=variational_recurrent,\n dtype=dtype,\n seed=dropout_seed\n )\n if zoneout_prob > 0.:\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\n return cell","def convert_rnn(g, op, block):\n\n def generate_lstm(\n input_seqs,\n hidden_state,\n cell_state,\n w_inp,\n w_hid,\n b_inp,\n b_hid,\n f_act,\n g_act,\n h_act,\n backwards=False,\n ):\n \"\"\"Implementation of LSTM cell for paddlepaddle of TVM\"\"\"\n\n h_list = []\n seq_length = len(input_seqs)\n for i in range(seq_length):\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\n step = _op.squeeze(step, axis=[0])\n gates = _op.nn.dense(step, w_inp) + _op.nn.dense(hidden_state, w_hid)\n if b_inp is not None:\n gates += b_inp\n if b_hid is not None:\n gates += b_hid\n i, f, c, o = _op.split(gates, 4, axis=-1)\n\n i = f_act(i)\n f = f_act(f)\n\n c = g_act(c)\n C = f * cell_state + i * c\n\n o = f_act(o)\n\n H = o * h_act(C)\n\n hidden_state = H\n cell_state = C\n h_list.append(_op.expand_dims(H, axis=0))\n\n if backwards:\n h_list = h_list[::-1]\n\n # Concatenate outputs and add back in direction axis.\n concatenated = _op.concatenate(h_list, 0)\n output = _op.expand_dims(concatenated, axis=1)\n hidden_state = _op.expand_dims(hidden_state, axis=0)\n cell_state = _op.expand_dims(cell_state, axis=0)\n\n return output, hidden_state, cell_state\n\n def generate_gru(\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, rz_act, n_act, backwards=False\n ):\n \"\"\"Implementation of GRU cell for paddlepaddle of TVM\"\"\"\n\n h_list = []\n seq_length = len(input_seqs)\n for i in range(seq_length):\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\n step = _op.squeeze(step, axis=[0])\n xwt = _op.nn.dense(step, w_inp)\n hwt = _op.nn.dense(hidden_state, w_hid)\n if b_inp is not None:\n xwt += b_inp\n if b_hid is not None:\n hwt += b_hid\n i_r, i_z, i_n = _op.split(xwt, 3, axis=-1)\n h_r, h_z, h_n = _op.split(hwt, 3, axis=-1)\n\n r_gate = rz_act(i_r + h_r)\n z_gate = rz_act(i_z + h_z)\n n_gate = n_act(i_n + r_gate * h_n)\n\n hidden_state = (hidden_state - n_gate) * z_gate + n_gate\n h_list.append(_op.expand_dims(hidden_state, axis=0))\n\n if backwards:\n h_list = h_list[::-1]\n\n # Concatenate outputs and add back in direction axis.\n concatenated = _op.concatenate(h_list, 0)\n output = _op.expand_dims(concatenated, axis=1)\n hidden_state = _op.expand_dims(hidden_state, axis=0)\n\n return output, hidden_state\n\n def generate_simplernn(\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, n_act, backwards=False\n ):\n \"\"\"Implementation of SimpleRNN cell for paddlepaddle of TVM\"\"\"\n\n h_list = []\n seq_length = len(input_seqs)\n for i in range(seq_length):\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\n step = _op.squeeze(step, axis=[0])\n xwt = _op.nn.dense(step, w_inp)\n hwt = _op.nn.dense(hidden_state, w_hid)\n if b_inp is not None:\n xwt += b_inp\n if b_hid is not None:\n hwt += b_hid\n\n n_gate = n_act(xwt + hwt)\n\n hidden_state = n_gate\n h_list.append(_op.expand_dims(hidden_state, axis=0))\n\n if backwards:\n h_list = h_list[::-1]\n\n # Concatenate outputs and add back in direction axis.\n concatenated = _op.concatenate(h_list, 0)\n output = _op.expand_dims(concatenated, axis=1)\n hidden_state = _op.expand_dims(hidden_state, axis=0)\n\n return output, hidden_state\n\n def make_param_inputs(g, node, layer, hidden_size, num_layers):\n \"\"\"Param for weight and bias.\"\"\"\n\n bidirect_len = 4 if node.attr(\"is_bidirec\") else 2\n all_layer_param_len = len(node.input(\"WeightList\"))\n weight_list = node.input(\"WeightList\")[: all_layer_param_len // 2]\n bias_list = node.input(\"WeightList\")[all_layer_param_len // 2 :]\n\n layer_weight_list = weight_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\n layer_bias_list = bias_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\n param_list = layer_weight_list + layer_bias_list\n param_list_len = len(param_list)\n\n input_weights = param_list[0 : param_list_len // 2 : 2]\n hidden_weights = param_list[1 : param_list_len // 2 : 2]\n\n input_bias = param_list[param_list_len // 2 : param_list_len : 2]\n hidden_bias = param_list[param_list_len // 2 + 1 : param_list_len : 2]\n\n return input_weights, hidden_weights, input_bias, hidden_bias\n\n def make_init_param_inputs(g, node, layer):\n \"\"\"Init param for inputs.\"\"\"\n\n mode = node.attr(\"mode\")\n if mode == \"LSTM\":\n all_init_h, all_init_c = node.input(\"PreState\")\n bidirect_len = 2 if node.attr(\"is_bidirec\") else 1\n init_h = _op.strided_slice(\n g.get_node(all_init_h),\n [layer * bidirect_len],\n [layer * bidirect_len + bidirect_len],\n axes=[0],\n )\n init_c = _op.strided_slice(\n g.get_node(all_init_c),\n [layer * bidirect_len],\n [layer * bidirect_len + bidirect_len],\n axes=[0],\n )\n return init_h, init_c\n all_init_h = node.input(\"PreState\")[0]\n bidirect_len = 2 if node.attr(\"is_bidirec\") else 1\n init_h = _op.strided_slice(\n g.get_node(all_init_h),\n [layer * bidirect_len],\n [layer * bidirect_len + bidirect_len],\n axes=[0],\n )\n return init_h\n\n hidden_size = op.attr(\"hidden_size\")\n num_layers = op.attr(\"num_layers\")\n is_bidirec = op.attr(\"is_bidirec\")\n mode = op.attr(\"mode\")\n\n input_x = g.get_node(op.input(\"Input\")[0])\n\n num_directions = 1\n if is_bidirec:\n num_directions = 2\n\n x_shape = infer_shape(input_x)\n time_steps = x_shape[0]\n x_steps = _op.split(input_x, indices_or_sections=time_steps, axis=0)\n for layer in range(num_layers):\n input_weights, hidden_weights, input_bias, hidden_bias = make_param_inputs(\n g, op, layer, hidden_size, num_layers\n )\n if mode == \"LSTM\":\n init_h, init_c = make_init_param_inputs(g, op, layer)\n init_hs = _op.split(init_h, num_directions)\n init_cs = _op.split(init_c, num_directions)\n result_output = []\n result_H = []\n result_C = []\n for i in range(num_directions):\n H_t = _op.squeeze(init_hs[i], axis=[0])\n C_t = _op.squeeze(init_cs[i], axis=[0])\n W = g.get_node(input_weights[i])\n R = g.get_node(hidden_weights[i])\n WB = g.get_node(input_bias[i])\n RB = g.get_node(hidden_bias[i])\n output, H, C = generate_lstm(\n input_seqs=x_steps,\n hidden_state=H_t,\n cell_state=C_t,\n w_inp=W,\n w_hid=R,\n b_inp=WB,\n b_hid=RB,\n f_act=_op.sigmoid,\n g_act=_op.tanh,\n h_act=_op.tanh,\n backwards=i == 1,\n )\n result_output.append(output)\n result_H.append(H)\n result_C.append(C)\n output = _op.concatenate(result_output, axis=1)\n H = _op.concatenate(result_H, axis=0)\n C = _op.concatenate(result_C, axis=0)\n elif mode == \"GRU\":\n init_h = make_init_param_inputs(g, op, layer)\n init_hs = _op.split(init_h, num_directions)\n result_output = []\n result_H = []\n for i in range(num_directions):\n H_t = _op.squeeze(init_hs[i], axis=[0])\n W = g.get_node(input_weights[i])\n R = g.get_node(hidden_weights[i])\n WB = g.get_node(input_bias[i])\n RB = g.get_node(hidden_bias[i])\n output, H = generate_gru(\n input_seqs=x_steps,\n hidden_state=H_t,\n w_inp=W,\n w_hid=R,\n b_inp=WB,\n b_hid=RB,\n rz_act=_op.sigmoid,\n n_act=_op.tanh,\n backwards=i == 1,\n )\n result_output.append(output)\n result_H.append(H)\n output = _op.concatenate(result_output, axis=1)\n H = _op.concatenate(result_H, axis=0)\n elif mode == \"RNN_TANH\":\n init_h = make_init_param_inputs(g, op, layer)\n init_hs = _op.split(init_h, num_directions)\n result_output = []\n result_H = []\n for i in range(num_directions):\n H_t = _op.squeeze(init_hs[i], axis=[0])\n W = g.get_node(input_weights[i])\n R = g.get_node(hidden_weights[i])\n WB = g.get_node(input_bias[i])\n RB = g.get_node(hidden_bias[i])\n output, H = generate_simplernn(\n input_seqs=x_steps,\n hidden_state=H_t,\n w_inp=W,\n w_hid=R,\n b_inp=WB,\n b_hid=RB,\n n_act=_op.tanh,\n backwards=i == 1,\n )\n result_output.append(output)\n result_H.append(H)\n output = _op.concatenate(result_output, axis=1)\n H = _op.concatenate(result_H, axis=0)\n\n output = _op.transpose(output, axes=[0, 2, 1, 3])\n output = _op.reshape(output, newshape=(0, 0, -1))\n x_steps = _op.split(output, indices_or_sections=time_steps, axis=0)\n\n g.add_node(op.output(\"Out\")[0], output)","def __init__(self,\n num_units,\n num_dims=1,\n input_dims=None,\n output_dims=None,\n priority_dims=None,\n non_recurrent_dims=None,\n tied=False,\n cell_fn=None,\n non_recurrent_fn=None,\n state_is_tuple=True,\n output_is_tuple=True):\n if not state_is_tuple:\n logging.warning('%s: Using a concatenated state is slower and will '\n 'soon be deprecated. Use state_is_tuple=True.', self)\n if not output_is_tuple:\n logging.warning('%s: Using a concatenated output is slower and will '\n 'soon be deprecated. Use output_is_tuple=True.', self)\n\n if num_dims < 1:\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\n\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\n priority_dims, non_recurrent_dims,\n non_recurrent_fn or nn.relu, tied,\n num_units)\n\n self._state_is_tuple = state_is_tuple\n self._output_is_tuple = output_is_tuple\n\n if cell_fn is None:\n my_cell_fn = functools.partial(\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\n else:\n my_cell_fn = lambda: cell_fn(num_units)\n if tied:\n self._cells = [my_cell_fn()] * num_dims\n else:\n self._cells = [my_cell_fn() for _ in range(num_dims)]\n if not isinstance(self._cells[0], rnn.RNNCell):\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\n type(self._cells[0]))\n\n if self._output_is_tuple:\n self._output_size = tuple(self._cells[0].output_size\n for _ in self._config.outputs)\n else:\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\n\n if self._state_is_tuple:\n self._state_size = tuple(self._cells[0].state_size\n for _ in self._config.recurrents)\n else:\n self._state_size = self._cell_state_size() * len(self._config.recurrents)","def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\n is_training=False, cell_name=\"GRU\", bidirectional=False, swap_memory=False):\n batch_size = tf.shape(X)[0]\n if bidirectional:\n rnn_size /= 2\n\n def get_cell():\n if cell_name == \"GRU\": # GRU\n _cell = rnn_cell.GRUCell(rnn_size)\n elif cell_name == \"LSTM\": # LSTM\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\n else:\n raise ValueError(\"Unrecognized Cell Name: {0}\".format(cell_name))\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\n _initial_state = _cell.zero_state(batch_size, tf.float32)\n return _cell, _initial_state\n\n if bidirectional:\n with tf.variable_scope(\"forward\"):\n cell_fw, initial_state_fw = get_cell()\n with tf.variable_scope(\"backward\"):\n cell_bw, initial_state_bw = get_cell()\n return rnn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, X, sequence_length=seq_len,\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\n else:\n cell, initial_state = get_cell()\n return rnn.dynamic_rnn(\n cell, X, sequence_length=seq_len, initial_state=initial_state,\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)","def build_rnn_greedy(self):\n print(\"Building the RNN part...\")\n params = self.params\n\n contexts = self.conv_feats\n\n sentences = tf.placeholder(tf.int32, [self.batch_size, self.max_sent_len])\n masks = tf.placeholder(tf.float32, [self.batch_size, self.max_sent_len]) \n weights = tf.placeholder(tf.float32, [self.batch_size, self.max_sent_len]) \n\n # initialize the word embedding\n idx2vec = np.array([self.word_table.word2vec[self.word_table.idx2word[i]] \n for i in range(self.num_words)])\n emb_w = weight('emb_weights', [self.num_words, self.dim_embed], init_val=idx2vec)\n\n # initialize the decoding layer\n dec_w = weight('dec_weights', [self.dim_dec, self.num_words]) \n if self.init_dec_bias: \n dec_b = bias('dec_biases', [self.num_words], init_val=self.word_table.word_freq)\n else:\n dec_b = bias('dec_biases', [self.num_words], init_val=0.0)\n \n # compute the mean context\n context_mean = tf.reduce_mean(contexts, 1)\n \n # initialize the LSTM\n lstm = tf.nn.rnn_cell.LSTMCell(self.dim_hidden, initializer=tf.random_normal_initializer(stddev=0.033)) \n lstm = tf.nn.rnn_cell.DropoutWrapper(lstm, self.lstm_keep_prob, self.lstm_keep_prob, self.lstm_keep_prob)\n\n memory, output = self.init_lstm(context_mean)\n state = memory, output\n\n cross_entropy_loss = 0.0\n results = []\n scores = []\n\n alphas = [] \n cross_entropies = []\n num_correct_words = 0.0\n\n # Generate the words one by one \n for idx in range(self.max_sent_len):\n\n # Attention mechanism\n alpha = self.attend(contexts, output) \n \n masked_alpha = alpha * tf.tile(tf.expand_dims(masks[:, idx], 1), [1, self.num_ctx]) \n alphas.append(tf.reshape(masked_alpha, [-1])) \n\n if idx == 0: \n word_emb = tf.zeros([self.batch_size, self.dim_embed])\n weighted_context = tf.identity(context_mean)\n else:\n word_emb = tf.cond(self.is_train, \n lambda: tf.nn.embedding_lookup(emb_w, sentences[:, idx-1]), \n lambda: word_emb)\n weighted_context = tf.reduce_sum(contexts * tf.expand_dims(alpha, 2), 1)\n \n # Apply the LSTM\n with tf.variable_scope(\"LSTM\"):\n output, state = lstm(tf.concat([weighted_context, word_emb], 1), state)\n \n # Compute the logits\n expanded_output = tf.concat([output, weighted_context, word_emb], 1)\n\n logits1 = fully_connected(expanded_output, self.dim_dec, 'dec_fc')\n logits1 = nonlinear(logits1, 'tanh')\n logits1 = dropout(logits1, self.fc_keep_prob, self.is_train)\n\n logits2 = tf.nn.xw_plus_b(logits1, dec_w, dec_b)\n\n # Update the loss\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=sentences[:, idx], \n logits=logits2)\n masked_cross_entropy = cross_entropy * masks[:, idx]\n cross_entropy_loss += tf.reduce_sum(masked_cross_entropy*weights[:, idx])\n cross_entropies.append(masked_cross_entropy)\n\n # Update the result\n max_prob_word = tf.argmax(logits2, 1)\n results.append(max_prob_word)\n\n is_word_correct = tf.where(tf.equal(max_prob_word, tf.cast(sentences[:, idx], tf.int64)), \n tf.cast(masks[:, idx], tf.float32), \n tf.cast(tf.zeros_like(max_prob_word), tf.float32))\n num_correct_words += tf.reduce_sum(is_word_correct) \n\n probs = tf.nn.softmax(logits2) \n score = tf.log(tf.reduce_max(probs, 1)) \n scores.append(score) \n \n # Prepare for the next iteration\n word_emb = tf.cond(self.is_train, lambda: word_emb, lambda: tf.nn.embedding_lookup(emb_w, max_prob_word)) \n tf.get_variable_scope().reuse_variables() \n\n # Get the final result\n results = tf.stack(results, axis=1)\n scores = tf.stack(scores, axis=1)\n\n alphas = tf.stack(alphas, axis=1)\n alphas = tf.reshape(alphas, [self.batch_size, self.num_ctx, -1])\n sum_alpha = tf.reduce_sum(alphas, axis=2)\n\n cross_entropies = tf.stack(cross_entropies, axis=1) \n num_correct_words = num_correct_words / tf.reduce_sum(masks)\n\n # Compute the final loss \n cross_entropy_loss = cross_entropy_loss / tf.reduce_sum(masks*weights)\n\n avg_alpha = tf.reduce_sum(masks, axis=1) / self.num_ctx\n small_alpha_diff = tf.nn.relu(tf.tile(tf.expand_dims(avg_alpha*0.6, 1), [1, self.num_ctx])-sum_alpha)\n large_alpha_diff = tf.nn.relu(sum_alpha-tf.tile(tf.expand_dims(avg_alpha*6, 1), [1, self.num_ctx]))\n attention_loss = tf.nn.l2_loss(small_alpha_diff) + tf.nn.l2_loss(large_alpha_diff) \n attention_loss = params.att_coeff * attention_loss / self.batch_size \n\n if self.train_cnn:\n g_vars = tf.trainable_variables()\n else:\n g_vars = [tf_var for tf_var in tf.trainable_variables() if \"CNN\" not in tf_var.name]\n\n l2_loss = params.weight_decay * sum(tf.nn.l2_loss(tf_var) for tf_var in g_vars \n if (\"bias\" not in tf_var.name and\n \"offset\" not in tf_var.name and \n \"scale\" not in tf_var.name)) \n\n loss = cross_entropy_loss + attention_loss + l2_loss\n\n # Build the solver \n with tf.variable_scope(\"Solver\", reuse=tf.AUTO_REUSE):\n learning_rate = tf.train.exponential_decay(params.learning_rate, \n self.global_step,\n 10000, \n 0.9, \n staircase=True)\n\n if params.solver==\"momentum\":\n solver = tf.train.MomentumOptimizer(learning_rate, params.momentum)\n elif params.solver==\"rmsprop\":\n solver = tf.train.RMSPropOptimizer(learning_rate, params.decay, params.momentum)\n else:\n solver = tf.train.GradientDescentOptimizer(learning_rate)\n\n gs = tf.gradients(loss, g_vars)\n gs, _ = tf.clip_by_global_norm(gs, 10.0)\n opt_op = solver.apply_gradients(zip(gs, g_vars), global_step=self.global_step)\n\n self.sentences = sentences\n self.masks = masks\n self.weights = weights\n\n self.results = results\n self.scores = scores\n self.alphas = alphas\n\n self.sum_alpha = sum_alpha\n self.cross_entropies = cross_entropies\n self.num_correct_words = num_correct_words\n\n self.loss = loss\n self.cross_entropy_loss = cross_entropy_loss\n self.attention_loss = attention_loss\n self.l2_loss = l2_loss\n\n self.opt_op = opt_op\n self.g_vars = g_vars\n self.gs = gs\n \n print(\"RNN part built.\")","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(RCRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = ResidualCNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=2,\n )\n #self.rnn2 = BidirectionalGRU(\n # n_in=nb_in*2,\n # n_hidden=n_RNN_cell,\n # dropout=dropout_recurrent,\n # num_layers=1,\n #)\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.relu = nn.ReLU()\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def tile_representations(self, reps):\n if len(reps.shape) == 3:\n reps = reps.unsqueeze(0)\n elif len(reps.shape) != 4:\n raise ValueError('Input argument `reps` has invalid shape: {}'.format(reps.shape))\n\n tiled_reps = reps.repeat(1, 1, 1, self.dr)\n tiled_reps = tiled_reps.reshape(reps.size(0), reps.size(1), reps.size(2)*self.dr, reps.size(3))\n\n # return the only layer if only one layer is given at input\n # else return representations of all layers\n if len(tiled_reps) == 1:\n return tiled_reps.squeeze(0) # (batch_size, sequence_length * downsample_rate, hidden_size)\n return tiled_reps # (num_hidden_layers, batch_size, sequence_length * downsample_rate, hidden_size)","def rnn_with_embedding(self,cell,init_state,input_seq,\n input_seq_len,reuse=None,\n scope=\"RNN\"): \n with tf.variable_scope(scope,reuse=reuse) as vs:\n log(vs.name+\"/Encoding sequences\")\n with tf.device('/cpu:0'):\n emb = tf.get_variable(\"emb\",\n [self.vocab_size,self.hidden_size],\n dtype=tf.float32)\n un_emb = tf.get_variable(\"unemb\",\n [self.hidden_size,self.vocab_size],\n tf.float32)\n # We need a bias\n un_emb_b = tf.get_variable(\"unemb_b\",\n [self.vocab_size],\n dtype=tf.float32)\n \n assert scope+\"/emb:0\" in emb.name,\\\n \"Making sure the reusing is working\"\n emb_input_seq = tf.nn.embedding_lookup(\n emb,input_seq)\n emb_input_list = tf.unpack(\n tf.transpose(emb_input_seq,[1,0,2]))\n \n # RNN pass\n if init_state is None:\n init_state = cell.zero_state(\n tf.shape(emb_input_list[0])[0],tf.float32)\n \n emb_output_list, final_state = tf.nn.rnn(\n cell,emb_input_list,initial_state=init_state,\n sequence_length=input_seq_len)\n\n # We shift the predicted outputs, because at\n # each word we're trying to predict the next.\n emb_output_list = emb_output_list[:-1]\n \n # Unembedding\n output_list = [tf.matmul(t,un_emb) + un_emb_b\n for t in emb_output_list]\n outputs = tf.transpose(tf.pack(output_list),[1,0,2])\n\n return outputs, final_state","def collate(self, batch):\n \n images = []\n indices = []\n roi_size = 5 if self.Train else 4\n rois = torch.zeros((len(batch), 20, roi_size), dtype=torch.float32)\n rois = rois.to(batch[0][1].device)\n \n for _b in range(len(batch)):\n # Accumulate patches:\n images.append(batch[_b][0].to(torch.float32))\n indices.append(batch[_b][2])\n \n # Accumulate ROI:\n \"\"\"\n image_num = torch.Tensor([_b]).expand(batch[_b][1].size(0))\n image_num = image_num.type(batch[_b][1].dtype).view(-1,1)\n image_num = image_num.to(batch[_b][1].device)\n _roi = torch.cat([image_num, batch[_b][1]], dim=1)\n rois = torch.cat([rois, _roi], dim=0)\n \"\"\"\n num_boxes = batch[_b][1].size(0)\n rois[_b,:num_boxes,:] = batch[_b][1]\n \n \n # Stack outputs and return\n batch = [torch.stack(images, dim=0), rois, torch.Tensor(indices)]\n return batch","def unroll_cell(self, decoder_inputs, initial_state, loop_function, cell):\n return tf.contrib.legacy_seq2seq.rnn_decoder(\n decoder_inputs=decoder_inputs,\n initial_state=initial_state,\n cell=cell,\n loop_function=self.get_input)","def __call__(self, inputs, state, scope=None, debug=False):\n # B is batch size.\n\n # 1) Use read_ind to find memory location to read from\n # as input.\n\n # inputs.read_ind: (B, 1)\n # memory: (B, mem_size, embed_size)\n read_ind = tf.to_int32(inputs.read_ind)\n batch_size = tf.shape(read_ind)[0]\n if debug:\n print('batch size is', batch_size)\n print('read ind is', read_ind)\n mem_ind = tf.range(batch_size)\n\n # read_mem_ind: (B, 1)\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\n # read_ind: (B, 2)\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\n if debug:\n print('processed read ind is', read_ind)\n\n # inner_inputs: (B, embed_size)\n inner_inputs = tf.gather_nd(state.memory, read_ind)\n if debug:\n print('inner_inputs is', inner_inputs)\n\n inner_state = state.inner_state\n\n # 2) Run the inner RNNCell.\n \n # inner_outputs: (B, embed_size)\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\n\n if debug:\n print('inner_outputs is', inner_outputs)\n\n # 3) Compute logits for valid indices (using logit_masks\n # to mask out padded valid indices (-1)).\n \n # valid_indices: (B, max_n_valid_indices)\n valid_indices = tf.to_int32(inputs.valid_indices)\n if debug:\n print('valid_indices is', valid_indices)\n \n # Logit mask: (B, max_n_valid_indices)\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\n logit_masks = tf.cast(logit_masks, tf.float32)\n\n if debug:\n print('logit_masks is', logit_masks)\n\n # Normalize indices to be at least 0.\n valid_indices = tf.maximum(valid_indices, 0)\n\n # valid_indices: (B, max_n_valid_indices, 1)\n valid_indices = tf.expand_dims(valid_indices, -1)\n if debug:\n print('valid_indices is', valid_indices)\n print('mem_ind is', mem_ind)\n\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # valid_mem_ind: (B, 1, 1)\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\n if debug:\n print('valid_mem_ind is', valid_mem_ind)\n\n # valid_mem_ind: (B, max_n_valid_indices, 1)\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\n\n # valid_indices: (B, max_n_valid_indices, 2)\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\n # index into the right memory location.\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\n\n if debug:\n print('valid_indices is', valid_indices)\n\n # select all the valid slots. \n # valid_values: (B, max_n_valid_indices, embed_size)\n valid_values = tf.gather_nd(state.memory, valid_indices)\n if debug:\n print('valid_values is', valid_values)\n \n # expanded_inner_outputs: (B, 1, embed_size)\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\n if debug:\n print('expanded_inner_outputs is', expanded_inner_outputs)\n\n # valid_values: (B, embed_size, max_n_valid_indices)\n valid_values = tf.transpose(valid_values, [0, 2, 1])\n if debug:\n print('valid_values is', valid_values)\n\n # logits: (B, 1, max_n_valid_indices)\n logits = tf.matmul(expanded_inner_outputs, valid_values)\n \n if debug:\n print('logits is', logits)\n\n # logits: (B, max_n_valid_indices)\n logits = tf.squeeze(logits, axis=[1])\n if debug:\n print('logits is', logits)\n\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\n\n outputs = masked_logits\n # 4) Write the output of the inner RNN to a memory\n # location (write_ind), using write_masks to mask out\n # padded write_ind (-1).\n \n # write_ind: (B, 1)\n write_ind = tf.cast(inputs.write_ind, tf.int32)\n if debug:\n print('write_ind is', write_ind)\n\n # write mask: (B, 1)\n write_masks = tf.greater_equal(inputs.write_ind, 0)\n if debug:\n print('write_masks greater_equal', write_masks)\n\n write_masks = tf.cast(write_masks, tf.float32)\n\n # write mask: (B, 1, 1)\n write_masks = tf.expand_dims(write_masks, [-1])\n\n if debug:\n print('write_masks is', write_masks)\n\n # Normalize write_ind to be above 0.\n # write_ind: (B, 1)\n write_ind = tf.maximum(write_ind, 0)\n\n # write_mem_ind: (B, 1)\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\n\n # write_ind: (B, 2)\n # Second dimension is [b_i, write_index]\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\n if debug:\n print('write_ind is', write_ind)\n\n if debug:\n print('masked_logits is', masked_logits)\n print('memory is', state.memory)\n\n # write_mat: (B, mem_size, embed_size)\n write_mat = tf.scatter_nd(\n write_ind, inner_outputs, shape=tf.shape(state.memory))\n\n if debug:\n print('@' * 50)\n print('write_mat is', write_mat)\n print('write_mask is', write_masks)\n print('@' * 50)\n\n masked_write_mat = write_mat * write_masks\n new_memory = state.memory + masked_write_mat\n \n state = MemoryStateTuple(new_memory, new_inner_state)\n if debug:\n print('state is', state)\n \n return (outputs, state)","def LSTMCellWeightsShape(num_inputs, num_nodes):\n # Dimension 0 accounts for combining x with the previous m state.\n # Dimension 1 accounts for the in value and the (in, forget, out) gates.\n return [num_inputs + num_nodes, 4 * num_nodes]","def convert_rnn_param_concat(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n axis = int(attrs.get(\"dim\"))\n\n # mxnet RNN node and ONNX RNN/LSTM/GRU nodes\n # use different ways to store their parameters\n\n # The conversion between these formats is broken into 2 steps\n # The first step (performed here in _rnn_param_concat) regroups the\n # flattened parameters according to the table below.\n # The second step corrects the shapes and orders of gates and is\n # performed and described in more detail in the RNN node\n\n # mxnet [ONNX] -> ONNX (group)\n # i2h_weights [W (+ WB)] -> W (input weights)\n # h2h_weights [R (+ RB)] -> R (recurrence weights)\n # i2h_biases [Wb (+ WBb)] -> B = [Wb + Rb (+ WBb + RBb)]\n # h2h_biases [Rb (+ RBb)] -> (biases)\n\n split = len(input_nodes) // 2\n weights, biases = input_nodes[:split], input_nodes[split:]\n i2h_weights = weights[::2]\n h2h_weights = weights[1::2]\n i2h_biases = biases[::2]\n h2h_biases = biases[1::2]\n reordered_biases = [\n bias\n for pair in zip(i2h_biases, h2h_biases)\n for bias in pair\n ]\n\n # The order of mxnet parameters in the inputs is:\n # [\n # '{}{}_{}_{}'.format(d, l, g, t)\n # for t in ['weight', 'bias']\n # for l in range(num_layers)\n # for d in ['l', 'r'][:num_directions]\n # for g in ['i2h', 'h2h']\n # ]\n\n w = onnx.helper.make_node(\n \"Concat\",\n inputs=i2h_weights,\n outputs=[name + \"__W\"],\n axis=axis,\n name=name + \"__W\"\n )\n r = onnx.helper.make_node(\n \"Concat\",\n inputs=h2h_weights,\n outputs=[name + \"__R\"],\n axis=axis,\n name=name + \"__R\"\n )\n b = onnx.helper.make_node(\n \"Concat\",\n inputs=reordered_biases,\n outputs=[name + \"__B\"],\n axis=axis,\n name=name + \"__B\"\n )\n return [w, r, b]","def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\n freeze_bn=False,\n **kwargs,\n ):\n super(CRNN, self).__init__()\n self.n_in_channel = n_in_channel\n self.attention = attention\n self.cnn_integration = cnn_integration\n self.freeze_bn = freeze_bn\n\n n_in_cnn = n_in_channel\n\n if cnn_integration:\n n_in_cnn = 1\n\n self.cnn = CNN(\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\n )\n\n self.train_cnn = train_cnn\n if not train_cnn:\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n if rnn_type == \"BGRU\":\n nb_in = self.cnn.nb_filters[-1]\n if self.cnn_integration:\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\n nb_in = nb_in * n_in_channel\n self.rnn = BidirectionalGRU(\n n_in=nb_in,\n n_hidden=n_RNN_cell,\n dropout=dropout_recurrent,\n num_layers=n_layers_RNN,\n )\n else:\n NotImplementedError(\"Only BGRU supported for CRNN for now\")\n\n self.dropout = nn.Dropout(dropout)\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\n self.sigmoid = nn.Sigmoid()\n\n if self.attention:\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\n self.softmax = nn.Softmax(dim=-1)","def test_learnable_cell(self):\n genotype = '0|0|2|0|0|2|0|0 1|0|0|1|1|0|0|0 0|1|0|0|0|0|2|1--1 7'\n search_space = {'dil_conv_3x3', 'dil_conv_5x5', 'dil_conv_7x7',\n 'skip_connect', 'clinc_3x3', 'clinc_7x7', 'avg_pool_3x3', 'max_pool_3x3'}\n\n net = LearnableCell(3, genotype, search_space)\n x = torch.rand((16, 3, 32, 32))\n y = net(x)\n self.assertEqual(list(y.shape), [16, 7, 15, 15])","def __init__(self, cell_index, stimulus_type, conv_layers=[(12, 9, 9), (12, 9, 9)], dense_layer=64,\n loss='poisson_loss', optimizer='adam', weight_init='normal', l2_reg=0., dropout=0.5, mean_adapt=False):\n\n self.stim_shape = (40, 50, 50)\n\n # build the model\n with notify('Building convnet'):\n\n self.model = Sequential()\n\n # convolutional layers\n for ix, layer in enumerate(conv_layers):\n\n # get parameters for this layer\n num_filters, row_size, col_size = layer\n\n # convolutional layer\n if ix == 0:\n self.model.add(Convolution2D(num_filters, row_size, col_size,\n input_shape=self.stim_shape, init=weight_init,\n border_mode='same', subsample=(1,1),\n W_regularizer=l2(l2_reg), activation='relu'))\n\n else:\n self.model.add(Convolution2D(num_filters, row_size, col_size,\n input_shape=self.stim_shape, init=weight_init,\n border_mode='same', subsample=(1,1),\n W_regularizer=l2(l2_reg), activation='relu'))\n\n # max pooling layer\n self.model.add(MaxPooling2D(pool_size=(2, 2), ignore_border=True))\n\n # dropout\n self.model.add(Dropout(dropout))\n\n # flatten\n self.model.add(Flatten())\n\n # Add dense (affine) layer with relu activation\n self.model.add(Dense(dense_layer, init=weight_init, W_regularizer=l2(l2_reg), activation='relu'))\n self.model.add(Dropout(dropout))\n\n # Add a final dense (affine) layer with softplus activation\n self.model.add(Dense(1, init=weight_init, W_regularizer=l2(l2_reg), activation='softplus'))\n\n # save architecture string (for markdown file)\n self.architecture = '\\n'.join(['Convolutional layers {}'.format(conv_layers),\n '{} filters in the second (fully connected) layer'.format(dense_layer),\n 'weight initialization: {}'.format(weight_init),\n 'l2 regularization: {}'.format(l2_reg),\n 'stimulus shape: {}'.format(self.stim_shape)])\n\n # compile\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)","def __call__(self, inputs, state, scope=None, *args, **kwargs):\r\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\r\n # Instead, it is up to subclasses to provide a proper build\r\n # method. See the class docstring for more details.\r\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\r\n *args, **kwargs)","def rnn_decoder_with_attention(decoder_inputs, initial_state, cell, loop_function,attention_states,scope=None):#3D Tensor [batch_size x attn_length x attn_size]\n with tf.variable_scope(scope or \"rnn_decoder\"):\n print(\"rnn_decoder_with_attention started...\")\n state = initial_state #[batch_size x cell.state_size].\n _, hidden_size = state.get_shape().as_list() #200\n attention_states_original=attention_states\n batch_size,sequence_length,_=attention_states.get_shape().as_list()\n outputs = []\n prev = None\n #################################################\n for i, inp in enumerate(decoder_inputs):#循环解码部分的输入。如sentence_length个[batch_size x input_size]\n # 如果是训练，使用训练数据的输入；如果是test, 将t时刻的输出作为t + 1 时刻的s输入\n if loop_function is not None and prev is not None:#测试的时候：如果loop_function不为空且前一个词的值不为空，那么使用前一个的值作为RNN的输入\n with tf.variable_scope(\"loop_function\", reuse=True):\n inp = loop_function(prev, i)\n if i > 0:\n tf.get_variable_scope().reuse_variables()\n ##ATTENTION#################################################################################################################################################\n # 1.get logits of attention for each encoder input. attention_states:[batch_size x attn_length x attn_size]; query=state:[batch_size x cell.state_size]\n query=state\n W_a = tf.get_variable(\"W_a\", shape=[hidden_size, hidden_size],initializer=tf.random_normal_initializer(stddev=0.1))\n query=tf.matmul(query, W_a) #[batch_size,hidden_size]\n query=tf.expand_dims(query,axis=1) #[batch_size, 1, hidden_size]\n U_a = tf.get_variable(\"U_a\", shape=[hidden_size, hidden_size],initializer=tf.random_normal_initializer(stddev=0.1))\n U_aa = tf.get_variable(\"U_aa\", shape=[ hidden_size])\n attention_states=tf.reshape(attention_states,shape=(-1,hidden_size)) #[batch_size*sentence_length,hidden_size]\n attention_states=tf.matmul(attention_states, U_a) #[batch_size*sentence_length,hidden_size]\n #print(\"batch_size\",batch_size,\" ;sequence_length:\",sequence_length,\" ;hidden_size:\",hidden_size) #print(\"attention_states:\", attention_states) #(?, 200)\n attention_states=tf.reshape(attention_states,shape=(-1,sequence_length,hidden_size)) # TODO [batch_size,sentence_length,hidden_size]\n #query_expanded: [batch_size,1, hidden_size]\n #attention_states_reshaped: [batch_size,sentence_length,hidden_size]\n attention_logits=tf.nn.tanh(query+attention_states+U_aa) #[batch_size,sentence_length,hidden_size]. additive style\n\n # 2.get possibility of attention\n attention_logits=tf.reshape(attention_logits,shape=(-1,hidden_size)) #batch_size*sequence_length [batch_size*sentence_length,hidden_size]\n V_a = tf.get_variable(\"V_a\", shape=[hidden_size,1],initializer=tf.random_normal_initializer(stddev=0.1)) #[hidden_size,1]\n attention_logits=tf.matmul(attention_logits,V_a) #最终需要的是[batch_size*sentence_length,1]<-----[batch_size*sentence_length,hidden_size],[hidden_size,1]\n attention_logits=tf.reshape(attention_logits,shape=(-1,sequence_length)) #attention_logits:[batch_size,sequence_length]\n ##########################################################################################################################################################\n #attention_logits=tf.reduce_sum(attention_logits,2) #[batch_size x attn_length]\n attention_logits_max=tf.reduce_max(attention_logits,axis=1,keep_dims=True) #[batch_size x 1]\n # possibility distribution for each encoder input.it means how much attention or focus for each encoder input\n p_attention=tf.nn.softmax(attention_logits-attention_logits_max)#[batch_size x attn_length]\n\n # 3.get weighted sum of hidden state for each encoder input as attention state\n p_attention=tf.expand_dims(p_attention,axis=2) #[batch_size x attn_length x 1]\n # attention_states:[batch_size x attn_length x attn_size]; p_attention:[batch_size x attn_length];\n attention_final=tf.multiply(attention_states_original,p_attention) #[batch_size x attn_length x attn_size]\n context_vector=tf.reduce_sum(attention_final,axis=1) #[batch_size x attn_size]\n ############################################################################################################################################################\n #inp:[batch_size x input_size].it is decoder input; attention_final:[batch_size x attn_size]\n output, state = cell(inp, state,context_vector) #attention_final TODO 使用RNN走一步\n outputs.append(output) # 将输出添加到结果列表中\n if loop_function is not None:\n prev = output\n print(\"rnn_decoder_with_attention ended...\")\n return outputs, state","def __call__(self, batch):\r\n '''\r\n for i in range(len(batch)):\r\n if batch[i].shape[1] != 861:\r\n batch[i] = batch[i - 1]\r\n '''\r\n return torch.tensor(batch)#torch.stack(batch, dim = 0)\r","def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\n residual_connection=False, device_str=None):\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\n dropout = dropout if mode == \"train\" else 0.0\n # Cell Type\n if unit_type == \"lstm\":\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\n\n elif unit_type == \"gru\":\n single_cell = tf.contrib.rnn.GRUCell(num_units)\n\n elif unit_type == \"layer_norm_lstm\":\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\n num_units,layer_norm=True)\n else:\n raise ValueError(\"Unknown unit type %s!\" % unit_type)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.contrib.rnn.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n\n # Residual\n if residual_connection:\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\n\n return single_cell","def test_model_with_simple_rnn_multiple_layers(self):\n tf.compat.v1.reset_default_graph()\n sess = tf.compat.v1.Session()\n with sess.graph.as_default():\n inputs = tf.keras.Input(shape=(3, 100))\n\n # Add an RNN layer with 12 internal units.\n x = tf.keras.layers.SimpleRNN(12, name='rnn0', activation='tanh', return_sequences=True)(inputs)\n x = tf.keras.layers.SimpleRNN(12, name='rnn1', activation='relu', return_sequences=True)(x)\n x = tf.keras.layers.SimpleRNN(12, name='rnn2', activation='tanh')(x)\n _ = tf.keras.layers.Dense(12, activation=tf.nn.softmax, name=\"matmul0\")(x)\n\n init = tf.compat.v1.global_variables_initializer()\n sess.run(init)\n # _ = tf.compat.v1.summary.FileWriter('./simple_rnn', sess.graph)\n\n # construct a connected graph\n conn_graph = ConnectedGraph(sess.graph, ['input_1'], ['matmul0/Softmax'])\n\n # there should be only 4 connected graph ops, input, simpleRNN , Dense and Softmax\n self.assertEqual(6, len(conn_graph.get_all_ops()))\n num_detected_rnns = 0\n for op in conn_graph.get_all_ops().values():\n if op.type == 'SimpleRNN':\n num_detected_rnns += 1\n inner_list = op.internal_ops\n self.assertEqual(49, len(inner_list))\n self.assertEqual(3, num_detected_rnns)","def stacked_bidirectional_rnn(RNN, num_units, num_layers, inputs, seq_lengths, batch_size):\n _inputs = inputs\n for _ in range(num_layers):\n with tf.variable_scope(None, default_name=\"bidirectional-rnn\"):\n rnn_cell_fw = RNN(num_units)\n rnn_cell_bw = RNN(num_units)\n initial_state_fw = rnn_cell_fw.zero_state(batch_size, dtype=tf.float32)\n initial_state_bw = rnn_cell_bw.zero_state(batch_size, dtype=tf.float32)\n (output, state) = tf.nn.bidirectional_dynamic_rnn(rnn_cell_fw, rnn_cell_bw, _inputs, seq_lengths,\n initial_state_fw, initial_state_bw, dtype=tf.float32)\n _inputs = tf.concat(output, 2)\n return _inputs","def _build_decoder_cell(self, encode_output):\n # We only make use of encoder_outputs in attention-based models\n cells = self.rnn_cells()\n cell = tf.contrib.rnn.MultiRNNCell(cells)\n decoder_initial_state = self._build_deocder_init_state(encode_output)\n\n return cell, decoder_initial_state","def test_two_cell_repel():\n space = c6.Space()\n c6.Cell(space, [0, 0], 1)\n c6.Cell(space, [0, 1.9], 1)\n for i in range(2):\n space.step()","def _single_cell(num_units,\n dropout,\n mode,\n residual_connection=False,\n device_str=None):\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\n\n # Cell Type\n utils.print_out(\" GRU\", new_line=False)\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\n\n # Dropout (= 1 - keep_prob)\n if dropout > 0.0:\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\n cell=single_cell, input_keep_prob=(1.0 - dropout))\n utils.print_out(\n \" %s, dropout=%g \" % (type(single_cell).__name__, dropout),\n new_line=False)\n\n # Residual\n if residual_connection:\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\n utils.print_out(\" %s\" % type(single_cell).__name__, new_line=False)\n\n # Device Wrapper\n if device_str:\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\n utils.print_out(\n \" %s, device=%s\" % (type(single_cell).__name__, device_str),\n new_line=False)\n\n return single_cell","def gru_encoder(cell, embedding, init_state, batch_input, batch_mask):\n #batch_size = batch_input.get_shape()[0]\n #state = tf.zeros([batch_size, options['state_size']], tf.float32) # initialize the state\n outputs = []\n #split_inputs = tf.split(1, batch_input.get_shape()[0], batch_input)\n \n with tf.device(\"/cpu:0\"):\n embedded_list = tf.nn.embedding_lookup(embedding, batch_input)\n #embedded_list = batch_mask * tf.transpose(embedded_list, [2, 0, 1]) # Add mask to change embedding into zeros\n #embedded_list = tf.transpose(embedded_list, [2, 1, 0])\n embedded_list = tf.transpose(embedded_list, [1, 0, 2])\n embedded_list = tf.unpack(embedded_list) # list of embedding\n \n # min_sequence_length = tf.reduce_min(seq_len)\n #max_sequence_length = tf.reduce_max(seq_len)\n\n state = init_state\n for time, (embedded, i_mask) in enumerate(zip(embedded_list, tf.unpack(tf.transpose(batch_mask)))):\n #embedded = tf.nn.embedding_lookup(embedding, tf.reshape(inputs, [-1])) # deprecated\n #embedded = embedded * tf.reshape(tf.convert_to_tensor(batch_mask[:, time], tf.float32), [batch_size, 1]) # deprecated\n #copy_cond = (time >= seq_len)\n #new_output, new_state = cell(embedded, state)\n output, state = cell(embedded, state)#tf.select(copy_cond, zero_output, new_output), tf.select(copy_cond, state, new_state)\n output = tf.expand_dims(i_mask, 1) * output\n outputs.append(output)\n #outputs = batch_mask * tf.transpose(tf.pack(outputs), [2, 0, 1])\n #outputs = tf.unpack(tf.transpose(outputs, [2, 1, 0]))\n return outputs, state","def add_prediction_op(self):\n\n #x_dropout = tf.keras.layers.SpatialDropout1D(0.4).apply(self.input_placeholder)\n layer_1_size = 150\n layer_2_size = 25\n num_aux_feats = 4\n\n rnn_cell_layer_1_fwd = tf.nn.rnn_cell.GRUCell(\n layer_1_size,\n activation='relu',\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\n bias_initializer=tf.zeros_initializer(),\n name=\"gru_1\",\n dtype=tf.float32\n )\n\n rnn_cell_layer_1_bwd = tf.nn.rnn_cell.GRUCell(\n layer_1_size,\n activation='relu',\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\n bias_initializer=tf.zeros_initializer(),\n name=\"gru_1\",\n dtype=tf.float32\n )\n\n rnn_cell_layer_2_fwd = tf.nn.rnn_cell.GRUCell(\n layer_2_size,\n activation='relu',\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\n bias_initializer=tf.zeros_initializer(),\n name=\"gru_2\",\n dtype=tf.float32\n )\n\n rnn_cell_layer_2_bwd = tf.nn.rnn_cell.GRUCell(\n layer_2_size,\n activation='relu',\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\n bias_initializer=tf.zeros_initializer(),\n name=\"gru_2\",\n dtype=tf.float32\n )\n\n outputs_1, states_1 = tf.nn.bidirectional_dynamic_rnn(\n cell_fw=rnn_cell_layer_1_fwd,\n cell_bw=rnn_cell_layer_1_bwd,\n inputs=self.input_placeholder,\n sequence_length=self.batch_seq_length_placeholder,\n dtype=tf.float32\n )\n h1 = tf.concat(outputs_1, axis=2, name=\"concat1\")\n\n outputs_2, states_2 = tf.nn.bidirectional_dynamic_rnn(\n cell_fw=rnn_cell_layer_2_fwd,\n cell_bw=rnn_cell_layer_2_bwd,\n inputs=h1,\n dtype=tf.float32\n )\n h2 = tf.concat(states_2, axis=1, name=\"concat2\")\n\n h3 = tf.concat(\n [\n h2,\n tf.reshape(self.batch_unique_count_placeholder, (-1, 1)),\n tf.reduce_max(h2, axis=1, keepdims=True)\n ],\n axis=1,\n name=\"concat3\"\n )\n num_aux_feats = 2\n\n #h_drop = tf.nn.dropout(state, keep_prob=0.8)\n\n with tf.name_scope(\"classifier\"):\n self.W_ho = tf.get_variable(\n \"W_ho\",\n (layer_2_size * 2 + num_aux_feats, self.config.n_classes),\n tf.float32,\n tf.contrib.layers.xavier_initializer(),\n trainable=True\n )\n self.b_o = tf.get_variable(\n \"bo\",\n (1, self.config.n_classes),\n tf.float32, tf.zeros_initializer(),\n trainable=True\n )\n pred = tf.matmul(h3, self.W_ho) + self.b_o\n\n return pred","def biLSTM(inputs, dim, seq_len, name, cell_type=\"cudnn\", cells=None, is_training=True, dropout_rate=0.0):\r\n if cell_type==\"cudnn\":\r\n with tf.variable_scope(name,reuse=tf.AUTO_REUSE) as scope:\r\n hidden_states, cell_states = bi_cudnn_rnn_encoder('lstm', dim, 1, dropout_rate, inputs, seq_len, is_training)\r\n else:\r\n with tf.name_scope(name) as scope:\r\n with tf.variable_scope('forward' + name) as scope:\r\n if cell_type == \"lstm\":\r\n lstm_fwd = tf.contrib.rnn.LSTMCell(num_units=dim)\r\n with tf.variable_scope('backward' + name) as scope:\r\n if cell_type == \"lstm\":\r\n lstm_bwd = tf.contrib.rnn.LSTMCell(num_units=dim)\r\n \r\n with tf.variable_scope(name+'blstm', reuse=tf.AUTO_REUSE):\r\n hidden_states, cell_states = tf.nn.bidirectional_dynamic_rnn(cell_fw=lstm_fwd, cell_bw=lstm_bwd, inputs=inputs, sequence_length=seq_len, dtype=tf.float32, scope=name)\r\n\r\n return hidden_states, cell_states","def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\n\t\treturn _mh.create_rnn_cell(\n\t\t\tunit_type=hparams.unit_type,\n\t\t\tnum_units=self.num_units,\n\t\t\tnum_layers=num_layers,\n\t\t\tnum_residual_layers=num_residual_layers,\n\t\t\tforget_bias=hparams.forget_bias,\n\t\t\tdropout=hparams.dropout,\n\t\t\tmode=self.mode)","def adj_batch():\n return torch.Tensor([[[1, 3], [3, 1]], [[7, 8], [8, 7]]])","def __init__(self,\n cell_type: Text = \"lstm\",\n tiers: Dict[int:List[int]] = {1:[1]},\n window_sizes: List[int] = [1],\n strides: List[int] = [1],\n use_dense_layer_output : bool = False,\n dense_layer_args : Dict = {\"units\": None,\n \"activation\":None,#don't change this\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"bias_initializer\":'zeros',\n \"kernel_regularizer\":None,\n \"bias_regularizer\":None,\n \"activity_regularizer\":None,\n \"kernel_constraint\":None,\n \"bias_constraint\":None,\n },\n lstm_cell_args : Dict = {\"activation\":'tanh',\n \"recurrent_activation\":'hard_sigmoid',\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"recurrent_initializer\":'orthogonal',\n \"bias_initializer\":'zeros',\n \"unit_forget_bias\":True,\n \"kernel_regularizer\":None,\n \"recurrent_regularizer\":None,\n \"bias_regularizer\":None,\n \"kernel_constraint\":None,\n \"recurrent_constraint\":None,\n \"bias_constraint\":None,\n \"implementation\":1,\n },\n gru_cell_args : Dict = {\"activation\":'tanh',\n \"recurrent_activation\":'hard_sigmoid',\n \"use_bias\":True,\n \"kernel_initializer\":'glorot_uniform',\n \"recurrent_initializer\":'orthogonal',\n \"bias_initializer\":'zeros',\n \"kernel_regularizer\":None,\n \"recurrent_regularizer\":None,\n \"bias_regularizer\":None,\n \"kernel_constraint\":None,\n \"recurrent_constraint\":None,\n \"bias_constraint\":None,\n \"implementation\":1,\n \"reset_after\":False,\n },\n adam_opt_args : Dict = {\"learning_rate\": None,\n \"epsilon\": None,\n \"beta_1\": None,\n \"beta_2\": None,\n },\n clip_norm : Optional[float] = None,\n dropout_training = 0,\n recurrent_dropout_training = 0,\n tens_to_log = None,\n checkpoint_path = None,\n predict_batch_size = 30,\n save_checkpoints_steps = 100,\n keep_checkpoint_max = 10,\n save_summary_steps = 10,\n logging_step = 10,\n ):\n \n if (len(tiers)!=len(window_sizes) or len(window_sizes)!=len(strides)):\n raise ValueError(\"Mismatch in network geometry specs. Need number of\"\n \" tiers = number of window size specs, or number of\"\n \" window specs = number of stride specs.\")\n \n \n self.cell_type = cell_type \n self.tiers = tiers, \n self.window_sizes = window_sizes,\n self.strides = strides,\n self.use_dense_layer_output = use_dense_layer_output\n self.dense_layer_args = dense_layer_args,\n self.lstm_cell_args = lstm_cell_args,\n self.gru_cell_args = gru_cell_args,\n self.adam_opt_args = adam_opt_args,\n self.clip_norm = clip_norm,\n self.dropout_training = 0,\n self.recurrent_dropout_training = recurrent_dropout_training,\n self.tens_to_log = tens_to_log,\n self.checkpoint_path = None,\n self.predict_batch_size = 30,\n self.save_checkpoints_steps = 100,\n self.keep_checkpoint_max = 10,\n self.save_summary_steps = 20,\n self.logging_step = 10","def _input_module(self):\n # GRU cell description\n self.cell = tf.nn.rnn_cell.GRUCell(\n num_units=self.config.hidden_size,\n input_size=self.config.word_vector_length)\n\n # Get output after every word.\n # outputs: (BATCH_SIZE, n_words, HIDDEN_SIZE)\n # state: The last output (1, HIDDEN_SIZE)\n outputs, state = tf.nn.dynamic_rnn(self.cell,\n self.input_placeholder,\n self.input_length_placeholder,\n dtype='float32')\n\n context_rnn_out = tf.reshape(outputs, [-1, self.config.hidden_size]) # Now the shape = [n_words, n_units]\n\n # Only project the state at the end of each sentence\n sentence_representations_mat = tf.gather(context_rnn_out,\n self.end_of_sentences_placeholder) # (1, n_sentences, HIDDEN_SIZE)\n\n # The code below it necessary to split the Tensor(?,HIDDEN_SIZE) in a list of tensors with shape (1,HIDDEN_SIZE)\n\n # Reshape `X` as a vector. -1 means \"set this dimension automatically\".\n sentences_as_vector = tf.reshape(sentence_representations_mat, [-1])\n\n # Create another vector containing zeroes to pad `X` to (MAX_INPUT_LENGTH * WORD_VECTOR_LENGTH) elements.\n zero_padding = tf.zeros(\n [self.dataset.max_input_size * self.config.hidden_size] - tf.shape(sentences_as_vector),\n dtype=sentences_as_vector.dtype)\n\n # Concatenate `X_as_vector` with the padding.\n sentences_padded_as_vector = tf.concat(0, [sentences_as_vector, zero_padding])\n\n # Reshape the padded vector to the desired shape.\n sentences_padded = tf.reshape(sentences_padded_as_vector, [self.dataset.max_input_size,\n self.config.hidden_size])\n\n # Split X into a list of tensors of length MAX_INPUT_LENGTH where each tensor is a 1xHIDDEN_SIZE vector\n # of the word vectors\n self.sentence_representations = tf.split(0, self.dataset.max_input_size, sentences_padded)\n\n self.number_of_sentences = tf.shape(sentence_representations_mat)[1]\n\n self.input_only_for_testing = tf.concat(0, self.sentence_representations)\n\n # Result of this module:\n # - List of sentences. Each sentence is a tensor of shape (1, HIDDEN_UNITS). 1=Batch_size\n # - The number of sentences.","def TextRCNN2(inputs, lstm_size=256, cnns=[(32,1), (32,3), (64,5), (128,7)]):\n tf_input, cnn_feats = cnn_backbone(inputs=inputs, cnns=cnns)\n\n tf_x = tf.keras.layers.concatenate(cnn_feats)\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size, return_sequences=True)(tf_x)\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size, return_sequences=True)(tf_x)\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size, return_sequences=True)(tf_x)\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size)(tf_x)\n \n tf_readout = tf.keras.layers.Dense(1, activation='sigmoid')(tf_x)\n model = tf.keras.models.Model(tf_input, tf_readout, name='TextRCNN2') \n model.compile(loss='binary_crossentropy', optimizer='adam')\n return model","def unroll_cell(self, decoder_inputs, initial_state, loop_function, cell):\n pass","def generator(real_init): #-1, 5, 3\n with tf.variable_scope('rnn_gen', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n x_init = real_init[:,:,0] #-1, 8\n y_init = real_init[:,:,1] #-1, 8\n z_init = real_init[:,:,2] #-1, 8\n \n with tf.variable_scope('x_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n x_w1 = tf.get_variable('x_w1', [6, 3])\n x_b1 = tf.get_variable('x_b1', [3])\n x_w2 = tf.get_variable('x_w2', [9, 3])\n x_b2 = tf.get_variable('x_b2', [3])\n x_w3 = tf.get_variable('x_w3', [3, 1])\n x_b3 = tf.get_variable('x_b3', [1])\n x_w4 = tf.get_variable('x_w4', [3, 1])\n x_b4 = tf.get_variable('x_b4', [1])\n \n x_full = x_init#-1, 8\n for i in range(104):\n x_layer1 = tf.nn.elu(tf.matmul(x_init, x_w1) + x_b1)#-1, 4\n x_layer2 = tf.concat([x_init, x_layer1], 1)#-1, 12\n x_layer3 = tf.nn.elu(tf.matmul(x_layer2, x_w2) + x_b2)#-1, 4\n \n x_mean = tf.sigmoid(tf.matmul(x_layer3, x_w3) + x_b3)#-1, 1\n x_gamma = tf.sigmoid(tf.matmul(x_layer3, x_w4) + x_b4)#-1, 1\n x_delta = x_mean + x_gamma * tf.random_normal(tf.shape(x_gamma), dtype = tf.float32)#-1, 1\n x_delta_denorm = (x_delta * 2 - 1) / 80\n x_output = tf.expand_dims(x_full[:,-1], 1) + x_delta_denorm\n x_full = tf.concat([x_full, x_output], axis = 1)#-1, 10 + 1\n x_init = x_full[:,-6:]\n \n with tf.variable_scope('y_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n y_w1 = tf.get_variable('y_w1', [6, 3])\n y_b1 = tf.get_variable('y_b1', [3])\n y_w2 = tf.get_variable('y_w2', [9, 3])\n y_b2 = tf.get_variable('y_b2', [3])\n y_w3 = tf.get_variable('y_w3', [3, 1])\n y_b3 = tf.get_variable('y_b3', [1])\n y_w4 = tf.get_variable('y_w4', [3, 1])\n y_b4 = tf.get_variable('y_b4', [1])\n \n y_full = y_init#-1, 8\n for i in range(104):\n y_layer1 = tf.nn.elu(tf.matmul(y_init, y_w1) + y_b1)\n y_layer2 = tf.concat([y_init, y_layer1], 1)#-1, 12\n y_layer3 = tf.nn.elu(tf.matmul(y_layer2, y_w2) + y_b2)#-1, 4\n \n y_mean = tf.sigmoid(tf.matmul(y_layer3, y_w3) + y_b3) #-1, 1\n y_gamma = tf.sigmoid(tf.matmul(y_layer3, y_w4) + y_b4) #-1, 1\n y_delta = y_mean + y_gamma * tf.random_normal(tf.shape(y_gamma), dtype = tf.float32)#-1, 1\n y_delta_denorm = (y_delta * 5 - 2.7) / 1700\n y_output = tf.expand_dims(y_full[:,-1], 1) + y_delta_denorm\n y_full = tf.concat([y_full, y_output], axis = 1)#-1, 10 + 1, 1\n y_init = y_full[:,-6:]\n \n with tf.variable_scope('z_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\n z_w1 = tf.get_variable('z_w1', [6, 3])\n z_b1 = tf.get_variable('z_b1', [3])\n z_w2 = tf.get_variable('z_w2', [9, 3])\n z_b2 = tf.get_variable('z_b2', [3])\n z_w3 = tf.get_variable('z_w3', [3, 1])\n z_b3 = tf.get_variable('z_b3', [1])\n z_w4 = tf.get_variable('z_w4', [3, 1])\n z_b4 = tf.get_variable('z_b4', [1])\n \n z_full = z_init#-1, 8\n for i in range(104):\n z_layer1 = tf.nn.elu(tf.matmul(z_init, z_w1) + z_b1)\n z_layer2 = tf.concat([z_init, z_layer1], 1)#-1, 12\n z_layer3 = tf.nn.elu(tf.matmul(z_layer2, z_w2) + z_b2)#-1, 4\n \n z_mean = tf.sigmoid(tf.matmul(z_layer3, z_w3) + z_b3) #-1, 1\n z_gamma = tf.sigmoid(tf.matmul(z_layer3, z_w4) + z_b4) #-1, 1\n z_delta = z_mean + z_gamma * tf.random_normal(tf.shape(z_gamma), dtype = tf.float32)#-1, 1\n z_delta_denorm = (z_delta * 3 - 2.2) / 300\n z_output = tf.expand_dims(z_full[:,-1], 1) + z_delta_denorm\n z_full = tf.concat([z_full, z_output], axis = 1)#-1, 10 + 1, 1\n z_init = z_full[:,-6:]\n \n rand_layer1 = tf.concat([tf.expand_dims(x_full, 2), tf.expand_dims(y_full, 2), tf.expand_dims(z_full, 2)], axis = 2)#-1, 200, 3\n rand_layer1_reshape = tf.reshape(rand_layer1, shape = (-1, 110, 3, 1))\n output_filt = tf.ones(shape = (11, 1, 1, 1)) / 11\n \n rand_layer2 = tf.nn.conv2d(rand_layer1_reshape, output_filt, strides = [1,1,1,1], padding = 'VALID')\n \n return tf.reshape(rand_layer2, shape = (-1, 100, 3)) #-1, 110, 3","def simple_batching(config, insts: List[Instance]) -> Tuple[torch.Tensor,torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor]:\n batch_size = len(insts)\n batch_data = insts\n # probably no need to sort because we will sort them in the model instead.\n # batch_data = sorted(insts, key=lambda inst: len(inst.input.words), reverse=True) ##object-based not direct copy\n sent_seq_len = torch.LongTensor(list(map(lambda inst: len(inst.input.sents), batch_data)))\n max_seq_len = sent_seq_len.max()\n\n # num_tokens = torch.LongTensor(list(map(lambda inst: inst.max_num_tokens, batch_data)))\n # max_tokens = num_tokens.max()\n\n num_tokens = list(map(lambda inst: inst.num_tokens, batch_data)) # 2-dimension\n max_tokens = max([max(num_token) for num_token in num_tokens])\n\n # NOTE: Use 1 here because the CharBiLSTM accepts\n char_seq_len = torch.LongTensor([list(map(len, inst.input.sents)) + [1] * (int(max_seq_len) - len(inst.input.sents)) for inst in batch_data])\n max_char_seq_len = char_seq_len.max()\n\n context_emb_tensor = None\n if config.context_emb != ContextEmb.none:\n emb_size = insts[0].elmo_vec.shape[1]\n context_emb_tensor = torch.zeros((batch_size, max_seq_len, emb_size))\n\n # emb_size = len(insts[0][0].vec)\n # print('emb_size: ',emb_size)\n emb_size = 768\n\n # word_seq_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\n label_seq_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\n review_idx_tensor = torch.full((batch_size, max_seq_len),0, dtype=torch.long)\n reply_idx_tensor = torch.full((batch_size, max_seq_len),0, dtype=torch.long)\n\n char_seq_tensor = torch.zeros((batch_size, max_seq_len, max_char_seq_len), dtype=torch.long)\n\n initial_sent_emb_tensor = torch.zeros((batch_size, max_seq_len, max_tokens, emb_size), dtype=torch.float32)\n sent_emb_tensor = torch.zeros((1,), dtype=torch.float32)\n\n # input = torch.zeros((batch_size, num_sents, emb_size))\n\n type_id_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\n num_tokens_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\n\n pair_tensor = torch.zeros((batch_size,max_seq_len,max_seq_len), dtype = torch.float32)\n pair_tensor_train = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\n pair_padding_tensor = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\n pair_padding_train = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\n # pair_padding_tensor1 = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\n\n max_review_tensor = torch.zeros((batch_size), dtype=torch.long)\n\n for idx in range(batch_size):\n\n\n # word_seq_tensor[idx, :word_seq_len[idx]] = torch.LongTensor(batch_data[idx].word_ids)\n if batch_data[idx].output_ids:\n # print('output_ids: ', batch_data[idx].output_ids)\n # print('review_idx: ', batch_data[idx].review_idx)\n # print(sent_seq_len[idx])\n # print(\"batch_data[idx].max_review_id: \",batch_data[idx].max_review_id )\n max_review_tensor[idx]=batch_data[idx].max_review_id\n label_seq_tensor[idx, :sent_seq_len[idx]] = torch.LongTensor(batch_data[idx].output_ids)\n review_idx_tensor[idx, torch.LongTensor(batch_data[idx].review_idx)] = torch.LongTensor(batch_data[idx].review_idx)\n reply_idx_tensor[idx, torch.LongTensor(batch_data[idx].reply_idx)] = torch.LongTensor(batch_data[idx].reply_idx)\n type_id_tensor[idx, :sent_seq_len[idx]] = torch.LongTensor(batch_data[idx].type)\n num_tokens_tensor[idx, :sent_seq_len[idx]] = torch.LongTensor(batch_data[idx].num_tokens)\n\n if config.context_emb != ContextEmb.none:\n context_emb_tensor[idx, :sent_seq_len[idx], :] = torch.from_numpy(batch_data[idx].elmo_vec)\n # print('type id tensor', type_id_tensor[idx])\n # print('max review id', batch_data[idx].max_review_id, len(batch_data[idx].review_idx))\n # pair_padding_tensor[idx, :len(batch_data[idx].review_idx), batch_data[idx].max_review_id:sent_seq_len[idx]] = 1.0\n # pair_padding_tensor[idx, torch.LongTensor(batch_data[idx].review_idx), torch.LongTensor(batch_data[idx].reply_idx)] = 1.0\n\n\n for sent_idx in range(sent_seq_len[idx]):\n for token_idx in range(num_tokens[idx][sent_idx]):\n initial_sent_emb_tensor[idx, sent_idx, token_idx, :emb_size] = torch.Tensor(batch_data[idx].vec[sent_idx][token_idx])\n\n # print('sent_emb_tensor', sent_emb_tensor[idx, sent_idx, 0])\n char_seq_tensor[idx, sent_idx, :char_seq_len[idx, sent_idx]] = torch.LongTensor(batch_data[idx].char_ids[sent_idx])\n\n if sent_idx < batch_data[idx].max_review_id:\n for sent_idx2 in range(sent_idx+1, sent_seq_len[idx]):\n if batch_data[idx].labels_pair[sent_idx] == batch_data[idx].labels_pair[sent_idx2] \\\n and batch_data[idx].labels_pair[sent_idx] != 0 \\\n and batch_data[idx].type[sent_idx] == 0 and batch_data[idx].type[sent_idx2] == 1:\n pair_tensor[idx,sent_idx,sent_idx2]=1.0\n pair_tensor_train[idx, sent_idx, sent_idx2] = 1.0\n #if batch_data[idx].type[sent_idx]==0 and batch_data[idx].type[sent_idx2]==1:\n # pair_padding_train[idx, sent_idx, sent_idx2] = 1.0\n if batch_data[idx].labels_pair[sent_idx] != 0 and batch_data[idx].labels_pair[sent_idx2] != 0 \\\n and batch_data[idx].type[sent_idx] == 0 and batch_data[idx].type[sent_idx2] == 1:\n pair_padding_tensor[idx,sent_idx,sent_idx2]=1.0\n # if batch_data[idx].type[sent_idx2 - 1] == 1:\n # pair_padding_tensor[idx, sent_idx, sent_idx2-1] = 1.0\n # if batch_data[idx].type[sent_idx2 - 2] == 1:\n # pair_padding_tensor[idx, sent_idx, sent_idx2 - 2] = 1.0\n # if sent_idx2 +1 < sent_seq_len[idx]:\n # pair_padding_tensor[idx, sent_idx, sent_idx2 + 1] = 1.0\n # if sent_idx2 + 2 < sent_seq_len[idx]:\n # pair_padding_tensor[idx, sent_idx, sent_idx2 + 2] = 1.0\n # print(\"sum:\", pair_padding_tensor.sum())\n # print((pair_padding_tensor[idx]==pair_padding_tensor1[idx]).all())\n\n # print('sum of pair padding tensor', torch.sum(pair_padding_tensor[idx]),torch.sum(pair_padding_tensor1[idx]))\n # print(pair_padding_tensor[idx][:100])\n\n\n # print(pair_tensor[idx,])\n for sentIdx in range(sent_seq_len[idx], max_seq_len):\n char_seq_tensor[idx, sentIdx, 0: 1] = torch.LongTensor([config.char2idx[PAD]]) ###because line 119 makes it 1, every single character should have a id. but actually 0 is enough\n\n tmp = pair_padding_tensor + pair_tensor\n\n for idx in range(batch_size):\n\n for sent_idx in range(sent_seq_len[idx]):\n # pair_padding_train[idx, sent_idx,tmp[idx,sent_idx,:]==1] =1\n\n if (tmp[idx, sent_idx, :] == 1).sum() >= 5:\n valid_idx = (tmp[idx, sent_idx, :] == 1).nonzero().view(-1)\n choice = torch.multinomial(valid_idx.float(), 5)\n pair_padding_train[idx, sent_idx, valid_idx[choice]] = 1\n else:\n pair_padding_train[idx, sent_idx,tmp[idx,sent_idx,:]==1] =1\n\n #if (tmp[idx, sent_idx, :] == 0).sum() >= 1:\n # valid_idx = (tmp[idx, sent_idx, :] == 0).nonzero().view(-1)\n # choice = torch.multinomial(valid_idx.float(), 1)\n # pair_padding_train[idx, sent_idx, valid_idx[choice]] = 1\n #else:\n # pair_padding_train[idx, sent_idx,tmp[idx,sent_idx,:]==0] =1\n\n\n pair_padding_train[pair_tensor == 1] = 1\n pair_tensor_train[pair_padding_train == 0] = -100\n pair_tensor[pair_padding_tensor == 0] = -100\n\n # print('number of not -100', torch.sum(pair_tensor != -100), torch.sum(pair_tensor_train != -100))\n # word_seq_tensor = word_seq_tensor.to(config.device)\n label_seq_tensor = label_seq_tensor.to(config.device)\n char_seq_tensor = char_seq_tensor.to(config.device)\n sent_seq_len = sent_seq_len.to(config.device)\n char_seq_len = char_seq_len.to(config.device)\n\n # sent_emb_tensor = sent_emb_tensor.to(config.device)\n type_id_tensor = type_id_tensor.to(config.device)\n\n review_idx_tensor = review_idx_tensor.to(config.device)\n reply_idx_tensor = reply_idx_tensor.to(config.device)\n\n pair_tensor = pair_tensor.to(config.device)\n pair_padding_tensor = pair_padding_tensor.to(config.device)\n pair_padding_train = pair_padding_train.to(config.device)\n pair_tensor_train = pair_tensor_train.to(config.device)\n\n return sent_emb_tensor, type_id_tensor, sent_seq_len, num_tokens_tensor, initial_sent_emb_tensor, context_emb_tensor, char_seq_tensor, char_seq_len, pair_tensor,pair_padding_tensor, label_seq_tensor, review_idx_tensor, reply_idx_tensor, pair_tensor_train, pair_padding_train, max_review_tensor","def nn_kras():\n return GCN_simple(29, [3], 2, 7, dropout=0)","def LSTMLayer(cell_name, weights, m, c, x_seq, pad_seq):\n if len(x_seq) != len(pad_seq):\n raise ValueError('length of x_seq(%d) != pad_seq(%d)' %\n (len(x_seq), len(pad_seq)))\n out_seq = []\n for seq in range(len(x_seq)):\n with ops.name_scope('%s_%d' % (cell_name, seq)):\n m, c = LSTMCell(weights, m, c, x_seq[seq], pad_seq[seq])\n out_seq.append(array_ops.identity(m, name='out'))\n return out_seq","def __init__(self, device, input_size, hidden_size, layer_norm=False, chrono_init=False, t_max=10):\n\n super(LSTMCell, self).__init__()\n\n self._device = device\n self._input_size = input_size\n self._hidden_size = hidden_size\n self._layer_norm = layer_norm\n self._chrono_init = chrono_init\n self._t_max = t_max\n\n self._W_x2i = nn.Parameter(torch.Tensor(input_size, hidden_size))\n self._W_h2i = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\n self._W_c2i = nn.Parameter(torch.Tensor(hidden_size))\n self._b_i = nn.Parameter(torch.Tensor(hidden_size))\n \n self._W_x2f = nn.Parameter(torch.Tensor(input_size, hidden_size))\n self._W_h2f = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\n self._W_c2f = nn.Parameter(torch.Tensor(hidden_size))\n self._b_f = nn.Parameter(torch.Tensor(hidden_size))\n \n self._W_x2o = nn.Parameter(torch.Tensor(input_size, hidden_size))\n self._W_h2o = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\n self._W_c2o = nn.Parameter(torch.Tensor(hidden_size))\n self._b_o = nn.Parameter(torch.Tensor(hidden_size))\n \n self._W_x2c = nn.Parameter(torch.Tensor(input_size, hidden_size))\n self._W_h2c = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\n self._b_c = nn.Parameter(torch.Tensor(hidden_size))\n\n if self._layer_norm:\n self._ln_c = nn.LayerNorm(hidden_size)\n self._ln_i = nn.LayerNorm(hidden_size)\n self._ln_f = nn.LayerNorm(hidden_size)\n self._ln_o = nn.LayerNorm(hidden_size)\n self._ln_g = nn.LayerNorm(hidden_size)\n \n self._reset_parameters()","def TextRCNN1(inputs, lstm_size=1024, cnns=[(32,1), (32,3), (64,5), (128,7)]):\n tf_input, cnn_feats = cnn_backbone(inputs=inputs, cnns=cnns)\n\n tf_x = tf.keras.layers.concatenate(cnn_feats)\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size)(tf_x)\n \n tf_readout = tf.keras.layers.Dense(1, activation='sigmoid')(tf_x)\n model = tf.keras.models.Model(tf_input, tf_readout, name='TextRCNN1') \n model.compile(loss='binary_crossentropy', optimizer='adam')\n return model","def _generate_cells(self) -> None:\n for i in range(15):\n for j in range(15):\n c = Cell(x=i, y=j)\n c.answer = self.puzzle.solution[j*self.width+i]\n self.cells[(j, i)] = c # row, col","def _build_pnasnet_base(\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\n start_cell_num):\n\n # Find where to place the reduction cells or stride normal cells\n reduction_indices = nasnet_utils.calc_reduction_layers(\n hparams.num_cells, hparams.num_reduction_layers)\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\n\n # Note: The None is prepended to match the behavior of _imagenet_stem()\n cell_outputs = [None, hidden_previous, hidden]\n net = hidden\n\n # Run the cells\n for cell_num in range(start_cell_num, hparams.num_cells):\n is_reduction = cell_num in reduction_indices\n stride = 2 if is_reduction else 1\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\n prev_layer = cell_outputs[-2]\n net = normal_cell(\n net,\n scope='cell_{}'.format(cell_num),\n filter_scaling=filter_scaling,\n stride=stride,\n prev_layer=prev_layer,\n cell_num=true_cell_num)\n true_cell_num += 1\n cell_outputs.append(net)\n\n # Final nonlinearity.\n # Note that we have dropped the final pooling, dropout and softmax layers\n # from the default pnasnet version.\n with tf.variable_scope('final_layer'):\n net = tf.nn.relu(net)\n return net","def set_cells(self, val=None):\t\r\n self._cells = \\\r\n (self.nx-1 if self.nx>1 else 1)* \\\r\n (self.ny-1 if self.ny>1 else 1)* \\\r\n (self.nz-1 if self.nz>1 else 1)","def test_output_head_shapes_correct():\n N = 20\n X = torch.randn((N, 10, 4)) * -20.0\n for _ in range(25):\n nn_instance = RNN(input_dim=4,\n layers_info=[[\"gru\", 20], [\"lstm\", 8], [\"linear\", 1], [\"linear\", 12]],\n hidden_activations=\"relu\")\n out = nn_instance(X)\n assert out.shape[0] == N\n assert out.shape[1] == 12\n\n for output_dim in [[ [\"linear\", 10], [\"linear\", 4], [\"linear\", 6]], [[\"linear\", 3], [\"linear\", 8], [\"linear\", 9]]]:\n nn_instance = RNN(input_dim=4,\n layers_info=[[\"gru\", 20], [\"lstm\", 8], [\"linear\", 1], [\"linear\", 12], output_dim],\n hidden_activations=\"relu\", output_activation=[\"softmax\", None, \"relu\"])\n out = nn_instance(X)\n assert out.shape[0] == N\n assert out.shape[1] == 20","def rnn(rnn_type, inputs, length, hidden_size, layer_num=1, dropout_keep_prob=None, concat=True):\n if not rnn_type.startswith('bi'):\n cell = get_cell(rnn_type, hidden_size, layer_num, dropout_keep_prob)\n outputs, states = tf.nn.dynamic_rnn(cell, inputs, sequence_length=length, dtype=tf.float32)\n if rnn_type.endswith('lstm'):\n c = [state.c for state in states]\n h = [state.h for state in states]\n states = h\n else:\n cell_fw = get_cell(rnn_type, hidden_size, layer_num, dropout_keep_prob)\n cell_bw = get_cell(rnn_type, hidden_size, layer_num, dropout_keep_prob)\n outputs, states = tf.nn.bidirectional_dynamic_rnn(\n cell_bw, cell_fw, inputs, sequence_length=length, dtype=tf.float32\n )\n states_fw, states_bw = states\n if rnn_type.endswith('lstm'):\n c_fw = [state_fw.c for state_fw in states_fw]\n h_fw = [state_fw.h for state_fw in states_fw]\n c_bw = [state_bw.c for state_bw in states_bw]\n h_bw = [state_bw.h for state_bw in states_bw]\n states_fw, states_bw = h_fw, h_bw\n if concat:\n outputs = tf.concat(outputs, 2)\n states = tf.concat([states_fw, states_bw], 1)\n else:\n outputs = outputs[0] + outputs[1]\n states = states_fw + states_bw\n return outputs, states","def add_dense_layer(self):\n output = self.cnn_layer\n # weight_shape is dimension 1 of the first weights in the dense layer. We\n # update it accordingly as we keep adding intermediate layers\n weight_shape = self.out_channels_2\n if self.hybrid:\n with tf.variable_scope(\"lstm_layer\"):\n print(\"adding Recurrent layer\")\n if self.rnn:\n print(\"Adding Basic RNN cell\")\n cell_fw = tf.contrib.rnn.BasicRNNCell(self.lstm_size)\n cell_bw = tf.contrib.rnn.BasicRNNCell(self.lstm_size)\n elif self.gru:\n print(\"Adding GRU cell\")\n cell_fw = tf.contrib.rnn.GRUCell(self.lstm_size)\n cell_bw = tf.contrib.rnn.GRUCell(self.lstm_size)\n elif self.elman:\n print(\"Adding ELMAN cell\")\n cell_fw = ElmanRNNCell(self.lstm_size)\n cell_bw = ElmanRNNCell(self.lstm_size)\n else:\n print(\"Adding LSTM cell\")\n cell_fw = tf.contrib.rnn.LSTMCell(self.lstm_size)\n cell_bw = tf.contrib.rnn.LSTMCell(self.lstm_size)\n if self.use_window_rnn:\n cnn_values = self.cnn_values\n print(\"using window_rnn\")\n else:\n print(\"not using window_rnn\")\n cnn_values = self.cnn_layer\n (output_fw, output_bw), _ = tf.nn.bidirectional_dynamic_rnn(\n cell_fw, cell_bw, cnn_values,\n sequence_length=self.sequence_lengths, dtype=tf.float32\n )\n output = tf.concat([output_fw, output_bw], axis=-1)\n output = tf.nn.dropout(output, self.dropout_holder)\n self.word_reps = output\n weight_shape = 2*self.lstm_size\n with tf.variable_scope(\"dense_layer\"):\n print(\"adding dense layer\")\n # weight_shape_2 is dimension 2 of the first weights in the dense layer.\n # we update it accordingly if we add more layers at the end\n weight_shape_2 = self.tag_count\n if self.pos and (self.single_ann or self.pos_ann):\n # this if block is for the cases when we have to concatenate the output\n # from prevoius layer to pos_embeddings\n print(\"Concatenating pos vecs with lstm/cnn output\")\n output = tf.concat([output, self.pos_vecs], axis=-1)\n weight_shape = weight_shape + self.pos_embedding_size\n output = tf.reshape(output, [-1, weight_shape])\n if self.single_ann:\n # This means we will have a hidden layer i.e two weights.\n print(\"Setting up hidden layer for single ann\")\n weight_shape_2 = self.ann_size\n if self.pos and not self.concat_pos and self.bi_ann:\n # this if block si for the case when we want to implement a bi-partite\n # ann, as such we will get weights for pos embeddings\n print(\"setting up network for bi ann..\")\n weight_shape_2 = self.ann_size\n w_pos = tf.get_variable(\"w_pos\", dtype=tf.float32,\n shape=[self.pos_embedding_size,\n self.pos_ann_count])\n b_pos = tf.get_variable(\"b_pos\", dtype=tf.float32,\n shape=[self.pos_ann_count],\n initializer=tf.zeros_initializer())\n output_pos = tf.reshape(self.pos_vecs, [-1, self.pos_embedding_size])\n pred_pos = tf.matmul(output_pos, w_pos) + b_pos\n output = tf.reshape(output, [-1, weight_shape])\n if len(output.shape) == 3:\n print(\"Setting up a network with no ann, only a fully connected dense \"\n \"layer\")\n # we have to reshape our output so that we can multiply it with weights.\n # if we reach here, it means we haven't reshaped it properly.\n output = tf.reshape(output, [-1, weight_shape])\n w1 = tf.get_variable(\"w1\", dtype=tf.float32,\n shape=[weight_shape, weight_shape_2])\n b1 = tf.get_variable(\"b1\", dtype=tf.float32, shape=[weight_shape_2],\n initializer=tf.zeros_initializer())\n pred = tf.matmul(output, w1) + b1\n # the pred above has weight_shape_2 as it's second dimension. our vars\n # have been defined in such a way that weight_shape_2 = self.tag_count if\n # we don't have to care about adding another layer.\n if self.pos and not self.concat_pos and self.bi_ann:\n # This block deals with concatenating output of pos hidden layer to\n # pred. We change weight_shape_2 accordingly.\n print(\"setting up network for bi ann..\")\n pred = tf.concat([pred, pred_pos], axis=-1)\n weight_shape_2 = weight_shape_2 + self.pos_ann_count\n\n if self.pos and (self.single_ann or self.bi_ann):\n # now, these are our final sets of weights in case we have an ann. so\n # the second dimension of these weights is self.tag_count!\n print(\"setting up network for ann\")\n w2 = tf.get_variable(\"w2\", dtype=tf.float32, shape=[weight_shape_2,\n self.tag_count])\n b2 = tf.get_variable(\"b2\", shape=[self.tag_count], dtype=tf.float32,\n initializer=tf.zeros_initializer())\n pred = tf.matmul(pred, w2) + b2\n self.logits = tf.reshape(pred, [-1, self.max_len, self.tag_count])","def apply_net_tiled(net,img):\n\n # borders = [8,20,20] ## border width within each patch that is thrown away after prediction\n # patchshape_padded = [32,240,240] ## the size of the patch that we feed into the net. must be divisible by 8 or net fails.\n # patchshape = [16,200,200] ## must be divisible by 8 to avoid artifacts.\n # stride = [16,200,200] ## same as patchshape in this case\n def f(n,m): return (ceil(n/m)*m)-n ## f(n,m) gives padding needed for n to be divisible by m\n def g(n,m): return (floor(n/m)*m)-n ## f(n,m) gives un-padding needed for n to be divisible by m\n\n a,b,c = img.shape[1:]\n q,r,s = f(a,8),f(b,8),f(c,8) ## calculate extra border needed for stride % 8 = 0\n\n ZPAD,YPAD,XPAD = 8,24,24\n\n img_padded = np.pad(img,[(0,0),(ZPAD,ZPAD+q),(YPAD,YPAD+r),(XPAD,XPAD+s)],mode='constant') ## pad for patch borders\n output = np.zeros(img.shape)\n\n zs = np.r_[:a:16]\n ys = np.r_[:b:200]\n xs = np.r_[:c:200]\n\n for x,y,z in itertools.product(xs,ys,zs):\n qe,re,se = min(z+16,a+q),min(y+200,b+r),min(x+200,c+s)\n ae,be,ce = min(z+16,a),min(y+200,b),min(x+200,c)\n patch = img_padded[:,z:qe+2*ZPAD,y:re+2*YPAD,x:se+2*XPAD]\n patch = torch.from_numpy(patch).cuda().float()\n patch = net(patch[None])[0,:,ZPAD:-ZPAD,YPAD:-YPAD,XPAD:-XPAD].detach().cpu().numpy()\n output[:,z:ae,y:be,x:ce] = patch[:,:ae-z,:be-y,:ce-x]\n\n return output","def n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs,\n activation, use_bi_direction, **kwargs): # NOQA\n\n argument.check_unexpected_kwargs(\n kwargs, train='train argument is not supported anymore. '\n 'Use chainer.using_config',\n use_cudnn='use_cudnn argument is not supported anymore. '\n 'Use chainer.using_config')\n argument.assert_kwargs_empty(kwargs)\n\n activation_list = ['tanh', 'relu']\n if activation not in activation_list:\n candidate = ','.join(activation_list)\n raise ValueError('Invalid activation: \"%s\". Please select from [%s]'\n % (activation, candidate))\n\n xp = cuda.get_array_module(hx)\n\n if xp is not numpy and chainer.should_use_cudnn('>=auto', 5000):\n states = get_random_state().create_dropout_states(dropout_ratio)\n lengths = [len(x) for x in xs]\n xs = chainer.functions.concat(xs, axis=0)\n\n rnn_mode = 'rnn_%s' % activation\n w = cudnn_rnn_weight_concat(\n n_layers, states, use_bi_direction, rnn_mode, ws, bs)\n\n if use_bi_direction:\n # Bi-directional RNN\n if activation == 'tanh':\n rnn = NStepBiRNNTanh\n elif activation == 'relu':\n rnn = NStepBiRNNReLU\n else:\n # Uni-directional RNN\n if activation == 'tanh':\n rnn = NStepRNNTanh\n elif activation == 'relu':\n rnn = NStepRNNReLU\n\n hy, ys = rnn(n_layers, states, lengths)(hx, w, xs)\n sections = numpy.cumsum(lengths[:-1])\n ys = chainer.functions.split_axis(ys, sections, 0)\n return hy, ys\n\n else:\n\n def f(x, h, c, w, b):\n xw, hw = w\n xb, hb = b\n rnn_in = linear.linear(x, xw, xb) + linear.linear(h, hw, hb)\n if activation == 'tanh':\n return tanh.tanh(rnn_in), None\n elif activation == 'relu':\n return relu.relu(rnn_in), None\n\n hy, _, ys = n_step_rnn_impl(\n f, n_layers, dropout_ratio, hx, None, ws, bs, xs, use_bi_direction)\n return hy, ys","def test_mismatched_starts(cell_cls):\n with tf.Graph().as_default():\n with tf.Session() as sess:\n pos_enc = positional_encoding(5, 6, dtype=tf.float64)\n in_seq = tf.get_variable('in_seq',\n shape=(3, 5, 6),\n initializer=tf.truncated_normal_initializer(),\n dtype=tf.float64)\n cell = cell_cls(pos_enc, num_layers=3, num_heads=2, hidden=24)\n _, states_1 = tf.nn.dynamic_rnn(cell, in_seq[:, :1], dtype=tf.float64)\n _, states_2 = tf.nn.dynamic_rnn(cell, in_seq[:, :2], dtype=tf.float64)\n _, states_3 = tf.nn.dynamic_rnn(cell, in_seq[:, :3], dtype=tf.float64)\n new_states = tuple(tf.stack([s2[0], s3[1], s1[2]], axis=0)\n for s1, s2, s3 in zip(states_1, states_2, states_3))\n\n full_seq, _ = tf.nn.dynamic_rnn(cell, in_seq, dtype=tf.float64)\n expected = tf.stack([full_seq[0, 2:4], full_seq[1, 3:5], full_seq[2, 1:3]], axis=0)\n\n inputs = tf.stack([in_seq[0, 2:4], in_seq[1, 3:5], in_seq[2, 1:3]], axis=0)\n actual, _ = tf.nn.dynamic_rnn(cell, inputs, initial_state=new_states)\n\n sess.run(tf.global_variables_initializer())\n\n actual, expected = sess.run((actual, expected))\n\n assert not np.isnan(actual).any()\n assert not np.isnan(expected).any()\n assert actual.shape == expected.shape\n assert np.allclose(actual, expected)","def build_resnet(self):\r\n\r\n # INPUTS\r\n inputs_data = Input((self.data_rows, self.data_cols, 1),name='inputs_data')\r\n\r\n\r\n def residual_block(input, output_channels=64, kernel_size=(3, 3), stride=(1, 1)):\r\n x = Conv2D(output_channels, kernel_size, padding='same', strides=stride)(input)\r\n x = BatchNormalization()(x)\r\n x = Activation('relu')(x)\r\n\r\n x = Conv2D(output_channels, kernel_size, padding='same', strides=stride)(x)\r\n x = BatchNormalization()(x)\r\n x = Activation('relu')(x)\r\n\r\n x = Add()([x, input])\r\n\r\n residual_block.counter += 1\r\n return x\r\n\r\n residual_block.counter = 0\r\n\r\n conv1=Conv2D(64,(3,3),strides=(1,1),padding='same',activation='relu')(inputs_data)\r\n res_block1=residual_block(conv1,output_channels=64)\r\n res_block2 =residual_block(res_block1, output_channels=64)\r\n res_block3 =residual_block(res_block2, output_channels=64)\r\n conv2=Conv2D(1,(3,3),strides=(1,1),padding='same')(res_block3)\r\n outputs=Add()([conv2,inputs_data])\r\n\r\n\r\n model = Model(inputs=inputs_data, outputs=outputs)\r\n\r\n\r\n return model","def build_lstm_cell(num_units, dropout):\n cell = tf.nn.rnn_cell.LSTMCell(num_units)\n if dropout:\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\n output_keep_prob=1-dropout)\n return result","def lstm_cell():\n if 'reuse' in inspect.getargspec(\n tf.contrib.rnn.BasicLSTMCell.__init__).args:\n return tf.contrib.rnn.BasicLSTMCell(\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True,\n reuse=tf.get_variable_scope().reuse)\n else:\n return tf.contrib.rnn.BasicLSTMCell(\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True)","def build_dynamic_rnn(self, cells, lstm_input, lstm_state):\n lstm_output, final_state = tf.nn.dynamic_rnn(cells, lstm_input, initial_state=lstm_state)\n # reshape lstm_output from [batch_size, time_steps, n_units] to [batch_size*time_steps, n_units]\n lstm_output = tf.reshape(lstm_output, [-1, self.num_hidden_units])\n\n return lstm_output, final_state","def separable_lstm2(cell, num_units, inputs, seq_lengths1, seq_lengths2, scope=None):\n with variable_scope.variable_scope(scope, \"SeparableLstm\", [inputs]):\n batch_size = tf.shape(inputs)[0]\n _, height, width, depth = _shape(inputs)\n reshaped = array_ops.reshape(inputs, [batch_size * width, height, depth])\n _, states = bidirectional_dynamic_rnn(\n cell(num_units), cell(num_units), reshaped, sequence_length=seq_lengths1, dtype=tf.float32)\n stacked_state = array_ops.concat(states, 1)\n with variable_scope.variable_scope(\"vertical\"):\n unpacked = array_ops.reshape(stacked_state, [batch_size, width, num_units*2])\n _, states = bidirectional_dynamic_rnn(\n cell(num_units), cell(num_units), unpacked, sequence_length=seq_lengths2, dtype=tf.float32)\n return array_ops.concat(states, 1)","def __init__(self,\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\n in2hid: tuple, in2out: tuple,\n hid2hid: tuple, hid2out: tuple,\n hidden_biases: np.ndarray, output_biases: np.ndarray,\n rnn_array: np.ndarray, rnn_map: np.ndarray,\n activation,\n batch_size: int = 1,\n initial_read: np.ndarray = None,\n dtype=np.float64,\n ):\n # Storing the input arguments (needed later on)\n self.act_f = activation\n self.dtype = dtype\n self.rnn_idx: np.ndarray = rnn_idx\n self.n_inputs: int = len(input_idx)\n self.n_hidden: int = len(hidden_idx)\n self.n_rnn: int = len(rnn_idx)\n self.n_outputs: int = len(output_idx)\n self.bs: int = batch_size\n \n # Setup the rnn_map\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\n for i, m in enumerate(rnn_map):\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\n \n # Placeholders, initialized during reset\n self.rnn_state: np.ndarray = None # State of the RNNs\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\n self.output_act: np.ndarray = None # Activations of the output nodes\n \n # Do not create the hidden-related matrices if hidden-nodes do not exist\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\n if self.n_hidden > 0:\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\n self.rnn_array: np.ndarray = rnn_array\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\n \n # Fill in the biases\n if self.n_hidden > 0:\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\n \n # Put network to initial (default) state\n self.reset(initial_read=initial_read)","def build_lstm_cell(size, keep_prob=None):\n encoder_cell = tf.contrib.rnn.LSTMCell(size)\n if keep_prob is not None:\n encoder_cell = tf.contrib.rnn.DropoutWrapper(\n encoder_cell, output_keep_prob=keep_prob)\n\n return encoder_cell"],"string":"[\n \"def _create_rnn_cells(self, is_list=False):\\n\\n stacked_rnn = []\\n for _ in range(self.num_layers):\\n single_cell = self._rnn_single_cell()\\n stacked_rnn.append(single_cell)\\n\\n if is_list:\\n return stacked_rnn\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(\\n cells=stacked_rnn,\\n state_is_tuple=True)\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, attn_len=0):\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = tf.contrib.rnn.LSTMBlockCell(layer_size)\\n if attn_len and not cells:\\n # Add attention wrapper to first layer.\\n cell = tf.contrib.rnn.AttentionCellWrapper(\\n cell, attn_len, state_is_tuple=True)\\n cell = tf.contrib.rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return tf.contrib.rnn.MultiRNNCell(cells)\",\n \"def rnn_cell(rnn_cell_size, dropout_keep_prob, is_training=True):\\n dropout_keep_prob = dropout_keep_prob if is_training else 1.0\\n cells = []\\n for layer_size in rnn_cell_size:\\n cell = rnn.LSTMBlockCell(layer_size)\\n cell = rnn.DropoutWrapper(\\n cell,\\n input_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n return rnn.MultiRNNCell(cells)\",\n \"def get_rnn_cells(self):\\n return [self.rnn]\",\n \"def MakeFancyRNNCell(H, keep_prob, num_layers=1):\\n cells = []\\n for _ in range(num_layers):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(H, forget_bias=0.0)\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cells.append(cell)\\n return tf.nn.rnn_cell.MultiRNNCell(cells)\",\n \"def get_rnn_cells(self) -> List[mx.rnn.BaseRNNCell]:\\n return self.forward_rnn.get_rnn_cells() + self.reverse_rnn.get_rnn_cells()\",\n \"def MakeFancyRNNCell(hidden_units, is_train, keep_prob, num_layers=1):\\n cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_units, forget_bias=0.0,state_is_tuple=True)\\n if is_train:\\n cell = tf.nn.rnn_cell.DropoutWrapper(cell, input_keep_prob=keep_prob, output_keep_prob=keep_prob)\\n cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)\\n return cell\",\n \"def _create_rnn_cell(num_units, num_layers, mode):\\n\\n cell_list = []\\n for i in range(num_layers):\\n single_cell = STLSTMCell(name=\\\"stlstm\\\",\\n num_units=num_units,\\n st_activation=tf.nn.relu,\\n st_kernel_initializer=tf.glorot_uniform_initializer(),\\n st_num_layers=2,\\n st_residual=True)\\n cell_list.append(single_cell)\\n\\n return cell_list\",\n \"def multi_batch_rnn(BaseEncoderClass):\\n class MultiBatchRNN(BaseEncoderClass):\\n def __init__(self, bptt, max_seq, *args, **kwargs):\\n self.max_seq = max_seq\\n self.bptt = bptt\\n super().__init__(*args, **kwargs)\\n\\n def concat(self, arrs):\\n return [torch.cat([l[si] for l in arrs]) for si in range(len(arrs[0]))]\\n\\n def forward(self, input):\\n sl, bs = input.size()\\n for l in self.hidden:\\n for h in l: h.data.zero_()\\n raw_outputs, outputs = [], []\\n for i in range(0, sl, self.bptt):\\n r, o = super().forward(input[i: min(i + self.bptt, sl)])\\n if i > (sl - self.max_seq):\\n raw_outputs.append(r)\\n outputs.append(o)\\n return self.concat(raw_outputs), self.concat(outputs)\\n return MultiBatchRNN\",\n \"def build_rnn(num_tokens, emb_size, cell, num_outputs=1):\\n emb_init, emb_apply = cells.embedding(num_tokens, emb_size)\\n readout_init, readout_apply = stax.Dense(num_outputs)\\n\\n def init_fun(key, input_shape):\\n \\\"\\\"\\\"Initialize the components of the RNN.\\n\\n Args:\\n key: Jax PRNGkey used to initialize the parameters.\\n input_shape: tuple representing the input shape, should be\\n (batch_size, sequence_length).\\n\\n Returns:\\n shapes: set of tuples representing the shapes after applying\\n the Embedding, RNN Cell, and Readout layers.\\n network_params: tuple of network parameters, containing the\\n embedding, RNN cell, and readout parameters.\\n \\\"\\\"\\\"\\n\\n emb_key, cell_key, readout_key = jax.random.split(key, 3)\\n\\n # Initialize the Embedding for the input tokens.\\n emb_shape, emb_params = emb_init(emb_key, input_shape)\\n\\n # The cell is defined for a single update step, which is why we ignore\\n # the sequence dimension (emb_shape[1]) here.\\n rnn_shape, rnn_params = cell.init(cell_key, (emb_shape[0], emb_shape[2]))\\n\\n output_shape, readout_params = readout_init(readout_key, rnn_shape)\\n\\n shapes = (emb_shape, rnn_shape, output_shape)\\n network_params = (emb_params, rnn_params, readout_params)\\n\\n return shapes, network_params\\n\\n def apply_fun(network_params, tokens):\\n \\\"\\\"\\\"Applies the RNN on a batch of input sequences.\\n\\n Args:\\n network_params: tuple of network parameters (see init_fun).\\n tokens: batch of inputs, with shape (batch_size, sequence_length).\\n\\n Returns:\\n outputs: network outputs, at every step along the sequence.\\n \\\"\\\"\\\"\\n emb_params, rnn_params, readout_params = network_params\\n\\n # Apply the embedding.\\n inputs = emb_apply(emb_params, tokens)\\n\\n # Run the RNN.\\n initial_states = cell.get_initial_state(rnn_params,\\n batch_size=tokens.shape[0])\\n return unroll.unroll_rnn(initial_states, inputs,\\n functools.partial(cell.batch_apply, rnn_params),\\n functools.partial(readout_apply, readout_params))\\n\\n return init_fun, apply_fun, emb_apply, readout_apply\",\n \"def _rnn_cells(self) -> RNNCellTuple:\\n return(RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size),\\n RNN_CELL_TYPES[self.rnn_cell_str](self.rnn_size))\",\n \"def build_rnn(cell, inputs):\\n #_,initial_state = get_init_cell(batch_size, rnn_size)\\n \\n output, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name='final_state')\\n\\n return (output, final_state)\",\n \"def build_rnn(cell, inputs):\\n outputs, final_state = tf.nn.dynamic_rnn(cell, inputs, dtype=tf.float32)\\n final_state = tf.identity(final_state, name=\\\"final_state\\\")\\n\\n return outputs, final_state\",\n \"def rnn_cell_loop(self):\\n\\n\\t\\t# Set up initial state\\n\\t\\tself.h_out = [tf.zeros([par['batch_size'],par['n_hidden']])]\\t\\t\\t# Spike\\n\\t\\tself.h = tf.ones([par['batch_size'],par['n_hidden']])\\t\\t\\t\\t\\t# State\\n\\t\\tself.h *= 0.1 if par['cell_type'] == 'rate' else par[par['cell_type']]['V_r']\\n\\t\\tself.h = [self.h]\\n\\t\\tadapt = par['w_init']*tf.ones([par['batch_size'],par['n_hidden']])\\n\\n\\t\\tsyn_x = par['syn_x_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\t\\tsyn_u = par['syn_u_init']*tf.ones([par['batch_size'], par['n_hidden']]) if par['use_stp'] else None\\n\\n\\t\\t# Apply the EI mask to the recurrent weights\\n\\t\\tself.W_rnn_effective = par['EI_matrix'] @ tf.nn.relu(self.var_dict['W_rnn'])\\n\\n\\t\\t# Set up latency buffer if being used\\n\\t\\tif par['use_latency']:\\n\\t\\t\\tself.state_buffer = [tf.zeros([par['batch_size'], par['n_hidden']]) for t in range(par['latency_max'])]\\n\\t\\t\\tself.state_buffer = deque(self.state_buffer)\\n\\t\\t\\tself.W_rnn_latency = self.W_rnn_effective[tf.newaxis,...] * par['latency_mask']\\n\\t\\t\\tself.lat_spike_shape = tf.ones([par['latency_max'], 1, 1])\\n\\n\\t\\t# Set up output record\\n\\t\\tself.output = []\\n\\t\\tself.syn_x = []\\n\\t\\tself.syn_u = []\\n\\n\\t\\ty = 0.\\n\\t\\tfor t in range(par['num_time_steps']):\\n\\t\\t\\tself.t = t \\t\\t# For latency calculations\\n\\n\\t\\t\\tif par['cell_type'] == 'rate':\\n\\t\\t\\t\\traise Exception('Rate cell not yet implemented.')\\n\\t\\t\\telif par['cell_type'] == 'adex':\\n\\t\\t\\t\\tif t < 10:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(tf.zeros_like(self.h_out[-1]), self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.AdEx_cell(self.h_out[-10], self.h[-1], \\\\\\n\\t\\t\\t\\t\\t\\tadapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*(spike @ self.var_dict['W_out'] + self.var_dict['b_out'])\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\t\\t\\t\\tself.syn_x.append(syn_x)\\n\\t\\t\\t\\tself.syn_u.append(syn_u)\\n\\n\\t\\t\\telif par['cell_type'] == 'lif':\\n\\t\\t\\t\\tspike, state, adapt, syn_x, syn_u = self.LIF_cell(self.h_out[-1], self.h[-1], adapt, self.input_data[t], syn_x, syn_u)\\n\\t\\t\\t\\ty = 0.95*y + 0.05*spike @ self.var_dict['W_out'] + 0.*self.var_dict['b_out']\\n\\n\\t\\t\\t\\tself.h_out.append(spike)\\n\\t\\t\\t\\tself.h.append(state)\\n\\t\\t\\t\\tself.output.append(y)\\n\\n\\t\\t# Stack records\\n\\t\\tself.output = tf.stack(self.output, axis=0)\\n\\t\\tself.h = tf.stack(self.h, axis=0)\\n\\t\\tself.h_out = tf.stack(self.h_out, axis=0)\\n\\t\\tself.syn_x = tf.stack(self.syn_x, axis=0)\\n\\t\\tself.syn_u = tf.stack(self.syn_u, axis=0)\",\n \"def custom_rnn(cell, inputs, initial_state=None, dtype=None,\\r\\n sequence_length=None, scope=None):\\r\\n\\r\\n if not isinstance(cell, tf.compat.v1.nn.rnn_cell.RNNCell):\\r\\n raise TypeError(\\\"cell must be an instance of RNNCell\\\")\\r\\n if not nest.is_sequence(inputs):\\r\\n raise TypeError(\\\"inputs must be a sequence\\\")\\r\\n if not inputs:\\r\\n raise ValueError(\\\"inputs must not be empty\\\")\\r\\n\\r\\n outputs = []\\r\\n states = []\\r\\n # Create a new scope in which the caching device is either\\r\\n # determined by the parent scope, or is set to place the cached\\r\\n # Variable using the same placement as for the rest of the RNN.\\r\\n with vs.variable_scope(scope or \\\"RNN\\\") as varscope:\\r\\n if varscope.caching_device is None:\\r\\n varscope.set_caching_device(lambda op: op.device)\\r\\n\\r\\n # Obtain the first sequence of the input\\r\\n first_input = inputs\\r\\n while nest.is_sequence(first_input):\\r\\n first_input = first_input[0]\\r\\n\\r\\n # Temporarily avoid EmbeddingWrapper and seq2seq badness\\r\\n # TODO(lukaszkaiser): remove EmbeddingWrapper\\r\\n if first_input.get_shape().ndims != 1:\\r\\n\\r\\n input_shape = first_input.get_shape().with_rank_at_least(2)\\r\\n fixed_batch_size = input_shape[0]\\r\\n\\r\\n flat_inputs = nest.flatten(inputs)\\r\\n for flat_input in flat_inputs:\\r\\n input_shape = flat_input.get_shape().with_rank_at_least(2)\\r\\n batch_size, input_size = input_shape[0], input_shape[1:]\\r\\n fixed_batch_size.merge_with(batch_size)\\r\\n for i, size in enumerate(input_size):\\r\\n if size.value is None:\\r\\n raise ValueError(\\r\\n \\\"Input size (dimension %d of inputs) must be accessible via \\\"\\r\\n \\\"shape inference, but saw value None.\\\" % i)\\r\\n else:\\r\\n fixed_batch_size = first_input.get_shape().with_rank_at_least(1)[0]\\r\\n\\r\\n if fixed_batch_size.value:\\r\\n batch_size = fixed_batch_size.value\\r\\n else:\\r\\n batch_size = array_ops.shape(first_input)[0]\\r\\n if initial_state is not None:\\r\\n state = initial_state\\r\\n else:\\r\\n if not dtype:\\r\\n raise ValueError(\\\"If no initial_state is provided, \\\"\\r\\n \\\"dtype must be specified\\\")\\r\\n state = cell.zero_state(batch_size, dtype)\\r\\n\\r\\n if sequence_length is not None: # Prepare variables\\r\\n sequence_length = ops.convert_to_tensor(\\r\\n sequence_length, name=\\\"sequence_length\\\")\\r\\n if sequence_length.get_shape().ndims not in (None, 1):\\r\\n raise ValueError(\\r\\n \\\"sequence_length must be a vector of length batch_size\\\")\\r\\n def _create_zero_output(output_size):\\r\\n # convert int to TensorShape if necessary\\r\\n size = _state_size_with_prefix(output_size, prefix=[batch_size])\\r\\n output = array_ops.zeros(\\r\\n array_ops.pack(size), _infer_state_dtype(dtype, state))\\r\\n shape = _state_size_with_prefix(\\r\\n output_size, prefix=[fixed_batch_size.value])\\r\\n output.set_shape(tensor_shape.TensorShape(shape))\\r\\n return output\\r\\n\\r\\n output_size = cell.output_size\\r\\n flat_output_size = nest.flatten(output_size)\\r\\n flat_zero_output = tuple(\\r\\n _create_zero_output(size) for size in flat_output_size)\\r\\n zero_output = nest.pack_sequence_as(structure=output_size,\\r\\n flat_sequence=flat_zero_output)\\r\\n\\r\\n sequence_length = math_ops.to_int32(sequence_length)\\r\\n min_sequence_length = math_ops.reduce_min(sequence_length)\\r\\n max_sequence_length = math_ops.reduce_max(sequence_length)\\r\\n\\r\\n for time, input_ in enumerate(inputs):\\r\\n if time > 0: varscope.reuse_variables()\\r\\n # pylint: disable=cell-var-from-loop\\r\\n call_cell = lambda: cell(input_, state)\\r\\n # pylint: enable=cell-var-from-loop\\r\\n if sequence_length is not None:\\r\\n (output, state) = _rnn_step(\\r\\n time=time,\\r\\n sequence_length=sequence_length,\\r\\n min_sequence_length=min_sequence_length,\\r\\n max_sequence_length=max_sequence_length,\\r\\n zero_output=zero_output,\\r\\n state=state,\\r\\n call_cell=call_cell,\\r\\n state_size=cell.state_size)\\r\\n else:\\r\\n (output, state) = call_cell()\\r\\n\\r\\n outputs.append(output)\\r\\n states.append(state)\\r\\n\\r\\n return (outputs, state, states)\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embed = get_embed(input_data, vocab_size, embed_dim) \\n output, final_state = build_rnn(cell, embed)\\n \\n logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn=None)\\n #final_state = tf.identity(final_state, name='final_state') \\n return logits, final_state\",\n \"def rnn(rnn_cell, X, h_0):\\n t, m, i = X.shape\\n h1, h = h_0.shape\\n H = np.zeros((t + 1, h1, h))\\n # print(\\\"HHH\\\", H.shape)\\n H[-1] = np.zeros(h)\\n Y = np.zeros((t, i))\\n Y = []\\n # print(\\\"XXX\\\", X.shape)\\n # print('this shape?', X.shape)\\n # print(\\\"YYY\\\", Y.shape)\\n h_next = h_0\\n for ti in range(t):\\n H[ti + 1], y = rnn_cell.forward(h_next, X[ti])\\n h_next = H[ti + 1]\\n Y.append(y)\\n return H, np.array(Y)\",\n \"def create_rnn_cell(num_units,\\n num_layers,\\n num_residual_layers,\\n dropout,\\n mode,\\n num_gpus,\\n base_gpu=0,\\n single_cell_fn=None,\\n all_layer_outputs=False):\\n cell_list = _cell_list(\\n num_units=num_units,\\n num_layers=num_layers,\\n num_residual_layers=num_residual_layers,\\n dropout=dropout,\\n mode=mode,\\n num_gpus=num_gpus,\\n base_gpu=base_gpu,\\n single_cell_fn=single_cell_fn)\\n\\n if len(cell_list) == 1: # Single layer.\\n return cell_list[0]\\n else: # Multi layers\\n print(all_layer_outputs, \\\"all_layer_outputs\\\")\\n\\n if all_layer_outputs:\\n return MultiRNNCell(cell_list)\\n else:\\n return tf.nn.rnn_cell.MultiRNNCell(cell_list)\",\n \"def build_rnn_cell(type, num_units, dropout):\\n cell = tf.nn.rnn_cell.BasicRNNCell(num_units)\\n if dropout:\\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\\n output_keep_prob=1-dropout)\\n return result\",\n \"def rnn_cell(rnn_cell_dim, layer_type, dropout_keep_prob=1.0):\\n if layer_type == \\\"layernorm_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units=rnn_cell_dim, dropout_keep_prob=dropout_keep_prob)\\n else:\\n if layer_type == \\\"lstm\\\":\\n cell = tf.nn.rnn_cell.BasicLSTMCell(rnn_cell_dim)\\n elif layer_type == \\\"gru\\\":\\n cell = tf.nn.rnn_cell.GRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_gru\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleGRUCell(rnn_cell_dim)\\n elif layer_type == \\\"cudnn_lstm\\\":\\n # pylint: disable=no-member\\n cell = tf.contrib.cudnn_rnn.CudnnCompatibleLSTMCell(rnn_cell_dim)\\n else:\\n raise ValueError(\\\"Error: not supported rnn type:{}\\\".format(layer_type))\\n\\n cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell, output_keep_prob=dropout_keep_prob)\\n return cell\",\n \"def _dynamic_rnn_loop(cell: RNNCellBase[State], inputs: torch.Tensor, initial_state: State, sequence_length: torch.LongTensor) ->Tuple[torch.Tensor, State]:\\n state = initial_state\\n time_steps = inputs.shape[0]\\n all_outputs = []\\n all_state = map_structure(lambda _: no_map(list), state)\\n for i in range(time_steps):\\n output, state = cell(inputs[i], state)\\n all_outputs.append(output)\\n map_structure_zip(lambda xs, x: xs.append(x), (all_state, state))\\n final_outputs = torch.stack(all_outputs, dim=0)\\n final_outputs = mask_sequences(final_outputs, sequence_length=sequence_length, time_major=True)\\n final_state = map_structure(lambda _: no_map(list), state)\\n for batch_idx, time_idx in enumerate(sequence_length.tolist()):\\n if time_idx > 0:\\n map_structure_zip(lambda xs, x: xs.append(x[time_idx - 1][batch_idx]), (final_state, all_state))\\n else:\\n map_structure_zip(lambda xs, x: xs.append(x[batch_idx]), (final_state, initial_state))\\n final_state = map_structure(lambda x: torch.stack(x, dim=0), final_state)\\n return final_outputs, final_state\",\n \"def get_init_cell(batch_size, rnn_size):\\n\\n cell = tf.contrib.rnn.BasicLSTMCell(rnn_size) #?????????????????cell_hidden_size = state_size\\n #cell = tf.contrib.run.DropoutWrapper(cell, output_keep_prob=keep_prob)\\n num_of_layers = 3\\n cell = tf.contrib.rnn.MultiRNNCell([cell for _ in range(num_of_layers)])\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name='initial_state')\\n \\n return (cell, initial_state)\",\n \"def build_nn(cell, input_data, vocab_size, embed_dim, initial_state):\\n # todo 1、获取嵌入层的输出\\n embed = get_embed(input_data, vocab_size, embed_dim)\\n # todo-2、获取 隐藏层的输出\\n rnn_outputs, final_state, final_state1 = build_rnn(\\n cell, embed, initial_state=initial_state)\\n # 3、构建全连接，获取logits\\n # 该api接受3-d 的张量，会拉成2-d矩阵，做全连接获得2-d的logits后，再转置为3-D的logits（shape = [批量， 时间步， 类别数量]）\\n logits = tf.contrib.layers.fully_connected(rnn_outputs, vocab_size, activation_fn=None)\\n # [N, n-steps, num_classes]\\n return logits, final_state, final_state1\",\n \"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n embedding = get_embed(input_data, vocab_size, rnn_size)\\n outputs, final_state = build_rnn(cell, embedding)\\n logits = tf.contrib.layers.fully_connected(outputs, vocab_size, activation_fn=None)\\n\\n return logits, final_state\",\n \"def __init__(self, input_size, hidden_size, output_size, model=\\\"gru\\\", n_layers=1):\\n \\n super(CharRNN, self).__init__()\\n\\n self.input_size = input_size\\n self.hidden_size = hidden_size\\n self.output_size = output_size\\n self.n_layers = n_layers\\n\\n self.embedding = nn.Embedding(input_size, hidden_size) # sparse word embedding\\n \\n self.model = model\\n if model.lower() == \\\"lstm\\\":\\n self.cell = nn.LSTM(hidden_size, hidden_size, n_layers)\\n else: # model is GRU\\n self.cell = nn.GRU(hidden_size, hidden_size, n_layers) # GRU unit\\n\\n self.linear = nn.Linear(hidden_size, output_size) # Fully connected layer\",\n \"def _rnn_layer(input_data, rnn_cell, rnn_hidden_size, layer_id, rnn_activation,\\n is_batch_norm, is_bidirectional):\\n if is_batch_norm:\\n input_data = tf.keras.layers.BatchNormalization(\\n momentum=_MOMENTUM, epsilon=_EPSILON)(input_data)\\n rnn_layer = rnn_cell(\\n rnn_hidden_size, activation=rnn_activation, return_sequences=True,\\n name=\\\"rnn_{}\\\".format(layer_id))\\n if is_bidirectional:\\n rnn_layer = tf.keras.layers.Bidirectional(rnn_layer, merge_mode=\\\"sum\\\")\\n\\n return rnn_layer(input_data)\",\n \"def encoder_one_way(self, cell, x, seq_len, init_state=None):\\n # Output is the outputs at all time steps, state is the last state\\n with tf.variable_scope(\\\"dynamic_rnn\\\"):\\n outputs, state = tf.nn.dynamic_rnn(\\\\\\n cell, x, sequence_length=seq_len, initial_state=init_state,\\n dtype=self.floatX)\\n # state is a StateTuple class with properties StateTuple.c and StateTuple.h\\n return outputs, state\",\n \"def cell_edges(self):\",\n \"def _build_rnn(self, n_cells, hidden_layer_size, num_layers,\\n batch_size, time_window, lr):\\n\\n x_anchor = tf.placeholder(shape=[batch_size, n_cells, time_window],\\n dtype=tf.float32)\\n x_pos = tf.placeholder(shape=[batch_size, n_cells, time_window],\\n dtype=tf.float32)\\n x_neg = tf.placeholder(shape=[batch_size, n_cells, time_window,],\\n dtype=tf.float32)\\n\\n def embed_rnn(x_in):\\n \\\"\\\"\\\"Gives RNN embedding of x_in.\\\"\\\"\\\"\\n x_in_flat = tf.reshape(x_in, [batch_size*time_window, n_cells])\\n w_in = tf.get_variable(\\\"w_in\\\", shape=[n_cells, hidden_layer_size],\\n initializer=tf.random_normal_initializer())\\n b_in = tf.get_variable(\\\"b_in\\\", shape=[hidden_layer_size],\\n initializer=tf.random_normal_initializer())\\n x_ld_flat = tf.matmul(x_in_flat, w_in) + b_in\\n x_ld = tf.reshape(x_ld_flat, [batch_size, time_window, hidden_layer_size])\\n\\n # stacked LSTM cells\\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_layer_size,\\n forget_bias=0.0,\\n state_is_tuple=True)\\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers,\\n state_is_tuple=True)\\n\\n # compute output\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n outputs, _ = tf.nn.dynamic_rnn(cell, x_ld,\\n initial_state=initial_state,\\n time_major=False)\\n\\n # reconstruct and compute loss on last output only\\n outputs_unp = tf.unpack(tf.transpose(outputs, [1, 0, 2]))\\n embedding = outputs_unp[-1]\\n\\n return embedding\\n\\n def distance_squared(embed1, embed2):\\n return tf.reduce_sum((embed1 - embed2)**2, 1)\\n\\n with tf.variable_scope(\\\"RNN\\\") as scope:\\n\\n # embed anchor, positive and negative examples.\\n embed_anchor = embed_rnn(tf.transpose(x_anchor, [0, 2, 1]))\\n # This enables reusing the RNN for anchor, pos and neg.\\n scope.reuse_variables()\\n # Check that we are reusing the same RNN using:\\n # print(tf.get_variable_scope().reuse)\\n embed_pos = embed_rnn(tf.transpose(x_pos, [0, 2, 1]))\\n embed_neg = embed_rnn(tf.transpose(x_neg, [0, 2, 1]))\\n\\n # Loss for each point max(d(anchor, pos)^2 - d(anchor, neg)^2 + 1, 0)\\n loss = tf.reduce_sum(tf.nn.relu(distance_squared(embed_anchor,\\n embed_pos) -\\n distance_squared(embed_anchor,\\n embed_neg)\\n + 1), 0)\\n # train model\\n train_step = tf.train.AdagradOptimizer(lr).minimize(loss)\\n\\n return (x_anchor, x_pos, x_neg, train_step, loss,\\n embed_anchor, embed_pos, embed_neg)\",\n \"def add_model(self, inputs):\\n size = self.config.hidden_size\\n forget_bias = self.config.forget_bias\\n input_cell = self.config.input_cell\\n\\n if input_cell == 'BasicLSTMCell':\\n lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias)\\n print 'Using Basic LSTM Cell \\\\n'\\n\\n elif input_cell == 'LSTMCell':\\n lstm_cell = tf.nn.rnn_cell.LSTMCell(size, forget_bias)\\n print 'Using LSTM Cell \\\\n'\\n\\n elif input_cell == 'GRUCell':\\n lstm_cell = tf.nn.rnn_cell.GRUCell(size)\\n print 'Using GRU Cell \\\\n'\\n\\n else:\\n print \\\"Please Specify a Correct Cell Type\\\"\\n\\n lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self.config.dropout,\\n input_keep_prob=self.config.dropout)\\n\\n cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self.config.num_layers)\\n \\n print 'Number of Hidden Layers ', self.config.num_layers\\n \\n self.initial_state = cell.zero_state(self.config.batch_size, tf.float32)\\n rnn_outputs = []\\n state = self.initial_state\\n\\n with tf.variable_scope('RNNLM') as scope:\\n for time_step in range(self.config.num_steps):\\n if time_step > 0: scope.reuse_variables()\\n (cell_output, state) = cell(inputs[:, time_step, :], state)\\n rnn_outputs.append(cell_output)\\n self.final_state = state\\n\\n return rnn_outputs\",\n \"def get_init_cell(batch_size, rnn_size):\\n lstm = tf.contrib.rnn.BasicLSTMCell(rnn_size)\\n #drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=0.5)\\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * 3)\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n initial_state = tf.identity(initial_state, name=\\\"initial_state\\\")\\n\\n return cell, initial_state\",\n \"def deep_rnn(rnn_cells, X, h_0):\\n T, m, i = X.shape\\n layers, _, h = h_0.shape\\n H = np.zeros((T + 1, layers, m, h))\\n Y = np.zeros((T, m, rnn_cells[-1].Wy.shape[1]))\\n H[0] = h_0\\n for t in range(T):\\n H[t + 1, 0], Y[t] = rnn_cells[0].forward(H[t, 0], X[t])\\n for layer in range(1, layers):\\n rnn = rnn_cells[layer]\\n H[t + 1, layer], Y[t] = rnn.forward(H[t, layer],\\n H[t + 1, layer - 1])\\n return H, Y\",\n \"def rnn_cell(hprev, zt, name=None, reuse=False):\\n nin = zt.shape[-1].value\\n nout = hprev.shape[-1].value\\n with tf.variable_scope(name, default_name=\\\"rnn\\\", values=[hprev, zt], reuse=reuse):\\n wz = get_variable_wrap(\\\"kernel/input\\\", [nin, nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n wh = get_variable_wrap(\\\"kernel/hidden\\\", [nout, nout],dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n bh = get_variable_wrap(\\\"bias\\\", [nout], dtype=tf.float32, \\n initializer=tf.random_normal_initializer(0, 0.01))\\n \\n return tf.tanh(ed.dot(hprev, wh) + ed.dot(zt, wz) + bh)\",\n \"def __init__(self,input_dim, hidden_dim, kernel_sizes, num_layers,gb_hidden_size):\\r\\n\\r\\n super().__init__()\\r\\n\\r\\n self.input_size = input_dim\\r\\n self.input_dim =input_dim\\r\\n\\r\\n if type(hidden_dim) != list:\\r\\n self.hidden_sizes = [hidden_dim]*num_layers\\r\\n else:\\r\\n assert len(hidden_dim) == num_layers, '`hidden_sizes` must have the same length as n_layers'\\r\\n self.hidden_sizes = hidden_dim\\r\\n if type(kernel_sizes) != list:\\r\\n self.kernel_sizes = [kernel_sizes]*num_layers\\r\\n else:\\r\\n assert len(kernel_sizes) == num_layers, '`kernel_sizes` must have the same length as n_layers'\\r\\n self.kernel_sizes = kernel_sizes\\r\\n\\r\\n self.n_layers = num_layers\\r\\n\\r\\n cells = nn.ModuleList()\\r\\n squenceCells=nn.ModuleList()\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n if i == 0:\\r\\n input_dim = self.input_size\\r\\n else:\\r\\n input_dim = self.hidden_sizes[i-1]\\r\\n\\r\\n cell = ConvGRUCell(self.input_dim[i], self.hidden_sizes[i], 3)\\r\\n\\r\\n cells.append(cell)\\r\\n\\r\\n self.cells = cells\\r\\n\\r\\n\\r\\n for i in range(self.n_layers):\\r\\n\\r\\n squenceCell = SequenceGRU(gb_hidden_size[i])\\r\\n\\r\\n squenceCells.append(squenceCell)\\r\\n\\r\\n self.squenceCells = squenceCells\",\n \"def encode_sequence(sequence, rnns, embedder, dropout_amount=0.):\\n\\n batch_size = 1\\n layer_states = []\\n for rnn in rnns:\\n hidden_size = rnn.weight_hh.size()[1]\\n \\n # h_0 of shape (batch, hidden_size)\\n # c_0 of shape (batch, hidden_size)\\n if rnn.weight_hh.is_cuda:\\n h_0 = torch.cuda.FloatTensor(batch_size,hidden_size).fill_(0)\\n c_0 = torch.cuda.FloatTensor(batch_size,hidden_size).fill_(0)\\n else:\\n h_0 = torch.zeros(batch_size,hidden_size)\\n c_0 = torch.zeros(batch_size,hidden_size)\\n\\n layer_states.append((h_0, c_0))\\n\\n outputs = []\\n for token in sequence:\\n rnn_input = embedder(token)\\n (cell_states, hidden_states), output, layer_states = forward_one_multilayer(rnns,rnn_input,layer_states,dropout_amount)\\n\\n outputs.append(output)\\n\\n return (cell_states, hidden_states), outputs\",\n \"def __init__(self, cell, attn_inputs, \\n attn_size, attn_vec_size,\\n output_size=None, input_size=None, \\n state_is_tuple=True, attn_masks=None,\\n merge_output_attn='linear',\\n reuse=None):\\n if not isinstance(cell, rnn.RNNCell):\\n raise TypeError(\\\"The parameter cell is not RNNCell.\\\")\\n if nest.is_sequence(cell.state_size) and not state_is_tuple:\\n raise ValueError(\\\"Cell returns tuple of states, but the flag \\\"\\n \\\"state_is_tuple is not set. State size is: %s\\\"\\n % str(cell.state_size))\\n if not state_is_tuple:\\n logging.warn(\\n \\\"%s: Using a concatenated state is slower and will soon be \\\"\\n \\\"deprecated. Use state_is_tuple=True.\\\", self)\\n\\n self._state_is_tuple = state_is_tuple\\n\\n if not state_is_tuple:\\n raise NotImplementedError\\n\\n self._cell = cell\\n self._input_size = input_size\\n self._output_size = output_size\\n if output_size is None:\\n self._output_size = cell.output_size\\n self._attn_size = attn_size\\n self._reuse = reuse\\n self._attn_inputs = attn_inputs\\n self._attn_vec_size = attn_vec_size\\n self.attn_masks = attn_masks\\n self.merge_output_attn = merge_output_attn\",\n \"def get_cell(rnn_type, hidden_size, layer_num=1, dropout_keep_prob=None):\\n cells = []\\n for i in range(layer_num):\\n if rnn_type.endswith('lstm'):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n elif rnn_type.endswith('gru'):\\n cell = tc.rnn.GRUCell(num_units=hidden_size)\\n elif rnn_type.endswith('rnn'):\\n cell = tc.rnn.BasicRNNCell(num_units=hidden_size)\\n else:\\n raise NotImplementedError('Unsuported rnn type: {}'.format(rnn_type))\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\\n return cells\",\n \"def __init__(self, rnn_cell, batch_size,\\n input_size, num_outputs):\\n super().__init__(name='RNNCellStateModel')\\n self._rnn_cell = rnn_cell\\n self._batch_size = batch_size\\n self._input_size = input_size\\n self._num_outputs = num_outputs\",\n \"def get_rnn(X, rnn_size, seq_len, batch_size, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0, is_training=False,\\n cell_name=\\\"BasicLSTM\\\", bidirectional=False):\\n with tf.device(\\\"/cpu:0\\\"):\\n # Convert input tensor to python list (along the sequence length dimention)\\n word_embeddings = tf.split(1, seq_len, X)\\n word_embeddings = [tf.squeeze(embed_, [1]) for embed_ in word_embeddings]\\n\\n # if is_training and keep_prob < 1:\\n # word_embeddings = [tf.nn.dropout(input_, keep_prob) for input_ in word_embeddings]\\n\\n def get_cell():\\n if cell_name == \\\"GRU\\\": # GRU\\n cell = rnn_cell.GRUCell(rnn_size)\\n elif cell_name == \\\"LSTM\\\": # LSTM\\n cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\\n else:\\n cell = rnn_cell.BasicLSTMCell(rnn_size)\\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\\n cell = rnn_cell.DropoutWrapper(cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\\n cell = rnn_cell.MultiRNNCell([cell] * num_layers)\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n return cell, initial_state\\n\\n if bidirectional:\\n with tf.variable_scope(\\\"forward\\\"):\\n cell_fw, initial_state_fw = get_cell()\\n with tf.variable_scope(\\\"backward\\\"):\\n cell_bw, initial_state_bw = get_cell()\\n return rnn.bidirectional_rnn(cell_fw, cell_bw, word_embeddings,\\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw)\\n else:\\n cell, initial_state = get_cell()\\n return rnn.rnn(cell, word_embeddings, initial_state=initial_state)\",\n \"def _propagate(dim_indices, conf, cells, c_prev, m_prev, new_output, new_state,\\n first_call):\\n if len(dim_indices) == 0:\\n return\\n\\n # Because of the way RNNCells are implemented, we take the last dimension\\n # (H_{N-1}) out and feed it as the state of the RNN cell\\n # (in `last_dim_output`).\\n # The input of the cell (H_0 to H_{N-2}) are concatenated into `cell_inputs`\\n if conf.num_dims > 1:\\n ls_cell_inputs = [None] * (conf.num_dims - 1)\\n for d in conf.dims[:-1]:\\n if new_output[d.idx] is None:\\n ls_cell_inputs[d.idx] = m_prev[d.idx]\\n else:\\n ls_cell_inputs[d.idx] = new_output[d.idx]\\n cell_inputs = array_ops.concat(ls_cell_inputs, 1)\\n else:\\n cell_inputs = array_ops.zeros([m_prev[0].get_shape().as_list()[0], 0],\\n m_prev[0].dtype)\\n\\n last_dim_output = (new_output[-1]\\n if new_output[-1] is not None else m_prev[-1])\\n\\n for i in dim_indices:\\n d = conf.dims[i]\\n if d.non_recurrent_fn:\\n if conf.num_dims > 1:\\n linear_args = array_ops.concat([cell_inputs, last_dim_output], 1)\\n else:\\n linear_args = last_dim_output\\n with vs.variable_scope('non_recurrent' if conf.tied else\\n 'non_recurrent/cell_{}'.format(i)):\\n if conf.tied and not (first_call and i == dim_indices[0]):\\n vs.get_variable_scope().reuse_variables()\\n\\n new_output[d.idx] = layers.fully_connected(\\n linear_args,\\n num_outputs=conf.num_units,\\n activation_fn=d.non_recurrent_fn,\\n weights_initializer=(vs.get_variable_scope().initializer or\\n layers.initializers.xavier_initializer),\\n weights_regularizer=vs.get_variable_scope().regularizer)\\n else:\\n if c_prev[i] is not None:\\n cell_state = (c_prev[i], last_dim_output)\\n else:\\n # for GRU/RNN, the state is just the previous output\\n cell_state = last_dim_output\\n\\n with vs.variable_scope('recurrent' if conf.tied else\\n 'recurrent/cell_{}'.format(i)):\\n if conf.tied and not (first_call and i == dim_indices[0]):\\n vs.get_variable_scope().reuse_variables()\\n cell = cells[i]\\n new_output[d.idx], new_state[d.idx] = cell(cell_inputs, cell_state)\",\n \"def get_cell(self, hidden_size, layer_num=1, dropout_keep_prob=None):\\n cells = []\\n for i in range(layer_num):\\n cell = tc.rnn.LSTMCell(num_units=hidden_size, state_is_tuple=True)\\n if dropout_keep_prob is not None:\\n cell = tc.rnn.DropoutWrapper(cell,\\n input_keep_prob=dropout_keep_prob,\\n output_keep_prob=dropout_keep_prob)\\n cells.append(cell)\\n cells = tc.rnn.MultiRNNCell(cells, state_is_tuple=True)\\n return cells\",\n \"def build_rnn(x, h, output_size, scope, n_layers, size, gru_size, activation=tf.tanh, output_activation=None, regularizer=None):\\n #====================================================================================#\\n # ----------PROBLEM 2----------\\n #====================================================================================#\\n # YOUR CODE HERE\\n # raise NotImplementedError\\n with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):\\n ## step 1 - inputs are first embedded by an MLP\\n x = build_mlp(x, output_size, scope, n_layers, size, activation=activation, output_activation=output_activation, regularizer=regularizer)\\n # print(\\\"after build_mlp x = \\\", x)\\n ## step 2 - passed to a GRU cell\\n # as \\\"sy_hidden = tf.placeholder(shape=[None, self.gru_size], name=\\\"hidden\\\", dtype=tf.float32)\\\" -> h, so we can only pass for 1 single GRUCell, if multiple CRUCell, hidden state will be agumented.\\n # as x is the size of (?, output_size) in output of build_mlp, the rnn must be equal with size\\n x, h = tf.nn.dynamic_rnn(tf.nn.rnn_cell.GRUCell(output_size, activation=activation), x, initial_state=h)\\n # after build_mlp x = Tensor(\\\"continuous_logits/continuous_logits/fc1/BiasAdd:0\\\", shape=(?, 1, 32), dtype=float32)\\n # x = tf.squeeze(x, axis=1)\\n x = tf.reshape(x, (-1, x.get_shape()[1]*x.get_shape()[2]))\\n # print(\\\"dynamic_rnn build_mlp x = \\\", x, \\\" h = \\\", h)\\n return x, h\",\n \"def custom_dynamic_rnn(cell, inputs, inputs_len, initial_state=None):\\n batch_size = tf.shape(inputs)[0]\\n max_time = tf.shape(inputs)[1]\\n\\n inputs_ta = tf.TensorArray(dtype=tf.float32, size=max_time)\\n inputs_ta = inputs_ta.unstack(tf.transpose(inputs, [1, 0, 2]))\\n emit_ta = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0)\\n t0 = tf.constant(0, dtype=tf.int32)\\n if initial_state is not None:\\n s0 = initial_state\\n else:\\n s0 = cell.zero_state(batch_size, dtype=tf.float32)\\n f0 = tf.zeros([batch_size], dtype=tf.bool)\\n\\n def loop_fn(t, prev_s, emit_ta, finished):\\n \\\"\\\"\\\"\\n the loop function of rnn\\n \\\"\\\"\\\"\\n cur_x = inputs_ta.read(t)\\n scores, cur_state = cell(cur_x, prev_s)\\n\\n # copy through\\n scores = tf.where(finished, tf.zeros_like(scores), scores)\\n\\n if isinstance(cell, tc.rnn.LSTMCell):\\n cur_c, cur_h = cur_state\\n prev_c, prev_h = prev_s\\n cur_state = tc.rnn.LSTMStateTuple(tf.where(finished, prev_c, cur_c),\\n tf.where(finished, prev_h, cur_h))\\n else:\\n cur_state = tf.where(finished, prev_s, cur_state)\\n\\n emit_ta = emit_ta.write(t, scores)\\n finished = tf.greater_equal(t + 1, inputs_len)\\n return [t + 1, cur_state, emit_ta, finished]\\n\\n _, state, emit_ta, _ = tf.while_loop(\\n cond=lambda _1, _2, _3, finished: tf.logical_not(\\n tf.reduce_all(finished)),\\n body=loop_fn,\\n loop_vars=(t0, s0, emit_ta, f0),\\n parallel_iterations=32,\\n swap_memory=False)\\n\\n outputs = tf.transpose(emit_ta.stack(), [1, 0, 2])\\n return outputs, state\",\n \"def _rnn_relu_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):\\n if b_ih is None:\\n igates = P.MatMul(False, True)(inputs, w_ih)\\n hgates = P.MatMul(False, True)(hidden, w_hh)\\n else:\\n igates = P.MatMul(False, True)(inputs, w_ih) + b_ih\\n hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh\\n return P.ReLU()(igates + hgates)\",\n \"def single_cell(\\n cell_class,\\n cell_params,\\n dp_input_keep_prob=1.0,\\n dp_output_keep_prob=1.0,\\n recurrent_keep_prob=1.0,\\n input_weight_keep_prob=1.0,\\n recurrent_weight_keep_prob=1.0,\\n weight_variational=False,\\n dropout_seed=None,\\n zoneout_prob=0.,\\n training=True,\\n residual_connections=False,\\n awd_initializer=False,\\n variational_recurrent=False, # in case they want to use DropoutWrapper\\n dtype=None,\\n):\\n if awd_initializer:\\n val = 1.0/math.sqrt(cell_params['num_units'])\\n cell_params['initializer'] = tf.random_uniform_initializer(minval=-val, maxval=val)\\n if 'WeightDropLayerNormBasicLSTMCell' in str(cell_class):\\n if recurrent_keep_prob < 1.0:\\n cell_params['recurrent_keep_prob'] = recurrent_keep_prob\\n if input_weight_keep_prob < 1.0:\\n cell_params['input_weight_keep_prob'] = input_weight_keep_prob\\n if recurrent_weight_keep_prob < 1.0:\\n cell_params['recurrent_weight_keep_prob'] = recurrent_weight_keep_prob\\n if weight_variational:\\n cell_params['weight_variational'] = weight_variational # which is basically True\\n if dropout_seed:\\n cell_params['dropout_seed'] = dropout_seed\\n\\n\\n cell = cell_class(**cell_params)\\n if residual_connections:\\n cell = ResidualWrapper(cell)\\n if zoneout_prob > 0. and (\\n dp_input_keep_prob < 1.0 or dp_output_keep_prob < 1.0\\n ):\\n raise ValueError(\\n \\\"Currently applying both dropout and zoneout on the same cell.\\\"\\n \\\"This is currently not supported.\\\"\\n )\\n if dp_input_keep_prob != 1.0 or dp_output_keep_prob != 1.0 and training:\\n cell = DropoutWrapper(\\n cell,\\n input_keep_prob=dp_input_keep_prob,\\n output_keep_prob=dp_output_keep_prob,\\n variational_recurrent=variational_recurrent,\\n dtype=dtype,\\n seed=dropout_seed\\n )\\n if zoneout_prob > 0.:\\n cell = ZoneoutWrapper(cell, zoneout_prob, is_training=training)\\n return cell\",\n \"def convert_rnn(g, op, block):\\n\\n def generate_lstm(\\n input_seqs,\\n hidden_state,\\n cell_state,\\n w_inp,\\n w_hid,\\n b_inp,\\n b_hid,\\n f_act,\\n g_act,\\n h_act,\\n backwards=False,\\n ):\\n \\\"\\\"\\\"Implementation of LSTM cell for paddlepaddle of TVM\\\"\\\"\\\"\\n\\n h_list = []\\n seq_length = len(input_seqs)\\n for i in range(seq_length):\\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\\n step = _op.squeeze(step, axis=[0])\\n gates = _op.nn.dense(step, w_inp) + _op.nn.dense(hidden_state, w_hid)\\n if b_inp is not None:\\n gates += b_inp\\n if b_hid is not None:\\n gates += b_hid\\n i, f, c, o = _op.split(gates, 4, axis=-1)\\n\\n i = f_act(i)\\n f = f_act(f)\\n\\n c = g_act(c)\\n C = f * cell_state + i * c\\n\\n o = f_act(o)\\n\\n H = o * h_act(C)\\n\\n hidden_state = H\\n cell_state = C\\n h_list.append(_op.expand_dims(H, axis=0))\\n\\n if backwards:\\n h_list = h_list[::-1]\\n\\n # Concatenate outputs and add back in direction axis.\\n concatenated = _op.concatenate(h_list, 0)\\n output = _op.expand_dims(concatenated, axis=1)\\n hidden_state = _op.expand_dims(hidden_state, axis=0)\\n cell_state = _op.expand_dims(cell_state, axis=0)\\n\\n return output, hidden_state, cell_state\\n\\n def generate_gru(\\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, rz_act, n_act, backwards=False\\n ):\\n \\\"\\\"\\\"Implementation of GRU cell for paddlepaddle of TVM\\\"\\\"\\\"\\n\\n h_list = []\\n seq_length = len(input_seqs)\\n for i in range(seq_length):\\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\\n step = _op.squeeze(step, axis=[0])\\n xwt = _op.nn.dense(step, w_inp)\\n hwt = _op.nn.dense(hidden_state, w_hid)\\n if b_inp is not None:\\n xwt += b_inp\\n if b_hid is not None:\\n hwt += b_hid\\n i_r, i_z, i_n = _op.split(xwt, 3, axis=-1)\\n h_r, h_z, h_n = _op.split(hwt, 3, axis=-1)\\n\\n r_gate = rz_act(i_r + h_r)\\n z_gate = rz_act(i_z + h_z)\\n n_gate = n_act(i_n + r_gate * h_n)\\n\\n hidden_state = (hidden_state - n_gate) * z_gate + n_gate\\n h_list.append(_op.expand_dims(hidden_state, axis=0))\\n\\n if backwards:\\n h_list = h_list[::-1]\\n\\n # Concatenate outputs and add back in direction axis.\\n concatenated = _op.concatenate(h_list, 0)\\n output = _op.expand_dims(concatenated, axis=1)\\n hidden_state = _op.expand_dims(hidden_state, axis=0)\\n\\n return output, hidden_state\\n\\n def generate_simplernn(\\n input_seqs, hidden_state, w_inp, w_hid, b_inp, b_hid, n_act, backwards=False\\n ):\\n \\\"\\\"\\\"Implementation of SimpleRNN cell for paddlepaddle of TVM\\\"\\\"\\\"\\n\\n h_list = []\\n seq_length = len(input_seqs)\\n for i in range(seq_length):\\n step = input_seqs[i] if not backwards else input_seqs[seq_length - (i + 1)]\\n step = _op.squeeze(step, axis=[0])\\n xwt = _op.nn.dense(step, w_inp)\\n hwt = _op.nn.dense(hidden_state, w_hid)\\n if b_inp is not None:\\n xwt += b_inp\\n if b_hid is not None:\\n hwt += b_hid\\n\\n n_gate = n_act(xwt + hwt)\\n\\n hidden_state = n_gate\\n h_list.append(_op.expand_dims(hidden_state, axis=0))\\n\\n if backwards:\\n h_list = h_list[::-1]\\n\\n # Concatenate outputs and add back in direction axis.\\n concatenated = _op.concatenate(h_list, 0)\\n output = _op.expand_dims(concatenated, axis=1)\\n hidden_state = _op.expand_dims(hidden_state, axis=0)\\n\\n return output, hidden_state\\n\\n def make_param_inputs(g, node, layer, hidden_size, num_layers):\\n \\\"\\\"\\\"Param for weight and bias.\\\"\\\"\\\"\\n\\n bidirect_len = 4 if node.attr(\\\"is_bidirec\\\") else 2\\n all_layer_param_len = len(node.input(\\\"WeightList\\\"))\\n weight_list = node.input(\\\"WeightList\\\")[: all_layer_param_len // 2]\\n bias_list = node.input(\\\"WeightList\\\")[all_layer_param_len // 2 :]\\n\\n layer_weight_list = weight_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\\n layer_bias_list = bias_list[layer * bidirect_len : layer * bidirect_len + bidirect_len]\\n param_list = layer_weight_list + layer_bias_list\\n param_list_len = len(param_list)\\n\\n input_weights = param_list[0 : param_list_len // 2 : 2]\\n hidden_weights = param_list[1 : param_list_len // 2 : 2]\\n\\n input_bias = param_list[param_list_len // 2 : param_list_len : 2]\\n hidden_bias = param_list[param_list_len // 2 + 1 : param_list_len : 2]\\n\\n return input_weights, hidden_weights, input_bias, hidden_bias\\n\\n def make_init_param_inputs(g, node, layer):\\n \\\"\\\"\\\"Init param for inputs.\\\"\\\"\\\"\\n\\n mode = node.attr(\\\"mode\\\")\\n if mode == \\\"LSTM\\\":\\n all_init_h, all_init_c = node.input(\\\"PreState\\\")\\n bidirect_len = 2 if node.attr(\\\"is_bidirec\\\") else 1\\n init_h = _op.strided_slice(\\n g.get_node(all_init_h),\\n [layer * bidirect_len],\\n [layer * bidirect_len + bidirect_len],\\n axes=[0],\\n )\\n init_c = _op.strided_slice(\\n g.get_node(all_init_c),\\n [layer * bidirect_len],\\n [layer * bidirect_len + bidirect_len],\\n axes=[0],\\n )\\n return init_h, init_c\\n all_init_h = node.input(\\\"PreState\\\")[0]\\n bidirect_len = 2 if node.attr(\\\"is_bidirec\\\") else 1\\n init_h = _op.strided_slice(\\n g.get_node(all_init_h),\\n [layer * bidirect_len],\\n [layer * bidirect_len + bidirect_len],\\n axes=[0],\\n )\\n return init_h\\n\\n hidden_size = op.attr(\\\"hidden_size\\\")\\n num_layers = op.attr(\\\"num_layers\\\")\\n is_bidirec = op.attr(\\\"is_bidirec\\\")\\n mode = op.attr(\\\"mode\\\")\\n\\n input_x = g.get_node(op.input(\\\"Input\\\")[0])\\n\\n num_directions = 1\\n if is_bidirec:\\n num_directions = 2\\n\\n x_shape = infer_shape(input_x)\\n time_steps = x_shape[0]\\n x_steps = _op.split(input_x, indices_or_sections=time_steps, axis=0)\\n for layer in range(num_layers):\\n input_weights, hidden_weights, input_bias, hidden_bias = make_param_inputs(\\n g, op, layer, hidden_size, num_layers\\n )\\n if mode == \\\"LSTM\\\":\\n init_h, init_c = make_init_param_inputs(g, op, layer)\\n init_hs = _op.split(init_h, num_directions)\\n init_cs = _op.split(init_c, num_directions)\\n result_output = []\\n result_H = []\\n result_C = []\\n for i in range(num_directions):\\n H_t = _op.squeeze(init_hs[i], axis=[0])\\n C_t = _op.squeeze(init_cs[i], axis=[0])\\n W = g.get_node(input_weights[i])\\n R = g.get_node(hidden_weights[i])\\n WB = g.get_node(input_bias[i])\\n RB = g.get_node(hidden_bias[i])\\n output, H, C = generate_lstm(\\n input_seqs=x_steps,\\n hidden_state=H_t,\\n cell_state=C_t,\\n w_inp=W,\\n w_hid=R,\\n b_inp=WB,\\n b_hid=RB,\\n f_act=_op.sigmoid,\\n g_act=_op.tanh,\\n h_act=_op.tanh,\\n backwards=i == 1,\\n )\\n result_output.append(output)\\n result_H.append(H)\\n result_C.append(C)\\n output = _op.concatenate(result_output, axis=1)\\n H = _op.concatenate(result_H, axis=0)\\n C = _op.concatenate(result_C, axis=0)\\n elif mode == \\\"GRU\\\":\\n init_h = make_init_param_inputs(g, op, layer)\\n init_hs = _op.split(init_h, num_directions)\\n result_output = []\\n result_H = []\\n for i in range(num_directions):\\n H_t = _op.squeeze(init_hs[i], axis=[0])\\n W = g.get_node(input_weights[i])\\n R = g.get_node(hidden_weights[i])\\n WB = g.get_node(input_bias[i])\\n RB = g.get_node(hidden_bias[i])\\n output, H = generate_gru(\\n input_seqs=x_steps,\\n hidden_state=H_t,\\n w_inp=W,\\n w_hid=R,\\n b_inp=WB,\\n b_hid=RB,\\n rz_act=_op.sigmoid,\\n n_act=_op.tanh,\\n backwards=i == 1,\\n )\\n result_output.append(output)\\n result_H.append(H)\\n output = _op.concatenate(result_output, axis=1)\\n H = _op.concatenate(result_H, axis=0)\\n elif mode == \\\"RNN_TANH\\\":\\n init_h = make_init_param_inputs(g, op, layer)\\n init_hs = _op.split(init_h, num_directions)\\n result_output = []\\n result_H = []\\n for i in range(num_directions):\\n H_t = _op.squeeze(init_hs[i], axis=[0])\\n W = g.get_node(input_weights[i])\\n R = g.get_node(hidden_weights[i])\\n WB = g.get_node(input_bias[i])\\n RB = g.get_node(hidden_bias[i])\\n output, H = generate_simplernn(\\n input_seqs=x_steps,\\n hidden_state=H_t,\\n w_inp=W,\\n w_hid=R,\\n b_inp=WB,\\n b_hid=RB,\\n n_act=_op.tanh,\\n backwards=i == 1,\\n )\\n result_output.append(output)\\n result_H.append(H)\\n output = _op.concatenate(result_output, axis=1)\\n H = _op.concatenate(result_H, axis=0)\\n\\n output = _op.transpose(output, axes=[0, 2, 1, 3])\\n output = _op.reshape(output, newshape=(0, 0, -1))\\n x_steps = _op.split(output, indices_or_sections=time_steps, axis=0)\\n\\n g.add_node(op.output(\\\"Out\\\")[0], output)\",\n \"def __init__(self,\\n num_units,\\n num_dims=1,\\n input_dims=None,\\n output_dims=None,\\n priority_dims=None,\\n non_recurrent_dims=None,\\n tied=False,\\n cell_fn=None,\\n non_recurrent_fn=None,\\n state_is_tuple=True,\\n output_is_tuple=True):\\n if not state_is_tuple:\\n logging.warning('%s: Using a concatenated state is slower and will '\\n 'soon be deprecated. Use state_is_tuple=True.', self)\\n if not output_is_tuple:\\n logging.warning('%s: Using a concatenated output is slower and will '\\n 'soon be deprecated. Use output_is_tuple=True.', self)\\n\\n if num_dims < 1:\\n raise ValueError('dims must be >= 1: {}'.format(num_dims))\\n\\n self._config = _parse_rnn_config(num_dims, input_dims, output_dims,\\n priority_dims, non_recurrent_dims,\\n non_recurrent_fn or nn.relu, tied,\\n num_units)\\n\\n self._state_is_tuple = state_is_tuple\\n self._output_is_tuple = output_is_tuple\\n\\n if cell_fn is None:\\n my_cell_fn = functools.partial(\\n rnn.LSTMCell, num_units=num_units, state_is_tuple=state_is_tuple)\\n else:\\n my_cell_fn = lambda: cell_fn(num_units)\\n if tied:\\n self._cells = [my_cell_fn()] * num_dims\\n else:\\n self._cells = [my_cell_fn() for _ in range(num_dims)]\\n if not isinstance(self._cells[0], rnn.RNNCell):\\n raise TypeError('cell_fn must return an RNNCell instance, saw: %s' %\\n type(self._cells[0]))\\n\\n if self._output_is_tuple:\\n self._output_size = tuple(self._cells[0].output_size\\n for _ in self._config.outputs)\\n else:\\n self._output_size = self._cells[0].output_size * len(self._config.outputs)\\n\\n if self._state_is_tuple:\\n self._state_size = tuple(self._cells[0].state_size\\n for _ in self._config.recurrents)\\n else:\\n self._state_size = self._cell_state_size() * len(self._config.recurrents)\",\n \"def get_dynamic_rnn(X, rnn_size, seq_len, num_layers=1, input_keep_prob=1.0, output_keep_prob=1.0,\\n is_training=False, cell_name=\\\"GRU\\\", bidirectional=False, swap_memory=False):\\n batch_size = tf.shape(X)[0]\\n if bidirectional:\\n rnn_size /= 2\\n\\n def get_cell():\\n if cell_name == \\\"GRU\\\": # GRU\\n _cell = rnn_cell.GRUCell(rnn_size)\\n elif cell_name == \\\"LSTM\\\": # LSTM\\n _cell = rnn_cell.LSTMCell(rnn_size, tf.shape(X)[2])\\n # cell = rnn_cell.BasicLSTMCell(rnn_size)\\n else:\\n raise ValueError(\\\"Unrecognized Cell Name: {0}\\\".format(cell_name))\\n if is_training and (input_keep_prob < 1 or output_keep_prob < 1):\\n _cell = rnn_cell.DropoutWrapper(_cell, input_keep_prob=input_keep_prob, output_keep_prob=output_keep_prob)\\n _cell = rnn_cell.MultiRNNCell([_cell] * num_layers)\\n _initial_state = _cell.zero_state(batch_size, tf.float32)\\n return _cell, _initial_state\\n\\n if bidirectional:\\n with tf.variable_scope(\\\"forward\\\"):\\n cell_fw, initial_state_fw = get_cell()\\n with tf.variable_scope(\\\"backward\\\"):\\n cell_bw, initial_state_bw = get_cell()\\n return rnn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, X, sequence_length=seq_len,\\n initial_state_fw=initial_state_fw, initial_state_bw=initial_state_bw,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\\n else:\\n cell, initial_state = get_cell()\\n return rnn.dynamic_rnn(\\n cell, X, sequence_length=seq_len, initial_state=initial_state,\\n dtype=None, parallel_iterations=None, swap_memory=swap_memory, time_major=False, scope=None)\",\n \"def build_rnn_greedy(self):\\n print(\\\"Building the RNN part...\\\")\\n params = self.params\\n\\n contexts = self.conv_feats\\n\\n sentences = tf.placeholder(tf.int32, [self.batch_size, self.max_sent_len])\\n masks = tf.placeholder(tf.float32, [self.batch_size, self.max_sent_len]) \\n weights = tf.placeholder(tf.float32, [self.batch_size, self.max_sent_len]) \\n\\n # initialize the word embedding\\n idx2vec = np.array([self.word_table.word2vec[self.word_table.idx2word[i]] \\n for i in range(self.num_words)])\\n emb_w = weight('emb_weights', [self.num_words, self.dim_embed], init_val=idx2vec)\\n\\n # initialize the decoding layer\\n dec_w = weight('dec_weights', [self.dim_dec, self.num_words]) \\n if self.init_dec_bias: \\n dec_b = bias('dec_biases', [self.num_words], init_val=self.word_table.word_freq)\\n else:\\n dec_b = bias('dec_biases', [self.num_words], init_val=0.0)\\n \\n # compute the mean context\\n context_mean = tf.reduce_mean(contexts, 1)\\n \\n # initialize the LSTM\\n lstm = tf.nn.rnn_cell.LSTMCell(self.dim_hidden, initializer=tf.random_normal_initializer(stddev=0.033)) \\n lstm = tf.nn.rnn_cell.DropoutWrapper(lstm, self.lstm_keep_prob, self.lstm_keep_prob, self.lstm_keep_prob)\\n\\n memory, output = self.init_lstm(context_mean)\\n state = memory, output\\n\\n cross_entropy_loss = 0.0\\n results = []\\n scores = []\\n\\n alphas = [] \\n cross_entropies = []\\n num_correct_words = 0.0\\n\\n # Generate the words one by one \\n for idx in range(self.max_sent_len):\\n\\n # Attention mechanism\\n alpha = self.attend(contexts, output) \\n \\n masked_alpha = alpha * tf.tile(tf.expand_dims(masks[:, idx], 1), [1, self.num_ctx]) \\n alphas.append(tf.reshape(masked_alpha, [-1])) \\n\\n if idx == 0: \\n word_emb = tf.zeros([self.batch_size, self.dim_embed])\\n weighted_context = tf.identity(context_mean)\\n else:\\n word_emb = tf.cond(self.is_train, \\n lambda: tf.nn.embedding_lookup(emb_w, sentences[:, idx-1]), \\n lambda: word_emb)\\n weighted_context = tf.reduce_sum(contexts * tf.expand_dims(alpha, 2), 1)\\n \\n # Apply the LSTM\\n with tf.variable_scope(\\\"LSTM\\\"):\\n output, state = lstm(tf.concat([weighted_context, word_emb], 1), state)\\n \\n # Compute the logits\\n expanded_output = tf.concat([output, weighted_context, word_emb], 1)\\n\\n logits1 = fully_connected(expanded_output, self.dim_dec, 'dec_fc')\\n logits1 = nonlinear(logits1, 'tanh')\\n logits1 = dropout(logits1, self.fc_keep_prob, self.is_train)\\n\\n logits2 = tf.nn.xw_plus_b(logits1, dec_w, dec_b)\\n\\n # Update the loss\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=sentences[:, idx], \\n logits=logits2)\\n masked_cross_entropy = cross_entropy * masks[:, idx]\\n cross_entropy_loss += tf.reduce_sum(masked_cross_entropy*weights[:, idx])\\n cross_entropies.append(masked_cross_entropy)\\n\\n # Update the result\\n max_prob_word = tf.argmax(logits2, 1)\\n results.append(max_prob_word)\\n\\n is_word_correct = tf.where(tf.equal(max_prob_word, tf.cast(sentences[:, idx], tf.int64)), \\n tf.cast(masks[:, idx], tf.float32), \\n tf.cast(tf.zeros_like(max_prob_word), tf.float32))\\n num_correct_words += tf.reduce_sum(is_word_correct) \\n\\n probs = tf.nn.softmax(logits2) \\n score = tf.log(tf.reduce_max(probs, 1)) \\n scores.append(score) \\n \\n # Prepare for the next iteration\\n word_emb = tf.cond(self.is_train, lambda: word_emb, lambda: tf.nn.embedding_lookup(emb_w, max_prob_word)) \\n tf.get_variable_scope().reuse_variables() \\n\\n # Get the final result\\n results = tf.stack(results, axis=1)\\n scores = tf.stack(scores, axis=1)\\n\\n alphas = tf.stack(alphas, axis=1)\\n alphas = tf.reshape(alphas, [self.batch_size, self.num_ctx, -1])\\n sum_alpha = tf.reduce_sum(alphas, axis=2)\\n\\n cross_entropies = tf.stack(cross_entropies, axis=1) \\n num_correct_words = num_correct_words / tf.reduce_sum(masks)\\n\\n # Compute the final loss \\n cross_entropy_loss = cross_entropy_loss / tf.reduce_sum(masks*weights)\\n\\n avg_alpha = tf.reduce_sum(masks, axis=1) / self.num_ctx\\n small_alpha_diff = tf.nn.relu(tf.tile(tf.expand_dims(avg_alpha*0.6, 1), [1, self.num_ctx])-sum_alpha)\\n large_alpha_diff = tf.nn.relu(sum_alpha-tf.tile(tf.expand_dims(avg_alpha*6, 1), [1, self.num_ctx]))\\n attention_loss = tf.nn.l2_loss(small_alpha_diff) + tf.nn.l2_loss(large_alpha_diff) \\n attention_loss = params.att_coeff * attention_loss / self.batch_size \\n\\n if self.train_cnn:\\n g_vars = tf.trainable_variables()\\n else:\\n g_vars = [tf_var for tf_var in tf.trainable_variables() if \\\"CNN\\\" not in tf_var.name]\\n\\n l2_loss = params.weight_decay * sum(tf.nn.l2_loss(tf_var) for tf_var in g_vars \\n if (\\\"bias\\\" not in tf_var.name and\\n \\\"offset\\\" not in tf_var.name and \\n \\\"scale\\\" not in tf_var.name)) \\n\\n loss = cross_entropy_loss + attention_loss + l2_loss\\n\\n # Build the solver \\n with tf.variable_scope(\\\"Solver\\\", reuse=tf.AUTO_REUSE):\\n learning_rate = tf.train.exponential_decay(params.learning_rate, \\n self.global_step,\\n 10000, \\n 0.9, \\n staircase=True)\\n\\n if params.solver==\\\"momentum\\\":\\n solver = tf.train.MomentumOptimizer(learning_rate, params.momentum)\\n elif params.solver==\\\"rmsprop\\\":\\n solver = tf.train.RMSPropOptimizer(learning_rate, params.decay, params.momentum)\\n else:\\n solver = tf.train.GradientDescentOptimizer(learning_rate)\\n\\n gs = tf.gradients(loss, g_vars)\\n gs, _ = tf.clip_by_global_norm(gs, 10.0)\\n opt_op = solver.apply_gradients(zip(gs, g_vars), global_step=self.global_step)\\n\\n self.sentences = sentences\\n self.masks = masks\\n self.weights = weights\\n\\n self.results = results\\n self.scores = scores\\n self.alphas = alphas\\n\\n self.sum_alpha = sum_alpha\\n self.cross_entropies = cross_entropies\\n self.num_correct_words = num_correct_words\\n\\n self.loss = loss\\n self.cross_entropy_loss = cross_entropy_loss\\n self.attention_loss = attention_loss\\n self.l2_loss = l2_loss\\n\\n self.opt_op = opt_op\\n self.g_vars = g_vars\\n self.gs = gs\\n \\n print(\\\"RNN part built.\\\")\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(RCRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = ResidualCNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=2,\\n )\\n #self.rnn2 = BidirectionalGRU(\\n # n_in=nb_in*2,\\n # n_hidden=n_RNN_cell,\\n # dropout=dropout_recurrent,\\n # num_layers=1,\\n #)\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.relu = nn.ReLU()\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def tile_representations(self, reps):\\n if len(reps.shape) == 3:\\n reps = reps.unsqueeze(0)\\n elif len(reps.shape) != 4:\\n raise ValueError('Input argument `reps` has invalid shape: {}'.format(reps.shape))\\n\\n tiled_reps = reps.repeat(1, 1, 1, self.dr)\\n tiled_reps = tiled_reps.reshape(reps.size(0), reps.size(1), reps.size(2)*self.dr, reps.size(3))\\n\\n # return the only layer if only one layer is given at input\\n # else return representations of all layers\\n if len(tiled_reps) == 1:\\n return tiled_reps.squeeze(0) # (batch_size, sequence_length * downsample_rate, hidden_size)\\n return tiled_reps # (num_hidden_layers, batch_size, sequence_length * downsample_rate, hidden_size)\",\n \"def rnn_with_embedding(self,cell,init_state,input_seq,\\n input_seq_len,reuse=None,\\n scope=\\\"RNN\\\"): \\n with tf.variable_scope(scope,reuse=reuse) as vs:\\n log(vs.name+\\\"/Encoding sequences\\\")\\n with tf.device('/cpu:0'):\\n emb = tf.get_variable(\\\"emb\\\",\\n [self.vocab_size,self.hidden_size],\\n dtype=tf.float32)\\n un_emb = tf.get_variable(\\\"unemb\\\",\\n [self.hidden_size,self.vocab_size],\\n tf.float32)\\n # We need a bias\\n un_emb_b = tf.get_variable(\\\"unemb_b\\\",\\n [self.vocab_size],\\n dtype=tf.float32)\\n \\n assert scope+\\\"/emb:0\\\" in emb.name,\\\\\\n \\\"Making sure the reusing is working\\\"\\n emb_input_seq = tf.nn.embedding_lookup(\\n emb,input_seq)\\n emb_input_list = tf.unpack(\\n tf.transpose(emb_input_seq,[1,0,2]))\\n \\n # RNN pass\\n if init_state is None:\\n init_state = cell.zero_state(\\n tf.shape(emb_input_list[0])[0],tf.float32)\\n \\n emb_output_list, final_state = tf.nn.rnn(\\n cell,emb_input_list,initial_state=init_state,\\n sequence_length=input_seq_len)\\n\\n # We shift the predicted outputs, because at\\n # each word we're trying to predict the next.\\n emb_output_list = emb_output_list[:-1]\\n \\n # Unembedding\\n output_list = [tf.matmul(t,un_emb) + un_emb_b\\n for t in emb_output_list]\\n outputs = tf.transpose(tf.pack(output_list),[1,0,2])\\n\\n return outputs, final_state\",\n \"def collate(self, batch):\\n \\n images = []\\n indices = []\\n roi_size = 5 if self.Train else 4\\n rois = torch.zeros((len(batch), 20, roi_size), dtype=torch.float32)\\n rois = rois.to(batch[0][1].device)\\n \\n for _b in range(len(batch)):\\n # Accumulate patches:\\n images.append(batch[_b][0].to(torch.float32))\\n indices.append(batch[_b][2])\\n \\n # Accumulate ROI:\\n \\\"\\\"\\\"\\n image_num = torch.Tensor([_b]).expand(batch[_b][1].size(0))\\n image_num = image_num.type(batch[_b][1].dtype).view(-1,1)\\n image_num = image_num.to(batch[_b][1].device)\\n _roi = torch.cat([image_num, batch[_b][1]], dim=1)\\n rois = torch.cat([rois, _roi], dim=0)\\n \\\"\\\"\\\"\\n num_boxes = batch[_b][1].size(0)\\n rois[_b,:num_boxes,:] = batch[_b][1]\\n \\n \\n # Stack outputs and return\\n batch = [torch.stack(images, dim=0), rois, torch.Tensor(indices)]\\n return batch\",\n \"def unroll_cell(self, decoder_inputs, initial_state, loop_function, cell):\\n return tf.contrib.legacy_seq2seq.rnn_decoder(\\n decoder_inputs=decoder_inputs,\\n initial_state=initial_state,\\n cell=cell,\\n loop_function=self.get_input)\",\n \"def __call__(self, inputs, state, scope=None, debug=False):\\n # B is batch size.\\n\\n # 1) Use read_ind to find memory location to read from\\n # as input.\\n\\n # inputs.read_ind: (B, 1)\\n # memory: (B, mem_size, embed_size)\\n read_ind = tf.to_int32(inputs.read_ind)\\n batch_size = tf.shape(read_ind)[0]\\n if debug:\\n print('batch size is', batch_size)\\n print('read ind is', read_ind)\\n mem_ind = tf.range(batch_size)\\n\\n # read_mem_ind: (B, 1)\\n read_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n # read_ind: (B, 2)\\n read_ind = tf.concat([read_mem_ind, read_ind], axis=1)\\n if debug:\\n print('processed read ind is', read_ind)\\n\\n # inner_inputs: (B, embed_size)\\n inner_inputs = tf.gather_nd(state.memory, read_ind)\\n if debug:\\n print('inner_inputs is', inner_inputs)\\n\\n inner_state = state.inner_state\\n\\n # 2) Run the inner RNNCell.\\n \\n # inner_outputs: (B, embed_size)\\n inner_outputs, new_inner_state = self._cell(inner_inputs, inner_state, scope=scope)\\n\\n if debug:\\n print('inner_outputs is', inner_outputs)\\n\\n # 3) Compute logits for valid indices (using logit_masks\\n # to mask out padded valid indices (-1)).\\n \\n # valid_indices: (B, max_n_valid_indices)\\n valid_indices = tf.to_int32(inputs.valid_indices)\\n if debug:\\n print('valid_indices is', valid_indices)\\n \\n # Logit mask: (B, max_n_valid_indices)\\n logit_masks = tf.greater_equal(inputs.valid_indices, 0)\\n logit_masks = tf.cast(logit_masks, tf.float32)\\n\\n if debug:\\n print('logit_masks is', logit_masks)\\n\\n # Normalize indices to be at least 0.\\n valid_indices = tf.maximum(valid_indices, 0)\\n\\n # valid_indices: (B, max_n_valid_indices, 1)\\n valid_indices = tf.expand_dims(valid_indices, -1)\\n if debug:\\n print('valid_indices is', valid_indices)\\n print('mem_ind is', mem_ind)\\n\\n valid_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # valid_mem_ind: (B, 1, 1)\\n valid_mem_ind = tf.expand_dims(valid_mem_ind, axis=2)\\n if debug:\\n print('valid_mem_ind is', valid_mem_ind)\\n\\n # valid_mem_ind: (B, max_n_valid_indices, 1)\\n valid_mem_ind = tf.tile(valid_mem_ind, [1, self._max_n_valid_indices, 1])\\n\\n # valid_indices: (B, max_n_valid_indices, 2)\\n # Third dimension of valid_indices is [b_i, valid_index] so that it can\\n # index into the right memory location.\\n valid_indices = tf.concat([valid_mem_ind, valid_indices], axis=2)\\n\\n if debug:\\n print('valid_indices is', valid_indices)\\n\\n # select all the valid slots. \\n # valid_values: (B, max_n_valid_indices, embed_size)\\n valid_values = tf.gather_nd(state.memory, valid_indices)\\n if debug:\\n print('valid_values is', valid_values)\\n \\n # expanded_inner_outputs: (B, 1, embed_size)\\n expanded_inner_outputs = tf.expand_dims(inner_outputs, 1)\\n if debug:\\n print('expanded_inner_outputs is', expanded_inner_outputs)\\n\\n # valid_values: (B, embed_size, max_n_valid_indices)\\n valid_values = tf.transpose(valid_values, [0, 2, 1])\\n if debug:\\n print('valid_values is', valid_values)\\n\\n # logits: (B, 1, max_n_valid_indices)\\n logits = tf.matmul(expanded_inner_outputs, valid_values)\\n \\n if debug:\\n print('logits is', logits)\\n\\n # logits: (B, max_n_valid_indices)\\n logits = tf.squeeze(logits, axis=[1])\\n if debug:\\n print('logits is', logits)\\n\\n # masked_logits = (logits * logit_masks) - (1 - logit_masks) * 1e6\\n masked_logits = logits * logit_masks + (1 - logit_masks) * tf.float32.min\\n # masked_logits = tf.Print(masked_logits, [masked_logits], message='masked_logits')\\n\\n outputs = masked_logits\\n # 4) Write the output of the inner RNN to a memory\\n # location (write_ind), using write_masks to mask out\\n # padded write_ind (-1).\\n \\n # write_ind: (B, 1)\\n write_ind = tf.cast(inputs.write_ind, tf.int32)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n # write mask: (B, 1)\\n write_masks = tf.greater_equal(inputs.write_ind, 0)\\n if debug:\\n print('write_masks greater_equal', write_masks)\\n\\n write_masks = tf.cast(write_masks, tf.float32)\\n\\n # write mask: (B, 1, 1)\\n write_masks = tf.expand_dims(write_masks, [-1])\\n\\n if debug:\\n print('write_masks is', write_masks)\\n\\n # Normalize write_ind to be above 0.\\n # write_ind: (B, 1)\\n write_ind = tf.maximum(write_ind, 0)\\n\\n # write_mem_ind: (B, 1)\\n write_mem_ind = tf.expand_dims(mem_ind, axis=1)\\n\\n # write_ind: (B, 2)\\n # Second dimension is [b_i, write_index]\\n write_ind = tf.concat([write_mem_ind, write_ind], axis=1)\\n if debug:\\n print('write_ind is', write_ind)\\n\\n if debug:\\n print('masked_logits is', masked_logits)\\n print('memory is', state.memory)\\n\\n # write_mat: (B, mem_size, embed_size)\\n write_mat = tf.scatter_nd(\\n write_ind, inner_outputs, shape=tf.shape(state.memory))\\n\\n if debug:\\n print('@' * 50)\\n print('write_mat is', write_mat)\\n print('write_mask is', write_masks)\\n print('@' * 50)\\n\\n masked_write_mat = write_mat * write_masks\\n new_memory = state.memory + masked_write_mat\\n \\n state = MemoryStateTuple(new_memory, new_inner_state)\\n if debug:\\n print('state is', state)\\n \\n return (outputs, state)\",\n \"def LSTMCellWeightsShape(num_inputs, num_nodes):\\n # Dimension 0 accounts for combining x with the previous m state.\\n # Dimension 1 accounts for the in value and the (in, forget, out) gates.\\n return [num_inputs + num_nodes, 4 * num_nodes]\",\n \"def convert_rnn_param_concat(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n axis = int(attrs.get(\\\"dim\\\"))\\n\\n # mxnet RNN node and ONNX RNN/LSTM/GRU nodes\\n # use different ways to store their parameters\\n\\n # The conversion between these formats is broken into 2 steps\\n # The first step (performed here in _rnn_param_concat) regroups the\\n # flattened parameters according to the table below.\\n # The second step corrects the shapes and orders of gates and is\\n # performed and described in more detail in the RNN node\\n\\n # mxnet [ONNX] -> ONNX (group)\\n # i2h_weights [W (+ WB)] -> W (input weights)\\n # h2h_weights [R (+ RB)] -> R (recurrence weights)\\n # i2h_biases [Wb (+ WBb)] -> B = [Wb + Rb (+ WBb + RBb)]\\n # h2h_biases [Rb (+ RBb)] -> (biases)\\n\\n split = len(input_nodes) // 2\\n weights, biases = input_nodes[:split], input_nodes[split:]\\n i2h_weights = weights[::2]\\n h2h_weights = weights[1::2]\\n i2h_biases = biases[::2]\\n h2h_biases = biases[1::2]\\n reordered_biases = [\\n bias\\n for pair in zip(i2h_biases, h2h_biases)\\n for bias in pair\\n ]\\n\\n # The order of mxnet parameters in the inputs is:\\n # [\\n # '{}{}_{}_{}'.format(d, l, g, t)\\n # for t in ['weight', 'bias']\\n # for l in range(num_layers)\\n # for d in ['l', 'r'][:num_directions]\\n # for g in ['i2h', 'h2h']\\n # ]\\n\\n w = onnx.helper.make_node(\\n \\\"Concat\\\",\\n inputs=i2h_weights,\\n outputs=[name + \\\"__W\\\"],\\n axis=axis,\\n name=name + \\\"__W\\\"\\n )\\n r = onnx.helper.make_node(\\n \\\"Concat\\\",\\n inputs=h2h_weights,\\n outputs=[name + \\\"__R\\\"],\\n axis=axis,\\n name=name + \\\"__R\\\"\\n )\\n b = onnx.helper.make_node(\\n \\\"Concat\\\",\\n inputs=reordered_biases,\\n outputs=[name + \\\"__B\\\"],\\n axis=axis,\\n name=name + \\\"__B\\\"\\n )\\n return [w, r, b]\",\n \"def __init__(\\n self,\\n n_in_channel=1,\\n nclass=10,\\n attention=True,\\n activation=\\\"glu\\\",\\n dropout=0.5,\\n train_cnn=True,\\n rnn_type=\\\"BGRU\\\",\\n n_RNN_cell=128,\\n n_layers_RNN=2,\\n dropout_recurrent=0,\\n cnn_integration=False,\\n freeze_bn=False,\\n **kwargs,\\n ):\\n super(CRNN, self).__init__()\\n self.n_in_channel = n_in_channel\\n self.attention = attention\\n self.cnn_integration = cnn_integration\\n self.freeze_bn = freeze_bn\\n\\n n_in_cnn = n_in_channel\\n\\n if cnn_integration:\\n n_in_cnn = 1\\n\\n self.cnn = CNN(\\n n_in_channel=n_in_cnn, activation=activation, conv_dropout=dropout, **kwargs\\n )\\n\\n self.train_cnn = train_cnn\\n if not train_cnn:\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n if rnn_type == \\\"BGRU\\\":\\n nb_in = self.cnn.nb_filters[-1]\\n if self.cnn_integration:\\n # self.fc = nn.Linear(nb_in * n_in_channel, nb_in)\\n nb_in = nb_in * n_in_channel\\n self.rnn = BidirectionalGRU(\\n n_in=nb_in,\\n n_hidden=n_RNN_cell,\\n dropout=dropout_recurrent,\\n num_layers=n_layers_RNN,\\n )\\n else:\\n NotImplementedError(\\\"Only BGRU supported for CRNN for now\\\")\\n\\n self.dropout = nn.Dropout(dropout)\\n self.dense = nn.Linear(n_RNN_cell * 2, nclass)\\n self.sigmoid = nn.Sigmoid()\\n\\n if self.attention:\\n self.dense_softmax = nn.Linear(n_RNN_cell * 2, nclass)\\n self.softmax = nn.Softmax(dim=-1)\",\n \"def test_learnable_cell(self):\\n genotype = '0|0|2|0|0|2|0|0 1|0|0|1|1|0|0|0 0|1|0|0|0|0|2|1--1 7'\\n search_space = {'dil_conv_3x3', 'dil_conv_5x5', 'dil_conv_7x7',\\n 'skip_connect', 'clinc_3x3', 'clinc_7x7', 'avg_pool_3x3', 'max_pool_3x3'}\\n\\n net = LearnableCell(3, genotype, search_space)\\n x = torch.rand((16, 3, 32, 32))\\n y = net(x)\\n self.assertEqual(list(y.shape), [16, 7, 15, 15])\",\n \"def __init__(self, cell_index, stimulus_type, conv_layers=[(12, 9, 9), (12, 9, 9)], dense_layer=64,\\n loss='poisson_loss', optimizer='adam', weight_init='normal', l2_reg=0., dropout=0.5, mean_adapt=False):\\n\\n self.stim_shape = (40, 50, 50)\\n\\n # build the model\\n with notify('Building convnet'):\\n\\n self.model = Sequential()\\n\\n # convolutional layers\\n for ix, layer in enumerate(conv_layers):\\n\\n # get parameters for this layer\\n num_filters, row_size, col_size = layer\\n\\n # convolutional layer\\n if ix == 0:\\n self.model.add(Convolution2D(num_filters, row_size, col_size,\\n input_shape=self.stim_shape, init=weight_init,\\n border_mode='same', subsample=(1,1),\\n W_regularizer=l2(l2_reg), activation='relu'))\\n\\n else:\\n self.model.add(Convolution2D(num_filters, row_size, col_size,\\n input_shape=self.stim_shape, init=weight_init,\\n border_mode='same', subsample=(1,1),\\n W_regularizer=l2(l2_reg), activation='relu'))\\n\\n # max pooling layer\\n self.model.add(MaxPooling2D(pool_size=(2, 2), ignore_border=True))\\n\\n # dropout\\n self.model.add(Dropout(dropout))\\n\\n # flatten\\n self.model.add(Flatten())\\n\\n # Add dense (affine) layer with relu activation\\n self.model.add(Dense(dense_layer, init=weight_init, W_regularizer=l2(l2_reg), activation='relu'))\\n self.model.add(Dropout(dropout))\\n\\n # Add a final dense (affine) layer with softplus activation\\n self.model.add(Dense(1, init=weight_init, W_regularizer=l2(l2_reg), activation='softplus'))\\n\\n # save architecture string (for markdown file)\\n self.architecture = '\\\\n'.join(['Convolutional layers {}'.format(conv_layers),\\n '{} filters in the second (fully connected) layer'.format(dense_layer),\\n 'weight initialization: {}'.format(weight_init),\\n 'l2 regularization: {}'.format(l2_reg),\\n 'stimulus shape: {}'.format(self.stim_shape)])\\n\\n # compile\\n super().__init__(cell_index, stimulus_type, loss, optimizer, mean_adapt)\",\n \"def __call__(self, inputs, state, scope=None, *args, **kwargs):\\r\\n # Bypass RNNCell's variable capturing semantics for LayerRNNCell.\\r\\n # Instead, it is up to subclasses to provide a proper build\\r\\n # method. See the class docstring for more details.\\r\\n return base_layer.Layer.__call__(self, inputs, state, scope=scope,\\r\\n *args, **kwargs)\",\n \"def rnn_decoder_with_attention(decoder_inputs, initial_state, cell, loop_function,attention_states,scope=None):#3D Tensor [batch_size x attn_length x attn_size]\\n with tf.variable_scope(scope or \\\"rnn_decoder\\\"):\\n print(\\\"rnn_decoder_with_attention started...\\\")\\n state = initial_state #[batch_size x cell.state_size].\\n _, hidden_size = state.get_shape().as_list() #200\\n attention_states_original=attention_states\\n batch_size,sequence_length,_=attention_states.get_shape().as_list()\\n outputs = []\\n prev = None\\n #################################################\\n for i, inp in enumerate(decoder_inputs):#循环解码部分的输入。如sentence_length个[batch_size x input_size]\\n # 如果是训练，使用训练数据的输入；如果是test, 将t时刻的输出作为t + 1 时刻的s输入\\n if loop_function is not None and prev is not None:#测试的时候：如果loop_function不为空且前一个词的值不为空，那么使用前一个的值作为RNN的输入\\n with tf.variable_scope(\\\"loop_function\\\", reuse=True):\\n inp = loop_function(prev, i)\\n if i > 0:\\n tf.get_variable_scope().reuse_variables()\\n ##ATTENTION#################################################################################################################################################\\n # 1.get logits of attention for each encoder input. attention_states:[batch_size x attn_length x attn_size]; query=state:[batch_size x cell.state_size]\\n query=state\\n W_a = tf.get_variable(\\\"W_a\\\", shape=[hidden_size, hidden_size],initializer=tf.random_normal_initializer(stddev=0.1))\\n query=tf.matmul(query, W_a) #[batch_size,hidden_size]\\n query=tf.expand_dims(query,axis=1) #[batch_size, 1, hidden_size]\\n U_a = tf.get_variable(\\\"U_a\\\", shape=[hidden_size, hidden_size],initializer=tf.random_normal_initializer(stddev=0.1))\\n U_aa = tf.get_variable(\\\"U_aa\\\", shape=[ hidden_size])\\n attention_states=tf.reshape(attention_states,shape=(-1,hidden_size)) #[batch_size*sentence_length,hidden_size]\\n attention_states=tf.matmul(attention_states, U_a) #[batch_size*sentence_length,hidden_size]\\n #print(\\\"batch_size\\\",batch_size,\\\" ;sequence_length:\\\",sequence_length,\\\" ;hidden_size:\\\",hidden_size) #print(\\\"attention_states:\\\", attention_states) #(?, 200)\\n attention_states=tf.reshape(attention_states,shape=(-1,sequence_length,hidden_size)) # TODO [batch_size,sentence_length,hidden_size]\\n #query_expanded: [batch_size,1, hidden_size]\\n #attention_states_reshaped: [batch_size,sentence_length,hidden_size]\\n attention_logits=tf.nn.tanh(query+attention_states+U_aa) #[batch_size,sentence_length,hidden_size]. additive style\\n\\n # 2.get possibility of attention\\n attention_logits=tf.reshape(attention_logits,shape=(-1,hidden_size)) #batch_size*sequence_length [batch_size*sentence_length,hidden_size]\\n V_a = tf.get_variable(\\\"V_a\\\", shape=[hidden_size,1],initializer=tf.random_normal_initializer(stddev=0.1)) #[hidden_size,1]\\n attention_logits=tf.matmul(attention_logits,V_a) #最终需要的是[batch_size*sentence_length,1]<-----[batch_size*sentence_length,hidden_size],[hidden_size,1]\\n attention_logits=tf.reshape(attention_logits,shape=(-1,sequence_length)) #attention_logits:[batch_size,sequence_length]\\n ##########################################################################################################################################################\\n #attention_logits=tf.reduce_sum(attention_logits,2) #[batch_size x attn_length]\\n attention_logits_max=tf.reduce_max(attention_logits,axis=1,keep_dims=True) #[batch_size x 1]\\n # possibility distribution for each encoder input.it means how much attention or focus for each encoder input\\n p_attention=tf.nn.softmax(attention_logits-attention_logits_max)#[batch_size x attn_length]\\n\\n # 3.get weighted sum of hidden state for each encoder input as attention state\\n p_attention=tf.expand_dims(p_attention,axis=2) #[batch_size x attn_length x 1]\\n # attention_states:[batch_size x attn_length x attn_size]; p_attention:[batch_size x attn_length];\\n attention_final=tf.multiply(attention_states_original,p_attention) #[batch_size x attn_length x attn_size]\\n context_vector=tf.reduce_sum(attention_final,axis=1) #[batch_size x attn_size]\\n ############################################################################################################################################################\\n #inp:[batch_size x input_size].it is decoder input; attention_final:[batch_size x attn_size]\\n output, state = cell(inp, state,context_vector) #attention_final TODO 使用RNN走一步\\n outputs.append(output) # 将输出添加到结果列表中\\n if loop_function is not None:\\n prev = output\\n print(\\\"rnn_decoder_with_attention ended...\\\")\\n return outputs, state\",\n \"def __call__(self, batch):\\r\\n '''\\r\\n for i in range(len(batch)):\\r\\n if batch[i].shape[1] != 861:\\r\\n batch[i] = batch[i - 1]\\r\\n '''\\r\\n return torch.tensor(batch)#torch.stack(batch, dim = 0)\\r\",\n \"def _single_cell(self,unit_type, num_units, mode,dropout=0.0,\\n residual_connection=False, device_str=None):\\n # dropout (= 1 - keep_prob) is set to 0 during eval and infer\\n dropout = dropout if mode == \\\"train\\\" else 0.0\\n # Cell Type\\n if unit_type == \\\"lstm\\\":\\n single_cell = tf.contrib.rnn.BasicLSTMCell(num_units)\\n\\n elif unit_type == \\\"gru\\\":\\n single_cell = tf.contrib.rnn.GRUCell(num_units)\\n\\n elif unit_type == \\\"layer_norm_lstm\\\":\\n single_cell = tf.contrib.rnn.LayerNormBasicLSTMCell(\\n num_units,layer_norm=True)\\n else:\\n raise ValueError(\\\"Unknown unit type %s!\\\" % unit_type)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.contrib.rnn.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.contrib.rnn.ResidualWrapper(single_cell)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.contrib.rnn.DeviceWrapper(single_cell, device_str)\\n\\n return single_cell\",\n \"def test_model_with_simple_rnn_multiple_layers(self):\\n tf.compat.v1.reset_default_graph()\\n sess = tf.compat.v1.Session()\\n with sess.graph.as_default():\\n inputs = tf.keras.Input(shape=(3, 100))\\n\\n # Add an RNN layer with 12 internal units.\\n x = tf.keras.layers.SimpleRNN(12, name='rnn0', activation='tanh', return_sequences=True)(inputs)\\n x = tf.keras.layers.SimpleRNN(12, name='rnn1', activation='relu', return_sequences=True)(x)\\n x = tf.keras.layers.SimpleRNN(12, name='rnn2', activation='tanh')(x)\\n _ = tf.keras.layers.Dense(12, activation=tf.nn.softmax, name=\\\"matmul0\\\")(x)\\n\\n init = tf.compat.v1.global_variables_initializer()\\n sess.run(init)\\n # _ = tf.compat.v1.summary.FileWriter('./simple_rnn', sess.graph)\\n\\n # construct a connected graph\\n conn_graph = ConnectedGraph(sess.graph, ['input_1'], ['matmul0/Softmax'])\\n\\n # there should be only 4 connected graph ops, input, simpleRNN , Dense and Softmax\\n self.assertEqual(6, len(conn_graph.get_all_ops()))\\n num_detected_rnns = 0\\n for op in conn_graph.get_all_ops().values():\\n if op.type == 'SimpleRNN':\\n num_detected_rnns += 1\\n inner_list = op.internal_ops\\n self.assertEqual(49, len(inner_list))\\n self.assertEqual(3, num_detected_rnns)\",\n \"def stacked_bidirectional_rnn(RNN, num_units, num_layers, inputs, seq_lengths, batch_size):\\n _inputs = inputs\\n for _ in range(num_layers):\\n with tf.variable_scope(None, default_name=\\\"bidirectional-rnn\\\"):\\n rnn_cell_fw = RNN(num_units)\\n rnn_cell_bw = RNN(num_units)\\n initial_state_fw = rnn_cell_fw.zero_state(batch_size, dtype=tf.float32)\\n initial_state_bw = rnn_cell_bw.zero_state(batch_size, dtype=tf.float32)\\n (output, state) = tf.nn.bidirectional_dynamic_rnn(rnn_cell_fw, rnn_cell_bw, _inputs, seq_lengths,\\n initial_state_fw, initial_state_bw, dtype=tf.float32)\\n _inputs = tf.concat(output, 2)\\n return _inputs\",\n \"def _build_decoder_cell(self, encode_output):\\n # We only make use of encoder_outputs in attention-based models\\n cells = self.rnn_cells()\\n cell = tf.contrib.rnn.MultiRNNCell(cells)\\n decoder_initial_state = self._build_deocder_init_state(encode_output)\\n\\n return cell, decoder_initial_state\",\n \"def test_two_cell_repel():\\n space = c6.Space()\\n c6.Cell(space, [0, 0], 1)\\n c6.Cell(space, [0, 1.9], 1)\\n for i in range(2):\\n space.step()\",\n \"def _single_cell(num_units,\\n dropout,\\n mode,\\n residual_connection=False,\\n device_str=None):\\n dropout = dropout if mode == tf.estimator.ModeKeys.TRAIN else 0.0\\n\\n # Cell Type\\n utils.print_out(\\\" GRU\\\", new_line=False)\\n single_cell = tf.nn.rnn_cell.GRUCell(num_units)\\n\\n # Dropout (= 1 - keep_prob)\\n if dropout > 0.0:\\n single_cell = tf.nn.rnn_cell.DropoutWrapper(\\n cell=single_cell, input_keep_prob=(1.0 - dropout))\\n utils.print_out(\\n \\\" %s, dropout=%g \\\" % (type(single_cell).__name__, dropout),\\n new_line=False)\\n\\n # Residual\\n if residual_connection:\\n single_cell = tf.nn.rnn_cell.ResidualWrapper(single_cell)\\n utils.print_out(\\\" %s\\\" % type(single_cell).__name__, new_line=False)\\n\\n # Device Wrapper\\n if device_str:\\n single_cell = tf.nn.rnn_cell.DeviceWrapper(single_cell, device_str)\\n utils.print_out(\\n \\\" %s, device=%s\\\" % (type(single_cell).__name__, device_str),\\n new_line=False)\\n\\n return single_cell\",\n \"def gru_encoder(cell, embedding, init_state, batch_input, batch_mask):\\n #batch_size = batch_input.get_shape()[0]\\n #state = tf.zeros([batch_size, options['state_size']], tf.float32) # initialize the state\\n outputs = []\\n #split_inputs = tf.split(1, batch_input.get_shape()[0], batch_input)\\n \\n with tf.device(\\\"/cpu:0\\\"):\\n embedded_list = tf.nn.embedding_lookup(embedding, batch_input)\\n #embedded_list = batch_mask * tf.transpose(embedded_list, [2, 0, 1]) # Add mask to change embedding into zeros\\n #embedded_list = tf.transpose(embedded_list, [2, 1, 0])\\n embedded_list = tf.transpose(embedded_list, [1, 0, 2])\\n embedded_list = tf.unpack(embedded_list) # list of embedding\\n \\n # min_sequence_length = tf.reduce_min(seq_len)\\n #max_sequence_length = tf.reduce_max(seq_len)\\n\\n state = init_state\\n for time, (embedded, i_mask) in enumerate(zip(embedded_list, tf.unpack(tf.transpose(batch_mask)))):\\n #embedded = tf.nn.embedding_lookup(embedding, tf.reshape(inputs, [-1])) # deprecated\\n #embedded = embedded * tf.reshape(tf.convert_to_tensor(batch_mask[:, time], tf.float32), [batch_size, 1]) # deprecated\\n #copy_cond = (time >= seq_len)\\n #new_output, new_state = cell(embedded, state)\\n output, state = cell(embedded, state)#tf.select(copy_cond, zero_output, new_output), tf.select(copy_cond, state, new_state)\\n output = tf.expand_dims(i_mask, 1) * output\\n outputs.append(output)\\n #outputs = batch_mask * tf.transpose(tf.pack(outputs), [2, 0, 1])\\n #outputs = tf.unpack(tf.transpose(outputs, [2, 1, 0]))\\n return outputs, state\",\n \"def add_prediction_op(self):\\n\\n #x_dropout = tf.keras.layers.SpatialDropout1D(0.4).apply(self.input_placeholder)\\n layer_1_size = 150\\n layer_2_size = 25\\n num_aux_feats = 4\\n\\n rnn_cell_layer_1_fwd = tf.nn.rnn_cell.GRUCell(\\n layer_1_size,\\n activation='relu',\\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\\n bias_initializer=tf.zeros_initializer(),\\n name=\\\"gru_1\\\",\\n dtype=tf.float32\\n )\\n\\n rnn_cell_layer_1_bwd = tf.nn.rnn_cell.GRUCell(\\n layer_1_size,\\n activation='relu',\\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\\n bias_initializer=tf.zeros_initializer(),\\n name=\\\"gru_1\\\",\\n dtype=tf.float32\\n )\\n\\n rnn_cell_layer_2_fwd = tf.nn.rnn_cell.GRUCell(\\n layer_2_size,\\n activation='relu',\\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\\n bias_initializer=tf.zeros_initializer(),\\n name=\\\"gru_2\\\",\\n dtype=tf.float32\\n )\\n\\n rnn_cell_layer_2_bwd = tf.nn.rnn_cell.GRUCell(\\n layer_2_size,\\n activation='relu',\\n kernel_initializer=tf.contrib.layers.xavier_initializer(),\\n bias_initializer=tf.zeros_initializer(),\\n name=\\\"gru_2\\\",\\n dtype=tf.float32\\n )\\n\\n outputs_1, states_1 = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw=rnn_cell_layer_1_fwd,\\n cell_bw=rnn_cell_layer_1_bwd,\\n inputs=self.input_placeholder,\\n sequence_length=self.batch_seq_length_placeholder,\\n dtype=tf.float32\\n )\\n h1 = tf.concat(outputs_1, axis=2, name=\\\"concat1\\\")\\n\\n outputs_2, states_2 = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw=rnn_cell_layer_2_fwd,\\n cell_bw=rnn_cell_layer_2_bwd,\\n inputs=h1,\\n dtype=tf.float32\\n )\\n h2 = tf.concat(states_2, axis=1, name=\\\"concat2\\\")\\n\\n h3 = tf.concat(\\n [\\n h2,\\n tf.reshape(self.batch_unique_count_placeholder, (-1, 1)),\\n tf.reduce_max(h2, axis=1, keepdims=True)\\n ],\\n axis=1,\\n name=\\\"concat3\\\"\\n )\\n num_aux_feats = 2\\n\\n #h_drop = tf.nn.dropout(state, keep_prob=0.8)\\n\\n with tf.name_scope(\\\"classifier\\\"):\\n self.W_ho = tf.get_variable(\\n \\\"W_ho\\\",\\n (layer_2_size * 2 + num_aux_feats, self.config.n_classes),\\n tf.float32,\\n tf.contrib.layers.xavier_initializer(),\\n trainable=True\\n )\\n self.b_o = tf.get_variable(\\n \\\"bo\\\",\\n (1, self.config.n_classes),\\n tf.float32, tf.zeros_initializer(),\\n trainable=True\\n )\\n pred = tf.matmul(h3, self.W_ho) + self.b_o\\n\\n return pred\",\n \"def biLSTM(inputs, dim, seq_len, name, cell_type=\\\"cudnn\\\", cells=None, is_training=True, dropout_rate=0.0):\\r\\n if cell_type==\\\"cudnn\\\":\\r\\n with tf.variable_scope(name,reuse=tf.AUTO_REUSE) as scope:\\r\\n hidden_states, cell_states = bi_cudnn_rnn_encoder('lstm', dim, 1, dropout_rate, inputs, seq_len, is_training)\\r\\n else:\\r\\n with tf.name_scope(name) as scope:\\r\\n with tf.variable_scope('forward' + name) as scope:\\r\\n if cell_type == \\\"lstm\\\":\\r\\n lstm_fwd = tf.contrib.rnn.LSTMCell(num_units=dim)\\r\\n with tf.variable_scope('backward' + name) as scope:\\r\\n if cell_type == \\\"lstm\\\":\\r\\n lstm_bwd = tf.contrib.rnn.LSTMCell(num_units=dim)\\r\\n \\r\\n with tf.variable_scope(name+'blstm', reuse=tf.AUTO_REUSE):\\r\\n hidden_states, cell_states = tf.nn.bidirectional_dynamic_rnn(cell_fw=lstm_fwd, cell_bw=lstm_bwd, inputs=inputs, sequence_length=seq_len, dtype=tf.float32, scope=name)\\r\\n\\r\\n return hidden_states, cell_states\",\n \"def _build_encoder_cell(self, hparams, num_layers, num_residual_layers):\\n\\t\\treturn _mh.create_rnn_cell(\\n\\t\\t\\tunit_type=hparams.unit_type,\\n\\t\\t\\tnum_units=self.num_units,\\n\\t\\t\\tnum_layers=num_layers,\\n\\t\\t\\tnum_residual_layers=num_residual_layers,\\n\\t\\t\\tforget_bias=hparams.forget_bias,\\n\\t\\t\\tdropout=hparams.dropout,\\n\\t\\t\\tmode=self.mode)\",\n \"def adj_batch():\\n return torch.Tensor([[[1, 3], [3, 1]], [[7, 8], [8, 7]]])\",\n \"def __init__(self,\\n cell_type: Text = \\\"lstm\\\",\\n tiers: Dict[int:List[int]] = {1:[1]},\\n window_sizes: List[int] = [1],\\n strides: List[int] = [1],\\n use_dense_layer_output : bool = False,\\n dense_layer_args : Dict = {\\\"units\\\": None,\\n \\\"activation\\\":None,#don't change this\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"kernel_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"activity_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n },\\n lstm_cell_args : Dict = {\\\"activation\\\":'tanh',\\n \\\"recurrent_activation\\\":'hard_sigmoid',\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"recurrent_initializer\\\":'orthogonal',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"unit_forget_bias\\\":True,\\n \\\"kernel_regularizer\\\":None,\\n \\\"recurrent_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"recurrent_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n \\\"implementation\\\":1,\\n },\\n gru_cell_args : Dict = {\\\"activation\\\":'tanh',\\n \\\"recurrent_activation\\\":'hard_sigmoid',\\n \\\"use_bias\\\":True,\\n \\\"kernel_initializer\\\":'glorot_uniform',\\n \\\"recurrent_initializer\\\":'orthogonal',\\n \\\"bias_initializer\\\":'zeros',\\n \\\"kernel_regularizer\\\":None,\\n \\\"recurrent_regularizer\\\":None,\\n \\\"bias_regularizer\\\":None,\\n \\\"kernel_constraint\\\":None,\\n \\\"recurrent_constraint\\\":None,\\n \\\"bias_constraint\\\":None,\\n \\\"implementation\\\":1,\\n \\\"reset_after\\\":False,\\n },\\n adam_opt_args : Dict = {\\\"learning_rate\\\": None,\\n \\\"epsilon\\\": None,\\n \\\"beta_1\\\": None,\\n \\\"beta_2\\\": None,\\n },\\n clip_norm : Optional[float] = None,\\n dropout_training = 0,\\n recurrent_dropout_training = 0,\\n tens_to_log = None,\\n checkpoint_path = None,\\n predict_batch_size = 30,\\n save_checkpoints_steps = 100,\\n keep_checkpoint_max = 10,\\n save_summary_steps = 10,\\n logging_step = 10,\\n ):\\n \\n if (len(tiers)!=len(window_sizes) or len(window_sizes)!=len(strides)):\\n raise ValueError(\\\"Mismatch in network geometry specs. Need number of\\\"\\n \\\" tiers = number of window size specs, or number of\\\"\\n \\\" window specs = number of stride specs.\\\")\\n \\n \\n self.cell_type = cell_type \\n self.tiers = tiers, \\n self.window_sizes = window_sizes,\\n self.strides = strides,\\n self.use_dense_layer_output = use_dense_layer_output\\n self.dense_layer_args = dense_layer_args,\\n self.lstm_cell_args = lstm_cell_args,\\n self.gru_cell_args = gru_cell_args,\\n self.adam_opt_args = adam_opt_args,\\n self.clip_norm = clip_norm,\\n self.dropout_training = 0,\\n self.recurrent_dropout_training = recurrent_dropout_training,\\n self.tens_to_log = tens_to_log,\\n self.checkpoint_path = None,\\n self.predict_batch_size = 30,\\n self.save_checkpoints_steps = 100,\\n self.keep_checkpoint_max = 10,\\n self.save_summary_steps = 20,\\n self.logging_step = 10\",\n \"def _input_module(self):\\n # GRU cell description\\n self.cell = tf.nn.rnn_cell.GRUCell(\\n num_units=self.config.hidden_size,\\n input_size=self.config.word_vector_length)\\n\\n # Get output after every word.\\n # outputs: (BATCH_SIZE, n_words, HIDDEN_SIZE)\\n # state: The last output (1, HIDDEN_SIZE)\\n outputs, state = tf.nn.dynamic_rnn(self.cell,\\n self.input_placeholder,\\n self.input_length_placeholder,\\n dtype='float32')\\n\\n context_rnn_out = tf.reshape(outputs, [-1, self.config.hidden_size]) # Now the shape = [n_words, n_units]\\n\\n # Only project the state at the end of each sentence\\n sentence_representations_mat = tf.gather(context_rnn_out,\\n self.end_of_sentences_placeholder) # (1, n_sentences, HIDDEN_SIZE)\\n\\n # The code below it necessary to split the Tensor(?,HIDDEN_SIZE) in a list of tensors with shape (1,HIDDEN_SIZE)\\n\\n # Reshape `X` as a vector. -1 means \\\"set this dimension automatically\\\".\\n sentences_as_vector = tf.reshape(sentence_representations_mat, [-1])\\n\\n # Create another vector containing zeroes to pad `X` to (MAX_INPUT_LENGTH * WORD_VECTOR_LENGTH) elements.\\n zero_padding = tf.zeros(\\n [self.dataset.max_input_size * self.config.hidden_size] - tf.shape(sentences_as_vector),\\n dtype=sentences_as_vector.dtype)\\n\\n # Concatenate `X_as_vector` with the padding.\\n sentences_padded_as_vector = tf.concat(0, [sentences_as_vector, zero_padding])\\n\\n # Reshape the padded vector to the desired shape.\\n sentences_padded = tf.reshape(sentences_padded_as_vector, [self.dataset.max_input_size,\\n self.config.hidden_size])\\n\\n # Split X into a list of tensors of length MAX_INPUT_LENGTH where each tensor is a 1xHIDDEN_SIZE vector\\n # of the word vectors\\n self.sentence_representations = tf.split(0, self.dataset.max_input_size, sentences_padded)\\n\\n self.number_of_sentences = tf.shape(sentence_representations_mat)[1]\\n\\n self.input_only_for_testing = tf.concat(0, self.sentence_representations)\\n\\n # Result of this module:\\n # - List of sentences. Each sentence is a tensor of shape (1, HIDDEN_UNITS). 1=Batch_size\\n # - The number of sentences.\",\n \"def TextRCNN2(inputs, lstm_size=256, cnns=[(32,1), (32,3), (64,5), (128,7)]):\\n tf_input, cnn_feats = cnn_backbone(inputs=inputs, cnns=cnns)\\n\\n tf_x = tf.keras.layers.concatenate(cnn_feats)\\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size, return_sequences=True)(tf_x)\\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size, return_sequences=True)(tf_x)\\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size, return_sequences=True)(tf_x)\\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size)(tf_x)\\n \\n tf_readout = tf.keras.layers.Dense(1, activation='sigmoid')(tf_x)\\n model = tf.keras.models.Model(tf_input, tf_readout, name='TextRCNN2') \\n model.compile(loss='binary_crossentropy', optimizer='adam')\\n return model\",\n \"def unroll_cell(self, decoder_inputs, initial_state, loop_function, cell):\\n pass\",\n \"def generator(real_init): #-1, 5, 3\\n with tf.variable_scope('rnn_gen', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n x_init = real_init[:,:,0] #-1, 8\\n y_init = real_init[:,:,1] #-1, 8\\n z_init = real_init[:,:,2] #-1, 8\\n \\n with tf.variable_scope('x_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n x_w1 = tf.get_variable('x_w1', [6, 3])\\n x_b1 = tf.get_variable('x_b1', [3])\\n x_w2 = tf.get_variable('x_w2', [9, 3])\\n x_b2 = tf.get_variable('x_b2', [3])\\n x_w3 = tf.get_variable('x_w3', [3, 1])\\n x_b3 = tf.get_variable('x_b3', [1])\\n x_w4 = tf.get_variable('x_w4', [3, 1])\\n x_b4 = tf.get_variable('x_b4', [1])\\n \\n x_full = x_init#-1, 8\\n for i in range(104):\\n x_layer1 = tf.nn.elu(tf.matmul(x_init, x_w1) + x_b1)#-1, 4\\n x_layer2 = tf.concat([x_init, x_layer1], 1)#-1, 12\\n x_layer3 = tf.nn.elu(tf.matmul(x_layer2, x_w2) + x_b2)#-1, 4\\n \\n x_mean = tf.sigmoid(tf.matmul(x_layer3, x_w3) + x_b3)#-1, 1\\n x_gamma = tf.sigmoid(tf.matmul(x_layer3, x_w4) + x_b4)#-1, 1\\n x_delta = x_mean + x_gamma * tf.random_normal(tf.shape(x_gamma), dtype = tf.float32)#-1, 1\\n x_delta_denorm = (x_delta * 2 - 1) / 80\\n x_output = tf.expand_dims(x_full[:,-1], 1) + x_delta_denorm\\n x_full = tf.concat([x_full, x_output], axis = 1)#-1, 10 + 1\\n x_init = x_full[:,-6:]\\n \\n with tf.variable_scope('y_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n y_w1 = tf.get_variable('y_w1', [6, 3])\\n y_b1 = tf.get_variable('y_b1', [3])\\n y_w2 = tf.get_variable('y_w2', [9, 3])\\n y_b2 = tf.get_variable('y_b2', [3])\\n y_w3 = tf.get_variable('y_w3', [3, 1])\\n y_b3 = tf.get_variable('y_b3', [1])\\n y_w4 = tf.get_variable('y_w4', [3, 1])\\n y_b4 = tf.get_variable('y_b4', [1])\\n \\n y_full = y_init#-1, 8\\n for i in range(104):\\n y_layer1 = tf.nn.elu(tf.matmul(y_init, y_w1) + y_b1)\\n y_layer2 = tf.concat([y_init, y_layer1], 1)#-1, 12\\n y_layer3 = tf.nn.elu(tf.matmul(y_layer2, y_w2) + y_b2)#-1, 4\\n \\n y_mean = tf.sigmoid(tf.matmul(y_layer3, y_w3) + y_b3) #-1, 1\\n y_gamma = tf.sigmoid(tf.matmul(y_layer3, y_w4) + y_b4) #-1, 1\\n y_delta = y_mean + y_gamma * tf.random_normal(tf.shape(y_gamma), dtype = tf.float32)#-1, 1\\n y_delta_denorm = (y_delta * 5 - 2.7) / 1700\\n y_output = tf.expand_dims(y_full[:,-1], 1) + y_delta_denorm\\n y_full = tf.concat([y_full, y_output], axis = 1)#-1, 10 + 1, 1\\n y_init = y_full[:,-6:]\\n \\n with tf.variable_scope('z_rw', reuse = tf.AUTO_REUSE, initializer=tf.contrib.layers.xavier_initializer()) as scope:\\n z_w1 = tf.get_variable('z_w1', [6, 3])\\n z_b1 = tf.get_variable('z_b1', [3])\\n z_w2 = tf.get_variable('z_w2', [9, 3])\\n z_b2 = tf.get_variable('z_b2', [3])\\n z_w3 = tf.get_variable('z_w3', [3, 1])\\n z_b3 = tf.get_variable('z_b3', [1])\\n z_w4 = tf.get_variable('z_w4', [3, 1])\\n z_b4 = tf.get_variable('z_b4', [1])\\n \\n z_full = z_init#-1, 8\\n for i in range(104):\\n z_layer1 = tf.nn.elu(tf.matmul(z_init, z_w1) + z_b1)\\n z_layer2 = tf.concat([z_init, z_layer1], 1)#-1, 12\\n z_layer3 = tf.nn.elu(tf.matmul(z_layer2, z_w2) + z_b2)#-1, 4\\n \\n z_mean = tf.sigmoid(tf.matmul(z_layer3, z_w3) + z_b3) #-1, 1\\n z_gamma = tf.sigmoid(tf.matmul(z_layer3, z_w4) + z_b4) #-1, 1\\n z_delta = z_mean + z_gamma * tf.random_normal(tf.shape(z_gamma), dtype = tf.float32)#-1, 1\\n z_delta_denorm = (z_delta * 3 - 2.2) / 300\\n z_output = tf.expand_dims(z_full[:,-1], 1) + z_delta_denorm\\n z_full = tf.concat([z_full, z_output], axis = 1)#-1, 10 + 1, 1\\n z_init = z_full[:,-6:]\\n \\n rand_layer1 = tf.concat([tf.expand_dims(x_full, 2), tf.expand_dims(y_full, 2), tf.expand_dims(z_full, 2)], axis = 2)#-1, 200, 3\\n rand_layer1_reshape = tf.reshape(rand_layer1, shape = (-1, 110, 3, 1))\\n output_filt = tf.ones(shape = (11, 1, 1, 1)) / 11\\n \\n rand_layer2 = tf.nn.conv2d(rand_layer1_reshape, output_filt, strides = [1,1,1,1], padding = 'VALID')\\n \\n return tf.reshape(rand_layer2, shape = (-1, 100, 3)) #-1, 110, 3\",\n \"def simple_batching(config, insts: List[Instance]) -> Tuple[torch.Tensor,torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor]:\\n batch_size = len(insts)\\n batch_data = insts\\n # probably no need to sort because we will sort them in the model instead.\\n # batch_data = sorted(insts, key=lambda inst: len(inst.input.words), reverse=True) ##object-based not direct copy\\n sent_seq_len = torch.LongTensor(list(map(lambda inst: len(inst.input.sents), batch_data)))\\n max_seq_len = sent_seq_len.max()\\n\\n # num_tokens = torch.LongTensor(list(map(lambda inst: inst.max_num_tokens, batch_data)))\\n # max_tokens = num_tokens.max()\\n\\n num_tokens = list(map(lambda inst: inst.num_tokens, batch_data)) # 2-dimension\\n max_tokens = max([max(num_token) for num_token in num_tokens])\\n\\n # NOTE: Use 1 here because the CharBiLSTM accepts\\n char_seq_len = torch.LongTensor([list(map(len, inst.input.sents)) + [1] * (int(max_seq_len) - len(inst.input.sents)) for inst in batch_data])\\n max_char_seq_len = char_seq_len.max()\\n\\n context_emb_tensor = None\\n if config.context_emb != ContextEmb.none:\\n emb_size = insts[0].elmo_vec.shape[1]\\n context_emb_tensor = torch.zeros((batch_size, max_seq_len, emb_size))\\n\\n # emb_size = len(insts[0][0].vec)\\n # print('emb_size: ',emb_size)\\n emb_size = 768\\n\\n # word_seq_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\\n label_seq_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\\n review_idx_tensor = torch.full((batch_size, max_seq_len),0, dtype=torch.long)\\n reply_idx_tensor = torch.full((batch_size, max_seq_len),0, dtype=torch.long)\\n\\n char_seq_tensor = torch.zeros((batch_size, max_seq_len, max_char_seq_len), dtype=torch.long)\\n\\n initial_sent_emb_tensor = torch.zeros((batch_size, max_seq_len, max_tokens, emb_size), dtype=torch.float32)\\n sent_emb_tensor = torch.zeros((1,), dtype=torch.float32)\\n\\n # input = torch.zeros((batch_size, num_sents, emb_size))\\n\\n type_id_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\\n num_tokens_tensor = torch.zeros((batch_size, max_seq_len), dtype=torch.long)\\n\\n pair_tensor = torch.zeros((batch_size,max_seq_len,max_seq_len), dtype = torch.float32)\\n pair_tensor_train = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\\n pair_padding_tensor = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\\n pair_padding_train = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\\n # pair_padding_tensor1 = torch.zeros((batch_size, max_seq_len, max_seq_len), dtype=torch.float32)\\n\\n max_review_tensor = torch.zeros((batch_size), dtype=torch.long)\\n\\n for idx in range(batch_size):\\n\\n\\n # word_seq_tensor[idx, :word_seq_len[idx]] = torch.LongTensor(batch_data[idx].word_ids)\\n if batch_data[idx].output_ids:\\n # print('output_ids: ', batch_data[idx].output_ids)\\n # print('review_idx: ', batch_data[idx].review_idx)\\n # print(sent_seq_len[idx])\\n # print(\\\"batch_data[idx].max_review_id: \\\",batch_data[idx].max_review_id )\\n max_review_tensor[idx]=batch_data[idx].max_review_id\\n label_seq_tensor[idx, :sent_seq_len[idx]] = torch.LongTensor(batch_data[idx].output_ids)\\n review_idx_tensor[idx, torch.LongTensor(batch_data[idx].review_idx)] = torch.LongTensor(batch_data[idx].review_idx)\\n reply_idx_tensor[idx, torch.LongTensor(batch_data[idx].reply_idx)] = torch.LongTensor(batch_data[idx].reply_idx)\\n type_id_tensor[idx, :sent_seq_len[idx]] = torch.LongTensor(batch_data[idx].type)\\n num_tokens_tensor[idx, :sent_seq_len[idx]] = torch.LongTensor(batch_data[idx].num_tokens)\\n\\n if config.context_emb != ContextEmb.none:\\n context_emb_tensor[idx, :sent_seq_len[idx], :] = torch.from_numpy(batch_data[idx].elmo_vec)\\n # print('type id tensor', type_id_tensor[idx])\\n # print('max review id', batch_data[idx].max_review_id, len(batch_data[idx].review_idx))\\n # pair_padding_tensor[idx, :len(batch_data[idx].review_idx), batch_data[idx].max_review_id:sent_seq_len[idx]] = 1.0\\n # pair_padding_tensor[idx, torch.LongTensor(batch_data[idx].review_idx), torch.LongTensor(batch_data[idx].reply_idx)] = 1.0\\n\\n\\n for sent_idx in range(sent_seq_len[idx]):\\n for token_idx in range(num_tokens[idx][sent_idx]):\\n initial_sent_emb_tensor[idx, sent_idx, token_idx, :emb_size] = torch.Tensor(batch_data[idx].vec[sent_idx][token_idx])\\n\\n # print('sent_emb_tensor', sent_emb_tensor[idx, sent_idx, 0])\\n char_seq_tensor[idx, sent_idx, :char_seq_len[idx, sent_idx]] = torch.LongTensor(batch_data[idx].char_ids[sent_idx])\\n\\n if sent_idx < batch_data[idx].max_review_id:\\n for sent_idx2 in range(sent_idx+1, sent_seq_len[idx]):\\n if batch_data[idx].labels_pair[sent_idx] == batch_data[idx].labels_pair[sent_idx2] \\\\\\n and batch_data[idx].labels_pair[sent_idx] != 0 \\\\\\n and batch_data[idx].type[sent_idx] == 0 and batch_data[idx].type[sent_idx2] == 1:\\n pair_tensor[idx,sent_idx,sent_idx2]=1.0\\n pair_tensor_train[idx, sent_idx, sent_idx2] = 1.0\\n #if batch_data[idx].type[sent_idx]==0 and batch_data[idx].type[sent_idx2]==1:\\n # pair_padding_train[idx, sent_idx, sent_idx2] = 1.0\\n if batch_data[idx].labels_pair[sent_idx] != 0 and batch_data[idx].labels_pair[sent_idx2] != 0 \\\\\\n and batch_data[idx].type[sent_idx] == 0 and batch_data[idx].type[sent_idx2] == 1:\\n pair_padding_tensor[idx,sent_idx,sent_idx2]=1.0\\n # if batch_data[idx].type[sent_idx2 - 1] == 1:\\n # pair_padding_tensor[idx, sent_idx, sent_idx2-1] = 1.0\\n # if batch_data[idx].type[sent_idx2 - 2] == 1:\\n # pair_padding_tensor[idx, sent_idx, sent_idx2 - 2] = 1.0\\n # if sent_idx2 +1 < sent_seq_len[idx]:\\n # pair_padding_tensor[idx, sent_idx, sent_idx2 + 1] = 1.0\\n # if sent_idx2 + 2 < sent_seq_len[idx]:\\n # pair_padding_tensor[idx, sent_idx, sent_idx2 + 2] = 1.0\\n # print(\\\"sum:\\\", pair_padding_tensor.sum())\\n # print((pair_padding_tensor[idx]==pair_padding_tensor1[idx]).all())\\n\\n # print('sum of pair padding tensor', torch.sum(pair_padding_tensor[idx]),torch.sum(pair_padding_tensor1[idx]))\\n # print(pair_padding_tensor[idx][:100])\\n\\n\\n # print(pair_tensor[idx,])\\n for sentIdx in range(sent_seq_len[idx], max_seq_len):\\n char_seq_tensor[idx, sentIdx, 0: 1] = torch.LongTensor([config.char2idx[PAD]]) ###because line 119 makes it 1, every single character should have a id. but actually 0 is enough\\n\\n tmp = pair_padding_tensor + pair_tensor\\n\\n for idx in range(batch_size):\\n\\n for sent_idx in range(sent_seq_len[idx]):\\n # pair_padding_train[idx, sent_idx,tmp[idx,sent_idx,:]==1] =1\\n\\n if (tmp[idx, sent_idx, :] == 1).sum() >= 5:\\n valid_idx = (tmp[idx, sent_idx, :] == 1).nonzero().view(-1)\\n choice = torch.multinomial(valid_idx.float(), 5)\\n pair_padding_train[idx, sent_idx, valid_idx[choice]] = 1\\n else:\\n pair_padding_train[idx, sent_idx,tmp[idx,sent_idx,:]==1] =1\\n\\n #if (tmp[idx, sent_idx, :] == 0).sum() >= 1:\\n # valid_idx = (tmp[idx, sent_idx, :] == 0).nonzero().view(-1)\\n # choice = torch.multinomial(valid_idx.float(), 1)\\n # pair_padding_train[idx, sent_idx, valid_idx[choice]] = 1\\n #else:\\n # pair_padding_train[idx, sent_idx,tmp[idx,sent_idx,:]==0] =1\\n\\n\\n pair_padding_train[pair_tensor == 1] = 1\\n pair_tensor_train[pair_padding_train == 0] = -100\\n pair_tensor[pair_padding_tensor == 0] = -100\\n\\n # print('number of not -100', torch.sum(pair_tensor != -100), torch.sum(pair_tensor_train != -100))\\n # word_seq_tensor = word_seq_tensor.to(config.device)\\n label_seq_tensor = label_seq_tensor.to(config.device)\\n char_seq_tensor = char_seq_tensor.to(config.device)\\n sent_seq_len = sent_seq_len.to(config.device)\\n char_seq_len = char_seq_len.to(config.device)\\n\\n # sent_emb_tensor = sent_emb_tensor.to(config.device)\\n type_id_tensor = type_id_tensor.to(config.device)\\n\\n review_idx_tensor = review_idx_tensor.to(config.device)\\n reply_idx_tensor = reply_idx_tensor.to(config.device)\\n\\n pair_tensor = pair_tensor.to(config.device)\\n pair_padding_tensor = pair_padding_tensor.to(config.device)\\n pair_padding_train = pair_padding_train.to(config.device)\\n pair_tensor_train = pair_tensor_train.to(config.device)\\n\\n return sent_emb_tensor, type_id_tensor, sent_seq_len, num_tokens_tensor, initial_sent_emb_tensor, context_emb_tensor, char_seq_tensor, char_seq_len, pair_tensor,pair_padding_tensor, label_seq_tensor, review_idx_tensor, reply_idx_tensor, pair_tensor_train, pair_padding_train, max_review_tensor\",\n \"def nn_kras():\\n return GCN_simple(29, [3], 2, 7, dropout=0)\",\n \"def LSTMLayer(cell_name, weights, m, c, x_seq, pad_seq):\\n if len(x_seq) != len(pad_seq):\\n raise ValueError('length of x_seq(%d) != pad_seq(%d)' %\\n (len(x_seq), len(pad_seq)))\\n out_seq = []\\n for seq in range(len(x_seq)):\\n with ops.name_scope('%s_%d' % (cell_name, seq)):\\n m, c = LSTMCell(weights, m, c, x_seq[seq], pad_seq[seq])\\n out_seq.append(array_ops.identity(m, name='out'))\\n return out_seq\",\n \"def __init__(self, device, input_size, hidden_size, layer_norm=False, chrono_init=False, t_max=10):\\n\\n super(LSTMCell, self).__init__()\\n\\n self._device = device\\n self._input_size = input_size\\n self._hidden_size = hidden_size\\n self._layer_norm = layer_norm\\n self._chrono_init = chrono_init\\n self._t_max = t_max\\n\\n self._W_x2i = nn.Parameter(torch.Tensor(input_size, hidden_size))\\n self._W_h2i = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\\n self._W_c2i = nn.Parameter(torch.Tensor(hidden_size))\\n self._b_i = nn.Parameter(torch.Tensor(hidden_size))\\n \\n self._W_x2f = nn.Parameter(torch.Tensor(input_size, hidden_size))\\n self._W_h2f = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\\n self._W_c2f = nn.Parameter(torch.Tensor(hidden_size))\\n self._b_f = nn.Parameter(torch.Tensor(hidden_size))\\n \\n self._W_x2o = nn.Parameter(torch.Tensor(input_size, hidden_size))\\n self._W_h2o = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\\n self._W_c2o = nn.Parameter(torch.Tensor(hidden_size))\\n self._b_o = nn.Parameter(torch.Tensor(hidden_size))\\n \\n self._W_x2c = nn.Parameter(torch.Tensor(input_size, hidden_size))\\n self._W_h2c = nn.Parameter(torch.Tensor(hidden_size, hidden_size))\\n self._b_c = nn.Parameter(torch.Tensor(hidden_size))\\n\\n if self._layer_norm:\\n self._ln_c = nn.LayerNorm(hidden_size)\\n self._ln_i = nn.LayerNorm(hidden_size)\\n self._ln_f = nn.LayerNorm(hidden_size)\\n self._ln_o = nn.LayerNorm(hidden_size)\\n self._ln_g = nn.LayerNorm(hidden_size)\\n \\n self._reset_parameters()\",\n \"def TextRCNN1(inputs, lstm_size=1024, cnns=[(32,1), (32,3), (64,5), (128,7)]):\\n tf_input, cnn_feats = cnn_backbone(inputs=inputs, cnns=cnns)\\n\\n tf_x = tf.keras.layers.concatenate(cnn_feats)\\n tf_x = tf.keras.layers.CuDNNLSTM(lstm_size)(tf_x)\\n \\n tf_readout = tf.keras.layers.Dense(1, activation='sigmoid')(tf_x)\\n model = tf.keras.models.Model(tf_input, tf_readout, name='TextRCNN1') \\n model.compile(loss='binary_crossentropy', optimizer='adam')\\n return model\",\n \"def _generate_cells(self) -> None:\\n for i in range(15):\\n for j in range(15):\\n c = Cell(x=i, y=j)\\n c.answer = self.puzzle.solution[j*self.width+i]\\n self.cells[(j, i)] = c # row, col\",\n \"def _build_pnasnet_base(\\n hidden_previous, hidden, normal_cell, hparams, true_cell_num,\\n start_cell_num):\\n\\n # Find where to place the reduction cells or stride normal cells\\n reduction_indices = nasnet_utils.calc_reduction_layers(\\n hparams.num_cells, hparams.num_reduction_layers)\\n filter_scaling = _filter_scaling(reduction_indices, start_cell_num)\\n\\n # Note: The None is prepended to match the behavior of _imagenet_stem()\\n cell_outputs = [None, hidden_previous, hidden]\\n net = hidden\\n\\n # Run the cells\\n for cell_num in range(start_cell_num, hparams.num_cells):\\n is_reduction = cell_num in reduction_indices\\n stride = 2 if is_reduction else 1\\n if is_reduction: filter_scaling *= hparams.filter_scaling_rate\\n prev_layer = cell_outputs[-2]\\n net = normal_cell(\\n net,\\n scope='cell_{}'.format(cell_num),\\n filter_scaling=filter_scaling,\\n stride=stride,\\n prev_layer=prev_layer,\\n cell_num=true_cell_num)\\n true_cell_num += 1\\n cell_outputs.append(net)\\n\\n # Final nonlinearity.\\n # Note that we have dropped the final pooling, dropout and softmax layers\\n # from the default pnasnet version.\\n with tf.variable_scope('final_layer'):\\n net = tf.nn.relu(net)\\n return net\",\n \"def set_cells(self, val=None):\\t\\r\\n self._cells = \\\\\\r\\n (self.nx-1 if self.nx>1 else 1)* \\\\\\r\\n (self.ny-1 if self.ny>1 else 1)* \\\\\\r\\n (self.nz-1 if self.nz>1 else 1)\",\n \"def test_output_head_shapes_correct():\\n N = 20\\n X = torch.randn((N, 10, 4)) * -20.0\\n for _ in range(25):\\n nn_instance = RNN(input_dim=4,\\n layers_info=[[\\\"gru\\\", 20], [\\\"lstm\\\", 8], [\\\"linear\\\", 1], [\\\"linear\\\", 12]],\\n hidden_activations=\\\"relu\\\")\\n out = nn_instance(X)\\n assert out.shape[0] == N\\n assert out.shape[1] == 12\\n\\n for output_dim in [[ [\\\"linear\\\", 10], [\\\"linear\\\", 4], [\\\"linear\\\", 6]], [[\\\"linear\\\", 3], [\\\"linear\\\", 8], [\\\"linear\\\", 9]]]:\\n nn_instance = RNN(input_dim=4,\\n layers_info=[[\\\"gru\\\", 20], [\\\"lstm\\\", 8], [\\\"linear\\\", 1], [\\\"linear\\\", 12], output_dim],\\n hidden_activations=\\\"relu\\\", output_activation=[\\\"softmax\\\", None, \\\"relu\\\"])\\n out = nn_instance(X)\\n assert out.shape[0] == N\\n assert out.shape[1] == 20\",\n \"def rnn(rnn_type, inputs, length, hidden_size, layer_num=1, dropout_keep_prob=None, concat=True):\\n if not rnn_type.startswith('bi'):\\n cell = get_cell(rnn_type, hidden_size, layer_num, dropout_keep_prob)\\n outputs, states = tf.nn.dynamic_rnn(cell, inputs, sequence_length=length, dtype=tf.float32)\\n if rnn_type.endswith('lstm'):\\n c = [state.c for state in states]\\n h = [state.h for state in states]\\n states = h\\n else:\\n cell_fw = get_cell(rnn_type, hidden_size, layer_num, dropout_keep_prob)\\n cell_bw = get_cell(rnn_type, hidden_size, layer_num, dropout_keep_prob)\\n outputs, states = tf.nn.bidirectional_dynamic_rnn(\\n cell_bw, cell_fw, inputs, sequence_length=length, dtype=tf.float32\\n )\\n states_fw, states_bw = states\\n if rnn_type.endswith('lstm'):\\n c_fw = [state_fw.c for state_fw in states_fw]\\n h_fw = [state_fw.h for state_fw in states_fw]\\n c_bw = [state_bw.c for state_bw in states_bw]\\n h_bw = [state_bw.h for state_bw in states_bw]\\n states_fw, states_bw = h_fw, h_bw\\n if concat:\\n outputs = tf.concat(outputs, 2)\\n states = tf.concat([states_fw, states_bw], 1)\\n else:\\n outputs = outputs[0] + outputs[1]\\n states = states_fw + states_bw\\n return outputs, states\",\n \"def add_dense_layer(self):\\n output = self.cnn_layer\\n # weight_shape is dimension 1 of the first weights in the dense layer. We\\n # update it accordingly as we keep adding intermediate layers\\n weight_shape = self.out_channels_2\\n if self.hybrid:\\n with tf.variable_scope(\\\"lstm_layer\\\"):\\n print(\\\"adding Recurrent layer\\\")\\n if self.rnn:\\n print(\\\"Adding Basic RNN cell\\\")\\n cell_fw = tf.contrib.rnn.BasicRNNCell(self.lstm_size)\\n cell_bw = tf.contrib.rnn.BasicRNNCell(self.lstm_size)\\n elif self.gru:\\n print(\\\"Adding GRU cell\\\")\\n cell_fw = tf.contrib.rnn.GRUCell(self.lstm_size)\\n cell_bw = tf.contrib.rnn.GRUCell(self.lstm_size)\\n elif self.elman:\\n print(\\\"Adding ELMAN cell\\\")\\n cell_fw = ElmanRNNCell(self.lstm_size)\\n cell_bw = ElmanRNNCell(self.lstm_size)\\n else:\\n print(\\\"Adding LSTM cell\\\")\\n cell_fw = tf.contrib.rnn.LSTMCell(self.lstm_size)\\n cell_bw = tf.contrib.rnn.LSTMCell(self.lstm_size)\\n if self.use_window_rnn:\\n cnn_values = self.cnn_values\\n print(\\\"using window_rnn\\\")\\n else:\\n print(\\\"not using window_rnn\\\")\\n cnn_values = self.cnn_layer\\n (output_fw, output_bw), _ = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw, cell_bw, cnn_values,\\n sequence_length=self.sequence_lengths, dtype=tf.float32\\n )\\n output = tf.concat([output_fw, output_bw], axis=-1)\\n output = tf.nn.dropout(output, self.dropout_holder)\\n self.word_reps = output\\n weight_shape = 2*self.lstm_size\\n with tf.variable_scope(\\\"dense_layer\\\"):\\n print(\\\"adding dense layer\\\")\\n # weight_shape_2 is dimension 2 of the first weights in the dense layer.\\n # we update it accordingly if we add more layers at the end\\n weight_shape_2 = self.tag_count\\n if self.pos and (self.single_ann or self.pos_ann):\\n # this if block is for the cases when we have to concatenate the output\\n # from prevoius layer to pos_embeddings\\n print(\\\"Concatenating pos vecs with lstm/cnn output\\\")\\n output = tf.concat([output, self.pos_vecs], axis=-1)\\n weight_shape = weight_shape + self.pos_embedding_size\\n output = tf.reshape(output, [-1, weight_shape])\\n if self.single_ann:\\n # This means we will have a hidden layer i.e two weights.\\n print(\\\"Setting up hidden layer for single ann\\\")\\n weight_shape_2 = self.ann_size\\n if self.pos and not self.concat_pos and self.bi_ann:\\n # this if block si for the case when we want to implement a bi-partite\\n # ann, as such we will get weights for pos embeddings\\n print(\\\"setting up network for bi ann..\\\")\\n weight_shape_2 = self.ann_size\\n w_pos = tf.get_variable(\\\"w_pos\\\", dtype=tf.float32,\\n shape=[self.pos_embedding_size,\\n self.pos_ann_count])\\n b_pos = tf.get_variable(\\\"b_pos\\\", dtype=tf.float32,\\n shape=[self.pos_ann_count],\\n initializer=tf.zeros_initializer())\\n output_pos = tf.reshape(self.pos_vecs, [-1, self.pos_embedding_size])\\n pred_pos = tf.matmul(output_pos, w_pos) + b_pos\\n output = tf.reshape(output, [-1, weight_shape])\\n if len(output.shape) == 3:\\n print(\\\"Setting up a network with no ann, only a fully connected dense \\\"\\n \\\"layer\\\")\\n # we have to reshape our output so that we can multiply it with weights.\\n # if we reach here, it means we haven't reshaped it properly.\\n output = tf.reshape(output, [-1, weight_shape])\\n w1 = tf.get_variable(\\\"w1\\\", dtype=tf.float32,\\n shape=[weight_shape, weight_shape_2])\\n b1 = tf.get_variable(\\\"b1\\\", dtype=tf.float32, shape=[weight_shape_2],\\n initializer=tf.zeros_initializer())\\n pred = tf.matmul(output, w1) + b1\\n # the pred above has weight_shape_2 as it's second dimension. our vars\\n # have been defined in such a way that weight_shape_2 = self.tag_count if\\n # we don't have to care about adding another layer.\\n if self.pos and not self.concat_pos and self.bi_ann:\\n # This block deals with concatenating output of pos hidden layer to\\n # pred. We change weight_shape_2 accordingly.\\n print(\\\"setting up network for bi ann..\\\")\\n pred = tf.concat([pred, pred_pos], axis=-1)\\n weight_shape_2 = weight_shape_2 + self.pos_ann_count\\n\\n if self.pos and (self.single_ann or self.bi_ann):\\n # now, these are our final sets of weights in case we have an ann. so\\n # the second dimension of these weights is self.tag_count!\\n print(\\\"setting up network for ann\\\")\\n w2 = tf.get_variable(\\\"w2\\\", dtype=tf.float32, shape=[weight_shape_2,\\n self.tag_count])\\n b2 = tf.get_variable(\\\"b2\\\", shape=[self.tag_count], dtype=tf.float32,\\n initializer=tf.zeros_initializer())\\n pred = tf.matmul(pred, w2) + b2\\n self.logits = tf.reshape(pred, [-1, self.max_len, self.tag_count])\",\n \"def apply_net_tiled(net,img):\\n\\n # borders = [8,20,20] ## border width within each patch that is thrown away after prediction\\n # patchshape_padded = [32,240,240] ## the size of the patch that we feed into the net. must be divisible by 8 or net fails.\\n # patchshape = [16,200,200] ## must be divisible by 8 to avoid artifacts.\\n # stride = [16,200,200] ## same as patchshape in this case\\n def f(n,m): return (ceil(n/m)*m)-n ## f(n,m) gives padding needed for n to be divisible by m\\n def g(n,m): return (floor(n/m)*m)-n ## f(n,m) gives un-padding needed for n to be divisible by m\\n\\n a,b,c = img.shape[1:]\\n q,r,s = f(a,8),f(b,8),f(c,8) ## calculate extra border needed for stride % 8 = 0\\n\\n ZPAD,YPAD,XPAD = 8,24,24\\n\\n img_padded = np.pad(img,[(0,0),(ZPAD,ZPAD+q),(YPAD,YPAD+r),(XPAD,XPAD+s)],mode='constant') ## pad for patch borders\\n output = np.zeros(img.shape)\\n\\n zs = np.r_[:a:16]\\n ys = np.r_[:b:200]\\n xs = np.r_[:c:200]\\n\\n for x,y,z in itertools.product(xs,ys,zs):\\n qe,re,se = min(z+16,a+q),min(y+200,b+r),min(x+200,c+s)\\n ae,be,ce = min(z+16,a),min(y+200,b),min(x+200,c)\\n patch = img_padded[:,z:qe+2*ZPAD,y:re+2*YPAD,x:se+2*XPAD]\\n patch = torch.from_numpy(patch).cuda().float()\\n patch = net(patch[None])[0,:,ZPAD:-ZPAD,YPAD:-YPAD,XPAD:-XPAD].detach().cpu().numpy()\\n output[:,z:ae,y:be,x:ce] = patch[:,:ae-z,:be-y,:ce-x]\\n\\n return output\",\n \"def n_step_rnn_base(n_layers, dropout_ratio, hx, ws, bs, xs,\\n activation, use_bi_direction, **kwargs): # NOQA\\n\\n argument.check_unexpected_kwargs(\\n kwargs, train='train argument is not supported anymore. '\\n 'Use chainer.using_config',\\n use_cudnn='use_cudnn argument is not supported anymore. '\\n 'Use chainer.using_config')\\n argument.assert_kwargs_empty(kwargs)\\n\\n activation_list = ['tanh', 'relu']\\n if activation not in activation_list:\\n candidate = ','.join(activation_list)\\n raise ValueError('Invalid activation: \\\"%s\\\". Please select from [%s]'\\n % (activation, candidate))\\n\\n xp = cuda.get_array_module(hx)\\n\\n if xp is not numpy and chainer.should_use_cudnn('>=auto', 5000):\\n states = get_random_state().create_dropout_states(dropout_ratio)\\n lengths = [len(x) for x in xs]\\n xs = chainer.functions.concat(xs, axis=0)\\n\\n rnn_mode = 'rnn_%s' % activation\\n w = cudnn_rnn_weight_concat(\\n n_layers, states, use_bi_direction, rnn_mode, ws, bs)\\n\\n if use_bi_direction:\\n # Bi-directional RNN\\n if activation == 'tanh':\\n rnn = NStepBiRNNTanh\\n elif activation == 'relu':\\n rnn = NStepBiRNNReLU\\n else:\\n # Uni-directional RNN\\n if activation == 'tanh':\\n rnn = NStepRNNTanh\\n elif activation == 'relu':\\n rnn = NStepRNNReLU\\n\\n hy, ys = rnn(n_layers, states, lengths)(hx, w, xs)\\n sections = numpy.cumsum(lengths[:-1])\\n ys = chainer.functions.split_axis(ys, sections, 0)\\n return hy, ys\\n\\n else:\\n\\n def f(x, h, c, w, b):\\n xw, hw = w\\n xb, hb = b\\n rnn_in = linear.linear(x, xw, xb) + linear.linear(h, hw, hb)\\n if activation == 'tanh':\\n return tanh.tanh(rnn_in), None\\n elif activation == 'relu':\\n return relu.relu(rnn_in), None\\n\\n hy, _, ys = n_step_rnn_impl(\\n f, n_layers, dropout_ratio, hx, None, ws, bs, xs, use_bi_direction)\\n return hy, ys\",\n \"def test_mismatched_starts(cell_cls):\\n with tf.Graph().as_default():\\n with tf.Session() as sess:\\n pos_enc = positional_encoding(5, 6, dtype=tf.float64)\\n in_seq = tf.get_variable('in_seq',\\n shape=(3, 5, 6),\\n initializer=tf.truncated_normal_initializer(),\\n dtype=tf.float64)\\n cell = cell_cls(pos_enc, num_layers=3, num_heads=2, hidden=24)\\n _, states_1 = tf.nn.dynamic_rnn(cell, in_seq[:, :1], dtype=tf.float64)\\n _, states_2 = tf.nn.dynamic_rnn(cell, in_seq[:, :2], dtype=tf.float64)\\n _, states_3 = tf.nn.dynamic_rnn(cell, in_seq[:, :3], dtype=tf.float64)\\n new_states = tuple(tf.stack([s2[0], s3[1], s1[2]], axis=0)\\n for s1, s2, s3 in zip(states_1, states_2, states_3))\\n\\n full_seq, _ = tf.nn.dynamic_rnn(cell, in_seq, dtype=tf.float64)\\n expected = tf.stack([full_seq[0, 2:4], full_seq[1, 3:5], full_seq[2, 1:3]], axis=0)\\n\\n inputs = tf.stack([in_seq[0, 2:4], in_seq[1, 3:5], in_seq[2, 1:3]], axis=0)\\n actual, _ = tf.nn.dynamic_rnn(cell, inputs, initial_state=new_states)\\n\\n sess.run(tf.global_variables_initializer())\\n\\n actual, expected = sess.run((actual, expected))\\n\\n assert not np.isnan(actual).any()\\n assert not np.isnan(expected).any()\\n assert actual.shape == expected.shape\\n assert np.allclose(actual, expected)\",\n \"def build_resnet(self):\\r\\n\\r\\n # INPUTS\\r\\n inputs_data = Input((self.data_rows, self.data_cols, 1),name='inputs_data')\\r\\n\\r\\n\\r\\n def residual_block(input, output_channels=64, kernel_size=(3, 3), stride=(1, 1)):\\r\\n x = Conv2D(output_channels, kernel_size, padding='same', strides=stride)(input)\\r\\n x = BatchNormalization()(x)\\r\\n x = Activation('relu')(x)\\r\\n\\r\\n x = Conv2D(output_channels, kernel_size, padding='same', strides=stride)(x)\\r\\n x = BatchNormalization()(x)\\r\\n x = Activation('relu')(x)\\r\\n\\r\\n x = Add()([x, input])\\r\\n\\r\\n residual_block.counter += 1\\r\\n return x\\r\\n\\r\\n residual_block.counter = 0\\r\\n\\r\\n conv1=Conv2D(64,(3,3),strides=(1,1),padding='same',activation='relu')(inputs_data)\\r\\n res_block1=residual_block(conv1,output_channels=64)\\r\\n res_block2 =residual_block(res_block1, output_channels=64)\\r\\n res_block3 =residual_block(res_block2, output_channels=64)\\r\\n conv2=Conv2D(1,(3,3),strides=(1,1),padding='same')(res_block3)\\r\\n outputs=Add()([conv2,inputs_data])\\r\\n\\r\\n\\r\\n model = Model(inputs=inputs_data, outputs=outputs)\\r\\n\\r\\n\\r\\n return model\",\n \"def build_lstm_cell(num_units, dropout):\\n cell = tf.nn.rnn_cell.LSTMCell(num_units)\\n if dropout:\\n result = tf.nn.rnn_cell.DropoutWrapper(cell,\\n output_keep_prob=1-dropout)\\n return result\",\n \"def lstm_cell():\\n if 'reuse' in inspect.getargspec(\\n tf.contrib.rnn.BasicLSTMCell.__init__).args:\\n return tf.contrib.rnn.BasicLSTMCell(\\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True,\\n reuse=tf.get_variable_scope().reuse)\\n else:\\n return tf.contrib.rnn.BasicLSTMCell(\\n args.hidden_size, input_size=args.embedding_size, forget_bias=0.0, state_is_tuple=True)\",\n \"def build_dynamic_rnn(self, cells, lstm_input, lstm_state):\\n lstm_output, final_state = tf.nn.dynamic_rnn(cells, lstm_input, initial_state=lstm_state)\\n # reshape lstm_output from [batch_size, time_steps, n_units] to [batch_size*time_steps, n_units]\\n lstm_output = tf.reshape(lstm_output, [-1, self.num_hidden_units])\\n\\n return lstm_output, final_state\",\n \"def separable_lstm2(cell, num_units, inputs, seq_lengths1, seq_lengths2, scope=None):\\n with variable_scope.variable_scope(scope, \\\"SeparableLstm\\\", [inputs]):\\n batch_size = tf.shape(inputs)[0]\\n _, height, width, depth = _shape(inputs)\\n reshaped = array_ops.reshape(inputs, [batch_size * width, height, depth])\\n _, states = bidirectional_dynamic_rnn(\\n cell(num_units), cell(num_units), reshaped, sequence_length=seq_lengths1, dtype=tf.float32)\\n stacked_state = array_ops.concat(states, 1)\\n with variable_scope.variable_scope(\\\"vertical\\\"):\\n unpacked = array_ops.reshape(stacked_state, [batch_size, width, num_units*2])\\n _, states = bidirectional_dynamic_rnn(\\n cell(num_units), cell(num_units), unpacked, sequence_length=seq_lengths2, dtype=tf.float32)\\n return array_ops.concat(states, 1)\",\n \"def __init__(self,\\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\\n in2hid: tuple, in2out: tuple,\\n hid2hid: tuple, hid2out: tuple,\\n hidden_biases: np.ndarray, output_biases: np.ndarray,\\n rnn_array: np.ndarray, rnn_map: np.ndarray,\\n activation,\\n batch_size: int = 1,\\n initial_read: np.ndarray = None,\\n dtype=np.float64,\\n ):\\n # Storing the input arguments (needed later on)\\n self.act_f = activation\\n self.dtype = dtype\\n self.rnn_idx: np.ndarray = rnn_idx\\n self.n_inputs: int = len(input_idx)\\n self.n_hidden: int = len(hidden_idx)\\n self.n_rnn: int = len(rnn_idx)\\n self.n_outputs: int = len(output_idx)\\n self.bs: int = batch_size\\n \\n # Setup the rnn_map\\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\\n for i, m in enumerate(rnn_map):\\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\\n \\n # Placeholders, initialized during reset\\n self.rnn_state: np.ndarray = None # State of the RNNs\\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\\n self.output_act: np.ndarray = None # Activations of the output nodes\\n \\n # Do not create the hidden-related matrices if hidden-nodes do not exist\\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\\n if self.n_hidden > 0:\\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\\n self.rnn_array: np.ndarray = rnn_array\\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\\n \\n # Fill in the biases\\n if self.n_hidden > 0:\\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\\n \\n # Put network to initial (default) state\\n self.reset(initial_read=initial_read)\",\n \"def build_lstm_cell(size, keep_prob=None):\\n encoder_cell = tf.contrib.rnn.LSTMCell(size)\\n if keep_prob is not None:\\n encoder_cell = tf.contrib.rnn.DropoutWrapper(\\n encoder_cell, output_keep_prob=keep_prob)\\n\\n return encoder_cell\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7117752","0.70600027","0.674815","0.65157115","0.6431374","0.63540703","0.6354059","0.62947875","0.6241957","0.6232274","0.61524653","0.6138036","0.6061001","0.6054821","0.6045019","0.5993263","0.59205985","0.5865216","0.5863549","0.58027077","0.5800259","0.579469","0.579447","0.5780784","0.577455","0.5771293","0.57649297","0.56940633","0.5681182","0.5669214","0.5654458","0.563721","0.56365705","0.560488","0.5581316","0.5573498","0.5572005","0.55648816","0.5539302","0.54679996","0.54510546","0.54215866","0.5412774","0.5407013","0.53985053","0.5372472","0.53694427","0.5354204","0.53390557","0.53380436","0.5318929","0.5317348","0.53167105","0.53057647","0.5286531","0.5262287","0.52535534","0.5240214","0.5239836","0.5235294","0.5224427","0.5221607","0.5201449","0.5193479","0.5190371","0.5188371","0.51839554","0.5177601","0.51730275","0.5158361","0.51574206","0.5156038","0.5146601","0.5141849","0.5133688","0.51312184","0.5131","0.5124992","0.5120136","0.51156485","0.5114003","0.5110395","0.5104772","0.51025456","0.5099874","0.5099233","0.50884587","0.5079479","0.50764394","0.50751674","0.5072742","0.50716406","0.5067813","0.50608516","0.5059561","0.50576866","0.50569314","0.50496364","0.50475836","0.50462425"],"string":"[\n \"0.7117752\",\n \"0.70600027\",\n \"0.674815\",\n \"0.65157115\",\n \"0.6431374\",\n \"0.63540703\",\n \"0.6354059\",\n \"0.62947875\",\n \"0.6241957\",\n \"0.6232274\",\n \"0.61524653\",\n \"0.6138036\",\n \"0.6061001\",\n \"0.6054821\",\n \"0.6045019\",\n \"0.5993263\",\n \"0.59205985\",\n \"0.5865216\",\n \"0.5863549\",\n \"0.58027077\",\n \"0.5800259\",\n \"0.579469\",\n \"0.579447\",\n \"0.5780784\",\n \"0.577455\",\n \"0.5771293\",\n \"0.57649297\",\n \"0.56940633\",\n \"0.5681182\",\n \"0.5669214\",\n \"0.5654458\",\n \"0.563721\",\n \"0.56365705\",\n \"0.560488\",\n \"0.5581316\",\n \"0.5573498\",\n \"0.5572005\",\n \"0.55648816\",\n \"0.5539302\",\n \"0.54679996\",\n \"0.54510546\",\n \"0.54215866\",\n \"0.5412774\",\n \"0.5407013\",\n \"0.53985053\",\n \"0.5372472\",\n \"0.53694427\",\n \"0.5354204\",\n \"0.53390557\",\n \"0.53380436\",\n \"0.5318929\",\n \"0.5317348\",\n \"0.53167105\",\n \"0.53057647\",\n \"0.5286531\",\n \"0.5262287\",\n \"0.52535534\",\n \"0.5240214\",\n \"0.5239836\",\n \"0.5235294\",\n \"0.5224427\",\n \"0.5221607\",\n \"0.5201449\",\n \"0.5193479\",\n \"0.5190371\",\n \"0.5188371\",\n \"0.51839554\",\n \"0.5177601\",\n \"0.51730275\",\n \"0.5158361\",\n \"0.51574206\",\n \"0.5156038\",\n \"0.5146601\",\n \"0.5141849\",\n \"0.5133688\",\n \"0.51312184\",\n \"0.5131\",\n \"0.5124992\",\n \"0.5120136\",\n \"0.51156485\",\n \"0.5114003\",\n \"0.5110395\",\n \"0.5104772\",\n \"0.51025456\",\n \"0.5099874\",\n \"0.5099233\",\n \"0.50884587\",\n \"0.5079479\",\n \"0.50764394\",\n \"0.50751674\",\n \"0.5072742\",\n \"0.50716406\",\n \"0.5067813\",\n \"0.50608516\",\n \"0.5059561\",\n \"0.50576866\",\n \"0.50569314\",\n \"0.50496364\",\n \"0.50475836\",\n \"0.50462425\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76230234"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88993,"cells":{"query":{"kind":"string","value":"resize input in order to produce sampled depth map"},"document":{"kind":"string","value":"def scale_camera(cam, scale=1):\n new_cam = np.copy(cam)\n # focal: \n new_cam[1][0][0] = cam[1][0][0] * scale\n new_cam[1][1][1] = cam[1][1][1] * scale\n # principle point:\n new_cam[1][0][2] = cam[1][0][2] * scale\n new_cam[1][1][2] = cam[1][1][2] * scale\n return new_cam"},"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 resized_map(self, new_size):\n\n new_map = cv2.resize(self.map.copy(), new_size)\n cur_count = np.sum(new_map)\n\n # Avoid dividing by zero\n if cur_count == 0:\n return new_map\n\n scale = self.count / cur_count\n new_map *= scale\n return new_map","def _reconstruct(self, num_samples=None):","def pixel_shuffle(input, upscale_factor, inplace=False):\n return FunctionLib.apply(\n 'DepthToSpace', input.device, [input],\n outputs=[input if inplace else None],\n block_size=int(upscale_factor), mode='CRD', data_format='NCHW')","def pixel_unshuffle(input, downscale_factor, inplace=False):\n return FunctionLib.apply(\n 'SpaceToDepth', input.device, [input],\n outputs=[input if inplace else None],\n block_size=int(downscale_factor), mode='CRD', data_format='NCHW')","def depth_rendering(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\n\n x_indices = np.arange(lf_size[1])\n y_indices = np.arange(lf_size[2])\n b_indices = np.arange(lf_size[0])\n\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\n\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\n stacked = np.stack(grid, 2)\n positions = stacked.reshape(-1, 2)\n\n # Compute the distance from each lf position from the reference view\n # Repeat the elements of this to match the size of the disparity map\n ref_pos = np.array(\n [lf_one_way // 2, lf_one_way // 2])\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\n\n\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\n\n # Compute the shifted pixels\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\n\n #indices for linear interpolation in a square around the central point\n x_low = np.around(x_shifted).astype(int)\n #x_high = x_low + 1\n\n y_low = np.around(y_shifted).astype(int)\n #y_high = y_low + 1\n\n #Place co-ordinates outside the image back into the image\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\n #x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\n #y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\n\n #Gather the interpolation points\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\n #interp_pts_2 = np.stack((x_low_clip, y_high_clip))\n #interp_pts_3 = np.stack((x_high_clip, y_low_clip))\n #interp_pts_4 = np.stack((x_high_clip, y_high_clip))\n\n #Index into the images\n desired_shape = lf_size\n res_1 = torch_big_sample(ref_view, interp_pts_1, desired_shape)\n return res_1\n res_2 = torch_big_sample(ref_view, interp_pts_2, desired_shape)\n res_3 = torch_big_sample(ref_view, interp_pts_3, desired_shape)\n res_4 = torch_big_sample(ref_view, interp_pts_4, desired_shape)\n\n #Compute interpolation weights\n x_low_f = x_low.astype(np.float32)\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\n d_x_high = 1.0 - d_x_low\n y_low_f = y_low.astype(np.float32)\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\n d_y_high = 1.0 - d_y_low\n\n w1 = torch.from_numpy(d_x_low * d_y_low)\n w2 = torch.from_numpy(d_x_low * d_y_high)\n w3 = torch.from_numpy(d_x_high * d_y_low)\n w4 = torch.from_numpy(d_x_high * d_y_high)\n\n #THEY AGREE AT THIS POINT\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape), res_1)\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape), res_2)\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape), res_3)\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape), res_4)\n\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\n torch.add(novel_view, weighted_4, out=novel_view)\n return novel_view","def init_map(self, size, random_data = False):\n heightmap = []\n\n if random_data:\n # random noise background\n for x in range(size):\n heightmap.append([])\n for y in range(size):\n heightmap[-1].append(random.random())\n else:\n # black background\n for x in range(size):\n heightmap.append([])\n for y in range(size):\n heightmap[-1].append(0.0)\n\n return heightmap","def reduceFrame(self, depth, height_ratio = 0.5, sub_sample = 0.3, reduce_to = 'lower'):\n if (height_ratio > 1.0) or (height_ratio < 0.0)\\\n or (sub_sample > 1.0) or (sub_sample < 0.0):\n print('height_ratio and sub_sample must be between 0 and 1')\n exit(1)\n \n depth_copy = depth.copy()\n height = depth_copy.shape[0]\n h = int(height_ratio*(height))\n cols_to_cut = 0\n\n # catches the case when all rows are kept\n if height_ratio == 1:\n d_short = depth_copy\n\n elif reduce_to == 'lower':\n d_short = depth_copy[(height - h):,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'middle_lower':\n upper_brdr = int(3*(height/4.0) - h/2)\n lower_brdr = upper_brdr + h\n d_short = depth_copy[upper_brdr:lower_brdr,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'middle':\n upper_brdr = int((height - h)/2.0)\n lower_brdr = upper_brdr + h\n d_short = depth_copy[upper_brdr:lower_brdr,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'middle_upper':\n upper_brdr = int((height/4.0) - h/2)\n lower_brdr = upper_brdr + h\n d_short = depth_copy[upper_brdr:lower_brdr,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'upper':\n d_short = depth_copy[:h, cols_to_cut:-(cols_to_cut+1)]\n\n d_short[d_short <= 0] = np.nan\n d_short[d_short > self.max_depth] = np.nan\n \n rescaled = rescale(d_short, sub_sample, mode='reflect', multichannel=False, anti_aliasing=True)\n\n return rescaled","def gen_depth_data(scan_folder, dst_folder, normalize=False):\n # specify the goal folder\n dst_folder = os.path.join(dst_folder, 'depth')\n try:\n os.stat(dst_folder)\n print('generating depth data in: ', dst_folder)\n except:\n print('creating new depth folder: ', dst_folder)\n os.mkdir(dst_folder)\n \n # load LiDAR scan files\n scan_paths = load_files(scan_folder)\n\n depths = []\n \n # iterate over all scan files\n for idx in range(len(scan_paths)):\n # load a point cloud\n current_vertex = np.fromfile(scan_paths[idx], dtype=np.float32)\n current_vertex = current_vertex.reshape((-1, 4))\n \n proj_range, _, _, _ = range_projection(current_vertex)\n \n # normalize the image\n if normalize:\n proj_range = proj_range / np.max(proj_range)\n \n # generate the destination path\n dst_path = os.path.join(dst_folder, str(idx).zfill(6))\n \n # save the semantic image as format of .npy\n np.save(dst_path, proj_range)\n depths.append(proj_range)\n print('finished generating depth data at: ', dst_path)\n\n return depths","def __init__(self):\n \tself.transposition = {}\n \tself.currentDepthLimit = 0\n\tself.counter = 0\t\n pass","def keepsize(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\n\n def residual(inputs, n_filters):\n x = ReflectionPadding2D()(inputs)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = Activation(activation)(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, inputs])\n\n return x\n\n inputs = Input(shape=(nx, ny, 1))\n x = GaussianNoise(noise)(inputs)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x0 = Activation(activation)(x)\n\n x = residual(x0, n_filters)\n\n for i in range(depth-1):\n x = residual(x, n_filters)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, x0])\n\n# Upsampling for superresolution\n x = UpSampling2D()(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = Activation(activation)(x)\n\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n\n return Model(inputs=inputs, outputs=final)","def infer_depths(self):\n self.infer_depths_edges_from_cells()\n self.infer_depths_cells_from_edges()\n self.copy_depths_to_subgrid(depth_stat='depth_mean')","def upsample(x, name, size):\n with tf.name_scope(name):\n outputs = tf.image.resize_bilinear(x, size)\n # Return layer's output\n return outputs","def _build(self, inputs):\n\n # calculate how many slots we need from the 3 dimensions of the incoming conv layer (filter w/h plus depth)\n dims = inputs.get_shape().as_list()\n new_dim = 1\n for d in dims[1:]: # leave first axis as is (batch)\n new_dim = new_dim * d # multiply 'em up\n return tf.reshape(inputs, [-1, new_dim]) # -1=keep this dimension as is (it could be anything as this is the number of samples) and flatten the others","def prepare_cnn_entries(X,n_nodes=100):\n idx = X[:,:,0] > 0\n X_nozeros = X[idx]\n min_X = np.min(X_nozeros[:,0])\n max_X = np.max(X_nozeros[:,0])\n del X_nozeros\n gc.collect() \n\n \n \n wavelength_all,step = np.linspace(min_X,max_X, num=n_nodes,retstep=True)\n #wavelength_edges = np.histogram_bin_edges(wavelength_all,bins=n_nodes)\n\n X_new = [[[] for i in range(n_nodes)] for j in range(X.shape[0])]\n\n \n print('Start converting to discrete wavelength inputs...')\n for i in range(X.shape[0]):\n if(i % int(X.shape[0] / 10) == 0):\n print('Part 1.... ' + str(round(100*i/X.shape[0],0)) + ' % completed')\n for j in range(X.shape[1]):\n if(X[i,j,0]>0):\n X_new[i][int((X[i,j,0] - min_X) / step)].append(X[i,j,1])\n #print(X_new[i][int((X[i,j,0] - min_X) / step)])\n \n #del X\n gc.collect()\n \n X_new = np.array(X_new)\n print(np.count_nonzero(X_new))\n \n for i in range(X_new.shape[0]):\n if(i % int(X_new.shape[0] / 10) == 0):\n print('Part 2.... ' + str(round(100*i/X_new.shape[0])) + ' % completed')\n for j in range(X_new.shape[1]):\n X_new[i,j] = np.array(X_new[i,j])\n if(X_new[i,j].size > 0):\n X_new[i,j] = np.mean(np.array(X_new[i,j]))\n else:\n X_new[i,j] = 0.\n \n print(np.count_nonzero(X_new))\n \n return X_new","def densMap(fit, metricArray, n, overlap, imageSize, imageName):\n \n if True: #Make true if you want to calculate densities (i.e. if you have a new fit/new density list) \n print 'calculating densities'\n if type(fit)==sklearn.gaussian_process.gaussian_process.GaussianProcess: #If the fit is Gaussian\n densities, MSE = fit.predict(metricArray, eval_MSE =True)\n sigma = numpy.sqrt(MSE)\n print(sigma)\n else:\n densities = fit.predict(metricArray) #Use the ML fit to predict the density for each tile \n #print len(densities)\n f = open('densities.txt', 'w')\n print >> f, list(densities)\n f.close()\n else: \n f = open('densities.txt', 'r')\n data = f.read()\n densities = eval(data)\n # print densities\n densities = numpy.array(densities)\n f.close()\n imageName = 'FirstStitchLong.jpg'\n overlap = 0.2 \n n = 50\n image = Image.open(imageName) #open the image\n imageSize = image.size #get the image size \n # print 'Image Size is ', imageSize\n \n\n width = imageSize[0] \n height = imageSize[1] \n # print 'width ', width \n #print 'height ', height\n overlapSize = int(overlap*n)\n rowTiles = int((width-n)/(overlapSize))+1\n print 'Row Tiles is ', rowTiles\n #colTiles = int(((height-n)/(overlapSize))+1)\n \n \n # newArray = numpy.zeros((int((width-n)/(overlapSize)+1),int(((height-n)/(overlapSize))+1)))\n \n #newArray = numpy.zeros(width, height)\n #print newArray\n points = []\n for i in range(len(densities)):\n x = (i%rowTiles)*overlapSize + n/2\n y = (i/rowTiles)*overlapSize + n/2\n points += [[x,y]]\n # newArray[i%(rowTiles),i/(rowTiles)] = densities[i]\n # newArray[(i%(rowTiles)+1)*(n/2) , (i/(rowTiles)+1)*(n/2)] = densities[i]\n # points += [[(i%(rowTiles)+1)*(n/2), (i/(rowTiles)+1)*(n/2)]] #Consider the density to be at the center of each tile \n # print points\n grid_x, grid_y = numpy.mgrid[0:width, 0:height] #create a meshgrid \n \n # print densities\n # print('Points is ', points) \n # print('Densities is ', densities)\n data = griddata(points, densities, (grid_x, grid_y), method = 'linear') #interpolate to get continuous function of points \n #can change interpolation method\n print data.size\n\n # print 'Max is ', numpy.amax(data)\n # min_max_scaler = sklearn.preprocessing.MinMaxScaler()\n #data_minmax = min_max_scaler.fit_transform(data) \n \n \n \n ##Plotting \n plt.figure(1)\n \n #plt.figure(figsize = (width, height))\n # print \"Hi Cassie\"\n v = numpy.linspace(min(densities), max(densities), 20, endpoint=True)\n fig = plt.contourf(grid_x, grid_y, data, levels = v, alpha = 0.4, antialiased = True)\n \n mapIm = Image.open(imageName)\n plt.imshow(mapIm)\n maxDens = max(densities)\n print maxDens \n x = plt.colorbar(fig) \n plt.savefig('ContourPlot.jpg')\n return data","def glimpseSensor(img, normLoc, minRadius=4, depth=1, sensorBandwidth=12):\n input_shape = img.get_shape().as_list()\n img_size = input_shape[1]\n loc = tf.round(((normLoc + 1) / 2.0) * img_size)\n loc = tf.cast(loc, tf.int32)\n zooms = []\n for k in range(batch_size):\n imgZooms = []\n one_img = img[k, :, :, :]\n max_radius = minRadius * (2**(depth - 1))\n offset = 2 * max_radius\n one_img = tf.image.pad_to_bounding_box(one_img, offset, offset, max_radius * 4 + img_size,\n max_radius * 4 + img_size)\n\n for i in range(depth):\n r = int(minRadius * (2**(i)))\n d_raw = 2 * r\n d = tf.constant(d_raw, shape=[1])\n d = tf.tile(d, [2])\n loc_k = loc[k, :]\n adjusted_loc = offset + loc_k - r\n one_img2 = tf.reshape(\n one_img, (one_img.get_shape()[0].value, one_img.get_shape()[1].value, input_shape[3]))\n zoom = tf.slice(one_img2, adjusted_loc, d)\n zoom = tf.image.resize_bilinear(\n tf.reshape(zoom, (1, d_raw, d_raw, nput_shape[3])), (sensorBandwidth, sensorBandwidth))\n zoom = tf.reshape(zoom, (sensorBandwidth, sensorBandwidth, input_shape[3]))\n imgZooms.append(zoom)\n\n zooms.append(tf.stack(imgZooms))\n\n return tf.stack(zooms)","def keepsize_256(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\n\n def residual(inputs, n_filters):\n x = ReflectionPadding2D()(inputs)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = Activation(activation)(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, inputs])\n\n return x\n\n inputs = Input(shape=(nx, ny, 1))\n x = GaussianNoise(noise)(inputs)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x0 = Activation(activation)(x)\n\n x = residual(x0, n_filters)\n\n for i in range(depth-1):\n x = residual(x, n_filters)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, x0])\n\n# Upsampling for superresolution\n x = UpSampling2D()(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(4*n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = Activation(activation)(x)\n\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n\n return Model(inputs=inputs, outputs=final)","def update_dimensions(self):\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\n dtype=\"int16\")","def __init__(self, width, height, circular=True):\n self.width = width\n self.height = height\n self.size = width * height\n self.idx_list = []\n self._depth_buffer = [[] for _ in range(self.size)]\n self._depth = [0] * self.size\n self.circular = circular","def __init__(self):\n self.size = 1000\n self.mapArray = [None] * self.size","def rebuild(self):\n self.from_samples(self.samples)","def resize_lightfield(raw_lightfield, desired_size): # -> lightfield\n if raw_lightfield.ndim == 6:\n n_depth, n_cols, n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_depth, n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n\n for k, depth in enumerate(raw_lightfield):\n for i, row in enumerate(depth):\n for j, image_data in enumerate(row):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[k, i, j] = resized_image_data\n elif raw_lightfield.ndim == 5:\n n_cols, n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n\n for i, row in enumerate(raw_lightfield):\n for j, image_data in enumerate(row):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[i, j] = resized_image_data\n \n elif raw_lightfield.ndim == 4:\n n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n for j, image_data in enumerate(raw_lightfield):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[j] = resized_image_data\n \n return output_lightfield","def _build_depth_graph(self):\n self.depth_net = DepthNetwork(self.cfg.STRUCTURE, is_training=False)\n images = self.images_placeholder[tf.newaxis]\n poses = self.poses_placeholder[tf.newaxis]\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\n\n # fix the input shape\n images = tf.reshape(images, [1, 5, 192, 1088, 3])\n Ts = VideoSE3Transformation(matrix=poses)\n\n depths = self.depth_net.forward(Ts, images, intrinsics)\n self.outputs['depths'] = depths","def on_depth_image(self, depth_image):\n depth_image = depth_image.copy()\n mask = np.where(self.depth != 0)\n depth_image[mask] = self.depth[mask]\n return depth_image","def _resize(self, cap):\n old = self._data\n self._data = [None] * cap\n walk = self._front\n for i in range(self._size):\n self._data[i] = old[walk]\n walk = (walk + 1) % len(old)\n self._front = 0","def __init__(self, d=1):\r\n self.depth = d","def depr_depth_images(self):\n if not hasattr(self, '_depr_depth_images'):\n depth_images = self._archive['gaps_depth']\n self._depr_depth_images = depth_images.reshape([1, 20, 224, 224, 1])\n return self._depr_depth_images","def upsampleImage( arr, kernelSize ):\n return scipy.ndimage.zoom( arr, kernelSize )","def __resize_to_512(input_data):\n test_size = 720\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\n axis=-1))\n for contour in contours] for contours in input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\n axis=-1)) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * 512 / input_data['img'].shape[0]),\n np.cast['int32'](point[1] * 512 / input_data['img'].shape[1]))\n for point in input_data['center_point']]\n\n seq = iaa.Sequential([\n iaa.Scale({'height': 512, 'width': 512}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n return input_data","def _preallocate_samples(self):\n self.prealloc_samples_ = []\n for _ in range(self.num_prealloc_samples_):\n self.prealloc_samples_.append(self.sample())","def __resize_512p(input_data):\n rate = 1\n test_size=512\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\n if True: # input_data['img'].shape[1] < 512:\n rate = test_size / input_data['img'].shape[1]\n seq = iaa.Sequential([\n iaa.Scale({'height': \"keep-aspect-ratio\", 'width': test_size}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n else:\n if True: # input_data['img'].shape[0] < 512:\n rate = test_size / input_data['img'].shape[0]\n seq = iaa.Sequential([\n iaa.Scale({'height': test_size, 'width': \"keep-aspect-ratio\"}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\n input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\n return input_data","def downsample_sam(self, factor):","def main():\n\n ##############################\n # Options\n ##############################\n # Validation set\n input_depth_dir = os.path.expanduser(\n '~/Kitti/depth/train')\n data_split = 'val'\n\n # Test set\n # input_depth_dir = os.path.expanduser(\n # '~/Kitti/depth/depth_selection/test_depth_completion_anonymous/velodyne_raw')\n # data_split = 'test'\n\n # Fast fill with Gaussian blur @90Hz (paper result)\n fill_type = 'fast'\n extrapolate = True\n blur_type = 'gaussian'\n\n # Fast Fill with bilateral blur, no extrapolation @87Hz (recommended)\n # fill_type = 'fast'\n # extrapolate = False\n # blur_type = 'bilateral'\n\n # Multi-scale dilations with extra noise removal, no extrapolation @ 30Hz\n # fill_type = 'multiscale'\n # extrapolate = False\n # blur_type = 'bilateral'\n\n # Save output to disk or show process\n save_output = True\n\n ##############################\n # Processing\n ##############################\n if save_output:\n # Save to Disk\n show_process = False\n save_depth_maps = True\n else:\n if fill_type == 'fast':\n raise ValueError('\"fast\" fill does not support show_process')\n\n # Show Process\n show_process = True\n save_depth_maps = False\n\n # Create output folder\n this_file_path = os.path.dirname(os.path.realpath(__file__))\n outputs_dir = this_file_path + '/outputs'\n os.makedirs(outputs_dir, exist_ok=True)\n\n output_folder_prefix = 'depth_' + data_split\n output_list = sorted(os.listdir(outputs_dir))\n if len(output_list) > 0:\n split_folders = [folder for folder in output_list\n if folder.startswith(output_folder_prefix)]\n if len(split_folders) > 0:\n last_output_folder = split_folders[-1]\n last_output_index = int(last_output_folder.split('_')[-1])\n else:\n last_output_index = -1\n else:\n last_output_index = -1\n output_depth_dir = outputs_dir + '/{}_{:03d}'.format(\n output_folder_prefix, last_output_index + 1)\n\n if save_output:\n if not os.path.exists(output_depth_dir):\n os.makedirs(output_depth_dir)\n else:\n raise FileExistsError('Already exists!')\n print('Output dir:', output_depth_dir)\n\n # Get images in sorted order\n # images_to_use = sorted(glob.glob(input_depth_dir + '/*'))\n\n # Rolling average array of times for time estimation\n avg_time_arr_length = 10\n last_fill_times = np.repeat([1.0], avg_time_arr_length)\n last_total_times = np.repeat([1.0], avg_time_arr_length)\n\n images_to_use = []\n saved_path = []\n folder_path =\"./data_depth_selection/depth_selection/test_depth_completion_anonymous/velodyne_raw\"\n for img_name in os.listdir(folder_path):\n img_path = os.path.join(folder_path,img_name)\n saved_path_name = os.path.join(\"./output\", img_name)\n saved_path.append(saved_path_name)\n images_to_use.append(img_path)\n # if \"output\" not in os.listdir(\"Kitti/depth/\"):\n # os.mkdir(\"Kitti/depth/output\")\n # os.mkdir(\"output\")\n # for folder in os.listdir(folder_path):\n # # os.mkdir(\"./output/\"+folder)\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\")\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\")\n\n # inside_folder_path = folder_path + \"/\" + folder+\"/2011_09_26/\"+folder+\"/\"\n # for img_folder in os.listdir(inside_folder_path):\n # print((\"/output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder))\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder)\n # print(inside_folder_path + img_folder)\n # # os.mkdir(\"Kitti/depth/output/\"+folder+\"/proj_depth/groundtruth/\"+img_folder)\n # img_path = inside_folder_path + img_folder+\"/data\"\n # try:\n # print(\"............................................................\",\"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder)\n # depth_image_folder = os.listdir(\"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder)\n # # print(depth_image_folder)\n # for img in os.listdir(img_path):\n # # image_path = +\"/\"+img\n # # print(img)\n # if img in depth_image_folder:\n # # print(\"aaya\")\n # depth_image_path = \"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder+\"/\"+img\n # images_to_use.append(depth_image_path)\n # saved_path.append(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder+\"/\"+img)\n # except Exception:\n # print(\"folder nahi hai\")\n \n images_to_use = np.array(images_to_use)\n \n num_images = len(images_to_use)\n\n print(len(images_to_use))\n\n\n for i in range(num_images):\n\n depth_image_path = images_to_use[i]\n\n # Calculate average time with last n fill times\n avg_fill_time = np.mean(last_fill_times)\n avg_total_time = np.mean(last_total_times)\n\n # Show progress\n sys.stdout.write('\\rProcessing {} / {}, '\n 'Avg Fill Time: {:.5f}s, '\n 'Avg Total Time: {:.5f}s, '\n 'Est Time Remaining: {:.3f}s'.format(\n i, num_images - 1, avg_fill_time, avg_total_time,\n avg_total_time * (num_images - i)))\n sys.stdout.flush()\n\n # Start timing\n start_total_time = time.time()\n print(depth_image_path)\n # Load depth projections from uint16 image\n depth_image = cv2.imread(depth_image_path, cv2.IMREAD_ANYDEPTH)\n projected_depths = np.float32(depth_image / 256.0)\n\n # Fill in\n start_fill_time = time.time()\n if fill_type == 'fast':\n final_depths = depth_map_utils.fill_in_fast(\n projected_depths, extrapolate=extrapolate, blur_type=blur_type)\n elif fill_type == 'multiscale':\n final_depths, process_dict = depth_map_utils.fill_in_multiscale(\n projected_depths, extrapolate=extrapolate, blur_type=blur_type,\n show_process=show_process)\n else:\n raise ValueError('Invalid fill_type {}'.format(fill_type))\n end_fill_time = time.time()\n\n # Display images from process_dict\n if fill_type == 'multiscale' and show_process:\n img_size = (570, 165)\n\n x_start = 80\n y_start = 50\n x_offset = img_size[0]\n y_offset = img_size[1]\n x_padding = 0\n y_padding = 28\n\n img_x = x_start\n img_y = y_start\n max_x = 1900\n\n row_idx = 0\n for key, value in process_dict.items():\n\n image_jet = cv2.applyColorMap(\n np.uint8(value / np.amax(value) * 255),\n cv2.COLORMAP_JET)\n vis_utils.cv2_show_image(\n key, image_jet,\n img_size, (img_x, img_y))\n\n img_x += x_offset + x_padding\n if (img_x + x_offset + x_padding) > max_x:\n img_x = x_start\n row_idx += 1\n img_y = y_start + row_idx * (y_offset + y_padding)\n\n # Save process images\n cv2.imwrite('process/' + key + '.png', image_jet)\n\n cv2.waitKey()\n\n # Save depth images to disk\n if save_depth_maps:\n depth_image_file_name = depth_image_path.split(\"/\")\n # print(depth_image_file_name)\n file_path = \"\"\n print(len(depth_image_file_name))\n # for i in range(8):\n # if(i == 2):\n # file_path = os.path.join(file_path, \"output\")\n # else:\n # file_path = os.path.join(file_path, depth_image_file_name[i])\n # cv2.imwrite(file_path, depth_image)\n # print(\"check.............................\",saved_path[i])\n # with open(saved_path[i],'r') as f:\n # print(\"badhiya\") \n depth_image = (final_depths * 256)\n # plt.imsave(saved_path[i],depth_image)\n # cv2.imwrite(saved_path[i], depth_image)\n # print(saved_path[i])\n # cv2.imwrite(\"/media/pankaj/Elements/ip_basic\"+saved_path[i], depth_image)\n \n try:\n with open(saved_path[i], 'wb') as f:\n depth_image = (final_depths * 256).astype(np.uint16)\n\n writer = png.Writer(width=depth_image.shape[1],\n height=depth_image.shape[0],\n bitdepth=16,\n greyscale=True)\n writer.write(f, depth_image)\n except Exception:\n print(\"nikl.............\")\n\n end_total_time = time.time()\n\n # Update fill times\n last_fill_times = np.roll(last_fill_times, -1)\n last_fill_times[-1] = end_fill_time - start_fill_time\n\n # Update total times\n last_total_times = np.roll(last_total_times, -1)\n last_total_times[-1] = end_total_time - start_total_time","def Resize(self):\n\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\n self.FreshStart()","def reset_map(self):\n self.x = None\n self.X = None\n self.y = None\n self.Y = None\n self.data = None\n self.sampling = None\n self.size = None","def depth_rendering_gpu(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\n\n x_indices = np.arange(lf_size[1])\n y_indices = np.arange(lf_size[2])\n b_indices = np.arange(lf_size[0])\n\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\n\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\n stacked = np.stack(grid, 2)\n positions = stacked.reshape(-1, 2)\n\n # Compute the distance from each lf position from the reference view\n # Repeat the elements of this to match the size of the disparity map\n ref_pos = np.array(\n [lf_one_way // 2, lf_one_way // 2])\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\n\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\n\n # Compute the shifted pixels\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\n\n #indices for linear interpolation in a square around the central point\n x_low = np.floor(x_shifted).astype(int)\n x_high = x_low + 1\n\n y_low = np.floor(y_shifted).astype(int)\n y_high = y_low + 1\n\n #Place co-ordinates outside the image back into the image\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\n x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\n y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\n\n #Gather the interpolation points\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\n interp_pts_2 = np.stack((x_low_clip, y_high_clip))\n interp_pts_3 = np.stack((x_high_clip, y_low_clip))\n interp_pts_4 = np.stack((x_high_clip, y_high_clip))\n\n #Index into the images\n desired_shape = lf_size\n ref_view = torch.tensor(ref_view, dtype=torch.float32).cuda()\n res_1 = torch_tensor_sample(ref_view, interp_pts_1, desired_shape)\n res_2 = torch_tensor_sample(ref_view, interp_pts_2, desired_shape)\n res_3 = torch_tensor_sample(ref_view, interp_pts_3, desired_shape)\n res_4 = torch_tensor_sample(ref_view, interp_pts_4, desired_shape)\n\n #Compute interpolation weights\n x_low_f = x_low.astype(np.float32)\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\n d_x_high = 1.0 - d_x_low\n y_low_f = y_low.astype(np.float32)\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\n d_y_high = 1.0 - d_y_low\n\n w1 = torch.from_numpy(d_x_low * d_y_low)\n w2 = torch.from_numpy(d_x_low * d_y_high)\n w3 = torch.from_numpy(d_x_high * d_y_low)\n w4 = torch.from_numpy(d_x_high * d_y_high)\n\n #THEY AGREE AT THIS POINT\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape).cuda(), res_1)\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape).cuda(), res_2)\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape).cuda(), res_3)\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape).cuda(), res_4)\n\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\n torch.add(novel_view, weighted_4, out=novel_view)\n return novel_view","def generate_all_sizes():\n dimension = 4\n h = 1\n while h <= dimension:\n w = 1\n while w <= dimension:\n for y in range(0, dimension, h):\n for x in range(0, dimension, w):\n yield FeatureSize(x / dimension,\n y / dimension,\n w / dimension,\n h / dimension)\n w = w * 2\n h = h * 2","def downsample(state):\n return state[::2, ::2, :]","def dryrun_find_featuremap_dims(\n feature_extractor: FeatureExtractor | GraphModule,\n input_size: tuple[int, int],\n layers: list[str],\n) -> dict[str, dict[str, int | tuple[int, int]]]:\n\n dryrun_input = torch.empty(1, 3, *input_size)\n dryrun_features = feature_extractor(dryrun_input)\n return {\n layer: {\"num_features\": dryrun_features[layer].shape[1], \"resolution\": dryrun_features[layer].shape[2:]}\n for layer in layers\n }","def make_map(self, sampling=None, size=None):\n if sampling is None and self.sampling is None:\n self.sampling = self.minimum_sampling()\n elif sampling is not None:\n self.sampling = sampling\n \n if size is None and self.size is None:\n self.size = self.minimum_size()\n elif size is not None:\n self.size = size\n\n # Set the number of pixels that spans the full size requested\n pixsize = numpy.ceil(self.size/self.sampling).astype(int)\n # Force the pixel size to be odd\n if pixsize % 2 == 0:\n pixsize += 1\n # Adjust the size to be an integer number of pixels\n _size = pixsize*self.sampling\n if _size - self.size > 0.1*self.sampling:\n warnings.warn('Size reset to an integer number of pixels: '\n ' {0} -> {1} arcsec'.format(self.size, _size))\n self.size = _size\n self.y = (pixsize-1)*numpy.linspace(-0.5,0.5,pixsize)*self.sampling\n self.x = self.y.copy()[::-1]\n\n # Sample it\n self.X, self.Y = numpy.meshgrid(self.x, self.y)\n self.data = self.__call__(self.X, self.Y)","def undistort_rectify_map(self):\n return cv.initUndistortRectifyMap(self._k, self._dist, np.eye(3), self._k, self.frame_size[::-1], cv.CV_16SC2)","def _modify_map_size(self, merged_map):\n pos_x_white, pos_y_white = np.where(merged_map == 255)\n pos_x_black, pos_y_black = np.where(merged_map == 0)\n\n pos_x_M = np.amax(np.hstack((pos_x_black, pos_x_white)))\n pos_x_m = np.amin(np.hstack((pos_x_black, pos_x_white)))\n pos_y_M = np.amax(np.hstack((pos_y_black, pos_y_white)))\n pos_y_m = np.amin(np.hstack((pos_y_black, pos_y_white)))\n\n reduced_map = merged_map[pos_x_m-5:pos_x_M+5, pos_y_m-5:pos_y_M+5]\n\n return reduced_map","def upsample_filt(size):\r\n factor = (size + 1) // 2\r\n if size % 2 == 1:\r\n center = factor - 1\r\n else:\r\n center = factor - 0.5\r\n og = np.ogrid[:size, :size]\r\n return (1 - abs(og[0] - center) / factor) * \\\r\n (1 - abs(og[1] - center) / factor)","def __init__(self):\n self._root = None\n self._size = 0\n self._curr_idx = 0\n self._depths, self._heights = None, None","def resize_volume(img):\n desired_depth = 64\n desired_width = 128\n desired_height = 128\n\n current_depth = img.shape[-1]\n current_width = img.shape[0]\n current_height = img.shape[1]\n\n depth = current_depth / desired_depth\n width = current_width / desired_width\n height = current_height / desired_height\n\n depth_factor = 1 / depth\n width_factor = 1 / width\n height_factor = 1 / height\n\n img = ndimage.rotate(input=img, angle=90, reshape=False)\n img = ndimage.zoom(input=img, zoom=(width_factor, height_factor, depth_factor), order=1)\n\n return img","def __init__(self, input_size=88):\n self._input_size = input_size","def _assign_sizes(self):","def __init__(self, output_size, spatial_scale=1.0):\n super().__init__()\n self.output_size = output_size\n self.spatial_scale = spatial_scale","def __init__(self, output_size, spatial_scale=1.0):\n super().__init__()\n self.output_size = output_size\n self.spatial_scale = spatial_scale","def upsample(inputs, out_shape, data_format):\n if data_format == 'channels_first':\n inputs = tf.transpose(inputs, [0, 2, 3, 1])\n new_height = out_shape[3]\n new_width = out_shape[2]\n else:\n new_height = out_shape[2]\n new_width = out_shape[1]\n\n inputs = tf.image.resize_nearest_neighbor(inputs, (new_height, new_width))\n if data_format == 'channels_first':\n inputs = tf.transpose(inputs, [0, 3, 1, 2])\n return inputs","def upsample_2d(x, size=(2, 2)):\n h, w, _ = x.get_shape().as_list()[1:]\n size_x, size_y = size\n output_h = h * size_x\n output_w = w * size_y\n return tf.image.resize_bilinear(x, (output_h, output_w), align_corners=None, name='upsampling')","def __init__(self, size=(2, 2), **kwargs):\n super(MaxUnpooling2D, self).__init__(**kwargs)\n self.size = size","def __init__(self,\n depth_multiplier,\n min_depth,\n conv_hyperparams,\n reuse_weights=None):\n super(SSDVgg16FeatureExtractor, self).__init__(\n depth_multiplier, min_depth, conv_hyperparams, reuse_weights)","def loadDepthFrame(self):\n self.DepthFrameRaw = cv2.imread(\n script_path + \"/data/raw_depth.png\", 0).astype(np.uint16)","def reindex(self):\n super().reindex()\n self._depths, self._heights = None, None\n for p in self.positions():\n self._compute_depth(p)\n self._compute_height(p)","def _visualize_input(self, input):\n self.writer.add_image('input', make_grid(input[0, 0, :, :], nrow=8, normalize=True))","def __init__(self, size):\n self.world = [[None for y in range(size)] for x in range(size)]","def DEPTH(frame):\n\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\n\tframe.image.copy_bits( depth.ctypes.data )\n\tcv2.imshow( 'VideoDEPTH', depth )","def make_hp_map(data, hp_indices, Nside = 2048, nest = True):\n \n print(\"len hp_indices: {}\".format(len(hp_indices)))\n hp_indices = np.array(hp_indices)\n print(\"shape of hp_indices: {}\".format(hp_indices.shape))\n hp_indices = np.squeeze(hp_indices)\n \n Npix = 12*Nside**2\n map_data = np.zeros(Npix, np.float_)\n map_data[hp_indices] = data\n \n return map_data","def f() -> None:\n x = torch.rand(7, 3).to(self.device)\n kernel = ScaleKernel(MaternKernel())\n allocator = GreedyVarianceReduction()\n allocator.allocate_inducing_points(x, kernel, 4, x.shape[:-2])","def _increase_size(self) -> None:\n keys_vals_to_move = [item for item in self.HashMap if item]\n self.length = 0\n self.capacity = self.capacity * 2\n self.HashMap = [None] * self.capacity\n for item in keys_vals_to_move:\n while len(item) > 0:\n self.add(item[0], item[1])\n item.pop(0)\n item.pop(0)","def dimensions():","def _build_reprojection_graph(self):\n EPS = 1e-8\n depths = self.depths_placeholder[tf.newaxis]\n poses = self.poses_placeholder[tf.newaxis]\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\n\n batch, num, ht, wd = tf.unstack(tf.shape(depths), num=4)\n Ts = VideoSE3Transformation(matrix=poses)\n intrinsics = intrinsics_vec_to_matrix(intrinsics)\n\n ii, jj = tf.meshgrid(tf.range(0, num), tf.range(num, num+1))\n ii = tf.reshape(ii, [-1])\n jj = tf.reshape(jj, [-1])\n\n Tij = Ts.gather(jj) * Ts.gather(ii).inv()\n X0 = projective_ops.backproject(depths, intrinsics)\n X1 = Tij(X0)\n\n coords = projective_ops.project(X1, intrinsics)\n depths = X1[..., 2]\n\n indicies = tf.cast(coords[..., ::-1] + .5, tf.int32)\n indicies = tf.reshape(indicies, [-1, 2])\n depths = tf.reshape(depths, [-1])\n\n depth = tf.scatter_nd(indicies, depths, [ht, wd])\n count = tf.scatter_nd(indicies, tf.ones_like(depths), [ht, wd])\n\n depth = depth / (count + EPS)\n self.outputs['depth_reprojection'] = depth","def draw(self):\n\n super().draw()\n \n self.dim = self.getdim()\n start_x, start_y, = self.x(), self.y()\n\n for y in range(self.r):\n for x in range(self.c):\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\n self.tiles[y][x].resize(x_pos, y_pos, self.dim, self.dim)","def edit(self):\n wmap = 512\n if not self.mapd:\n data = self.data[24:]\n mapd = self.mapd = []\n for index in xrange(0,3*wmap*wmap,3):\n mapd.append(data[index:index+3])\n self.setChanged()","def resize_volumes(x, depth_factor, height_factor, width_factor, data_format='channels_last'):\n if data_format == 'channels_first':\n output = repeat_elements(x, depth_factor, axis=2)\n output = repeat_elements(output, height_factor, axis=3)\n output = repeat_elements(output, width_factor, axis=4)\n return output\n elif data_format == 'channels_last':\n output = repeat_elements(x, depth_factor, axis=1)\n output = repeat_elements(output, height_factor, axis=2)\n output = repeat_elements(output, width_factor, axis=3)\n return output\n else:\n raise ValueError('Invalid data_format:', data_format)","def initiate_memory(self):\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]","def show_rgbd(self):\n while self.depth_data is None:\n pass\n\n while not rospy.is_shutdown():\n rospy.Rate(10).sleep()\n d = self.depth_data * self.cam.DEPTH_UNIT\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\n dc = np.concatenate((d, self.rgb_data), axis=1)\n cv2.imshow('RGB & Depth Image', dc)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n cv2.destroyAllWindows()","def __init__(self, width, height):\n self.clean_tiles = []\n self.width = width\n self.height = height","def __init__(self, width, height):\n self.w = width\n self.h = height\n self.cleanTiles = []\n self.tiles = [[False] * width for i in range(height)]\n self.cleaned = 0","def run(self, depth):\n\t\tdepth = depth.invert()\n\t\t\"\"\"use this to convert it into cm, or into m by changing 10 to 100\"\"\"\n\t\tdepth = divide(depth, 10)\n\t\t\"\"\"Makes blobs easier to detect\"\"\"\n\t\tdepth = depth.erode()\n\t\tblob_array = self.blob_detect(depth)\n\t\tif blob_array:\n\t\t\ttheadau_array = self.get_theadaus(blob_array)\n\t\t\tprint theadau_array\n\t\t\t\"\"\"\n\t\t\tUntill i fill in outside coord array, i will get rid of this code\n\t\t\toutside_coord_array = self.get_outside_points(blob_array)\n\t\t\tblob_width_array = self.get_width(outside_coord_array, theadau_array)\n\t\t\treturn blob_width_array\t\n\t\t\t\"\"\"\t\n\t\treturn blob_array","def resize(self):\n pass","def depth_callback(self, data):\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\"passthrough\")\n self.depth_mutex.acquire()\n self.depth_image = cv_image\n self.depth_mutex.release()","def polylinedictarraycopy(d):#d——原始图层多段线字典 \r\n dictlist=[]\r\n ratiolist=[] #放缩率列表\r\n rationumaccumulationlist=[] #放缩率数量累加列表\r\n \r\n eachrationum=globalconfig.X_ARRAY_NUM//globalconfig.RATIO_NUM\r\n leftrationum=globalconfig.X_ARRAY_NUM%globalconfig.RATIO_NUM\r\n \r\n eachrationumlist=[eachrationum]*globalconfig.RATIO_NUM #各个放缩率对应数量的列表\r\n \r\n for i in range((globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2,(globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2+leftrationum):\r\n eachrationumlist[i]=eachrationumlist[i]+1 #将整除后的余值加入到靠中间放缩率的方案中。\r\n \r\n rationumaccumulationlist.append(0) \r\n \r\n for i in range(1,globalconfig.RATIO_NUM): #计算放缩率数量累加列表\r\n rationumaccumulationlist.append(rationumaccumulationlist[i-1]+eachrationumlist[i-1])\r\n \r\n for i in range(0,globalconfig.RATIO_NUM): #计算放缩率列表\r\n ratiolist.append((globalconfig.CENTER_RATIO-((globalconfig.RATIO_NUM+1)//2-1)*globalconfig.RATIO_DIFF)+i*globalconfig.RATIO_DIFF) \r\n \r\n for i in range(0,globalconfig.RATIO_NUM): #每种放缩率\r\n for j in range(0,eachrationumlist[i]): #每种放缩率对应数量\r\n newdict={}\r\n for e in d: #将字典中值即每一图层对应的多段线列表进行复制并移动到指定位置\r\n newdict[e]=polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist)) \r\n #newdict.append([e,polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist))])\r\n dictlist.append(newdict) \r\n return (dictlist,ratiolist,eachrationumlist)","def __resize_to_32x(input_data):\n rate = 1\n while min(input_data['img'].shape[:2])>736:\n test_size = 736\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\n if True: # input_data['img'].shape[1] < 512:\n rate = test_size / input_data['img'].shape[1]\n seq = iaa.Sequential([\n iaa.Scale({'height': \"keep-aspect-ratio\", 'width': test_size}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n else:\n if True: # input_data['img'].shape[0] < 512:\n rate = test_size / input_data['img'].shape[0]\n seq = iaa.Sequential([\n iaa.Scale({'height': test_size, 'width': \"keep-aspect-ratio\"}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\n input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\n p_row = 0\n while True:\n if (input_data['img'].shape[0] + p_row) % 32 == 0:\n break\n p_row += 1\n p_col = 0\n while True:\n if (input_data['img'].shape[1] + p_col) % 32 == 0:\n break\n p_col += 1\n\n input_data['img'] = np.pad(input_data['img'], ((0, p_row), (0, p_col), (0, 0)), mode='constant')\n\n return input_data","def resize_function(input):\n\n from keras.backend import tf as ktf\n return ktf.image.resize_images(input, (64, 64))","def registerDepthFrame(self, frame):\n h, w = frame.shape[:2]\n frame = cv2.warpAffine(frame,self.depth2rgb_affine,(w,h))\n\n return frame","def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\n\n def get_states(start):\n frontier = [start]\n frontier_set = {start}\n explored = set()\n\n states = [False for _ in range(len(depths))]\n while not all(states):\n node = frontier.pop(0)\n frontier_set.remove(node)\n explored.add(node)\n\n children = node.get_children()\n\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\n # produced from the parent by the same action) produced at a certain depth will always be selected,\n # and children produced by other actions will never be selected\n shuffle(children)\n\n for child in children:\n if child not in frontier_set and child not in explored:\n frontier_set.add(child)\n frontier.append(child)\n child.path_cost = node.path_cost+1\n index = depths.index(child.path_cost) if child.path_cost in depths else None\n if index is not None and not states[index]:\n states[index] = {'start': start.sequence, 'end': child.sequence}\n\n return states\n\n depth_sample = [[] for depth in range(len(depths))]\n\n for _ in range(num_samples):\n start = list(range(1,n+2))\n shuffle(start)\n start = PuzzleState(start, path_cost=0)\n\n states = get_states(start)\n print('\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\n list(map(list.append, depth_sample, states))\n\n return depth_sample","def upscale(x, n):\n if n == 1:\n return x\n x_shape = tf.shape(x)\n height, width = x_shape[1], x_shape[2]\n return tf.image.resize_nearest_neighbor(x, [n * height, n * width])\n # return tf.batch_to_space(tf.tile(x, [n**2, 1, 1, 1]), [[0, 0], [0, 0]], n)","def sample(self, size=1):\n pass","def __init__(self,\n name,\n input_size,\n state_size):\n self._input_size = input_size\n self._state_size = state_size\n super(GRU, self).__init__(name)","def resize(final_grid, alpha, beta):\n # init the filter before resize\n adjusted = cv2.convertScaleAbs(final_grid, alpha, beta)\n sharpen_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])\n sharpen = cv2.filter2D(final_grid, -1, sharpen_kernel)\n\n # resize the map to the wanted size\n map_w_border_row = WIDTH_G + 2\n map_w_border_col = LENGTH_G + 2\n vis_map = cv2.resize(sharpen, (map_w_border_col, map_w_border_row), cv2.INTER_AREA)\n return vis_map","def _get_depth_map_scale_subfolder(self):\n if self.im_scale <= 0.25:\n if self.im_scale <= 0.125:\n return \"Depth/0.125/\"\n else:\n return \"Depth/0.25/\"\n else: \n return \"Depth/\"","def reconstructed_data(self):\n try:\n data = np.sum(\n np.array([\n self.partial_reconstructed_data(i)\n for i in range(self._max_level)\n ]),\n axis=0)\n except MemoryError:\n data = np.array(self.partial_reconstructed_data(0))\n for i in range(1, self._max_level):\n data = np.sum([data,\n np.array(self.partial_reconstructed_data(i))], axis=0)\n return data","def positions(self, tileID, numSamples):","def layers_sizes(self):\n return iter([self.delta_h*l for l in range(int(self.h/self.delta_h)-1)])","def _read_IntM_from_pdata(p_data, out_size=None, cam_id=2):\n\n # IntM = np.zeros((4,4))\n raw_img_size = p_data.get_cam2(0).size if cam_id == 2 else p_data.get_cam3(0).size\n width = int(raw_img_size[0])\n height = int(raw_img_size[1])\n IntM = p_data.calib.K_cam2 if cam_id == 2 else p_data.calib.K_cam3\n focal_length = np.mean([IntM[0, 0], IntM[1, 1]])\n h_fov = math.degrees(math.atan(IntM[0, 2] / IntM[0, 0]) * 2)\n v_fov = math.degrees(math.atan(IntM[1, 2] / IntM[1, 1]) * 2)\n\n if out_size is not None: # the depth map is re-scaled #\n camera_intrinsics = np.zeros((3, 3))\n pixel_width, pixel_height = out_size[0], out_size[1]\n camera_intrinsics[2, 2] = 1.\n camera_intrinsics[0, 0] = IntM[0, 0] # (pixel_width/2.0)/math.tan(math.radians(h_fov/2.0))\n camera_intrinsics[0, 2] = (pixel_width - 1)/2.0\n camera_intrinsics[1, 1] = IntM[1, 1] # (pixel_height/2.0)/math.tan(math.radians(v_fov/2.0))\n camera_intrinsics[1, 2] = (pixel_height - 1) /2.0\n\n IntM = camera_intrinsics\n focal_length = pixel_width / width * focal_length\n width, height = pixel_width, pixel_height\n\n\n # In scanenet dataset, the depth is perperdicular z, not ray distance #\n pixel_to_ray_array = View.normalised_pixel_to_ray_array(width=width, height=height,\n hfov=h_fov, vfov=v_fov, normalize_z=True)\n\n pixel_to_ray_array_2dM = np.reshape(np.transpose( pixel_to_ray_array, axes=[2, 0, 1]), [3, -1])\n pixel_to_ray_array_2dM = torch.from_numpy(pixel_to_ray_array_2dM.astype(np.float32))\n cam_intrinsic = {\n 'hfov': h_fov, 'vfov': v_fov,\n 'unit_ray_array': pixel_to_ray_array,\n 'unit_ray_array_2D': pixel_to_ray_array_2dM,\n 'focal_length': focal_length,\n 'intrinsic_M': IntM} \n return cam_intrinsic","def _resize(self, new_capacity):\n temp_array = self.make_array(new_capacity)\n for i in range(self.n):\n temp_array[i] = self.original_array[i]\n self.original_array = temp_array\n self.capacity = new_capacity","def __init__(self):\n self.VideoFrame = np.array([])\n self.DepthFrameRaw = np.array([]).astype(np.uint16)\n \"\"\" Extra arrays for colormaping the depth image\"\"\"\n self.DepthFrameHSV = np.zeros((480, 640, 3)).astype(np.uint8)\n self.DepthFrameRGB = np.array([])\n\n \"\"\"initialize kinect & turn off auto gain and whitebalance\"\"\"\n freenect.sync_get_video_with_res(resolution=freenect.RESOLUTION_HIGH)\n # print(freenect.sync_set_autoexposure(False))\n freenect.sync_set_autoexposure(False)\n # print(freenect.sync_set_whitebalance(False))\n freenect.sync_set_whitebalance(False)\n \"\"\"check depth returns a frame, and flag kinectConnected\"\"\"\n if(freenect.sync_get_depth_with_res(format=freenect.DEPTH_11BIT) == None):\n self.kinectConnected = False\n else:\n self.kinectConnected = True\n\n # mouse clicks & calibration variables\n self.depth2rgb_affine = np.array(list(csv.reader(open(\"depth2rgb_affine.cfg\"))), dtype=float)\n self.kinectCalibrated = False\n self.last_click = np.array([0, 0])\n self.new_click = False\n self.rgb_click_points = np.zeros((5, 2), int)\n self.depth_click_points = np.zeros((5, 2), int)\n\n \"\"\" block info \"\"\"\n self.block_contours = np.array([])\n self.block_detections = np.array([])\n\n \"\"\"camera calibration\"\"\"\n self.cam_int_mat = [] # np.array([])\n self.cam_ext_mat = []\n self.dist_coeffs = []\n\n \"\"\"depth info\"\"\"\n self.max_depth = 0.95\n self.affine_transform = False","def _reshape(self, data):\n\n\t\t\td = np.zeros((32,32,3))\n\t\t\td_r = data[0:1024].reshape(32,32)\n\t\t\td_g = data[1024:2048].reshape(32,32)\n\t\t\td_b = data[2048:].reshape(32,32)\n\n\t\t\tfor h in range(32):\n\t\t\t for w in range(32):\n\t\t\t for c in range(3):\n\n\t\t\t if c == 0 : d[h,w,c] = d_r[h,w]\n\t\t\t elif c == 1 : d[h,w,c] = d_g[h,w]\n\t\t\t else : d[h,w,c] = d_b[h,w]\n\n\t\t\tarray = np.array(d, dtype=np.uint8)\n\t\t\timg = Image.fromarray(array)\n\t\t\ttemp = img.resize(size = (64,64))\n\t\t\td = image.img_to_array(temp)\n\n\t\t\t#plt.imshow(d)\n\t\t\t#plt.show()\n\t\t\treturn d","def registerDepthFrame(self, frame):\n frame = cv2.warpAffine(frame, self.depth2rgb_affine,\n (frame.shape[1], frame.shape[0]))\n return frame","def zoom_to_size(self, *p):\n\t\tif self.image is None or self.allocation is None:\n\t\t\treturn\n\t\tif __debug__: print self.allocation.width, self.image.get_width()\n\t\tif __debug__: print self.allocation.width, self.image.get_width(), self.allocation.width/self.image.get_width()\n\t\tz = min(\n\t\t\tself.allocation.width/self.image.get_width(),\n\t\t\tself.allocation.height/self.image.get_height()\n\t\t\t)\n\t\tif __debug__: print \"zoom_to_size\", \"z=\", z\n\t\tself.zoom = z","def resizeGL(self,Width,Height):\n return","def getDimensions():","def _set_z_size(self):\n self._level_gen.size = (self._level_gen.size[X],\n self._level_gen.size[Y],\n self._level_size_z_spinbox.value())\n self._refresh_view()","def generate_depth_image(self, cloud):\n points = self.get_hand_points(cloud)\n\n im1 = self.compute_height_map(points, 2)\n im2 = self.compute_height_map(points, 1)\n im3 = self.compute_height_map(points, 0)\n\n im1 = grey_dilation(im1, size=3)\n im2 = grey_dilation(im2, size=3)\n im3 = grey_dilation(im3, size=3)\n\n self.image = np.stack((im1, im2, im3), 0)","def _convert_to_depth(self, dist):\n return self.dist_to_bottom - dist","def _shrink(values, last_dim, reduction_factor):\n\n shape = tf.shape(values)\n new_shape = [\n shape[0],\n shape[1] // reduction_factor,\n last_dim * reduction_factor\n ]\n values = tf.reshape(values, new_shape)\n return values","def __init__(self, size: int):\n self.size = size\n self.window = []","def _conv_filter(state_dict, patch_size=16):\n out_dict = {}\n for k, v in state_dict.items():\n if 'patch_embed.proj.weight' in k:\n v = v.reshape((v.shape[0], 3, patch_size, patch_size))\n out_dict[k] = v\n return out_dict","def _get_state_sizes(self):\n ds = self.builder.nodes[self.ds_inputs[0]]\n return [[ds.xdim]]"],"string":"[\n \"def resized_map(self, new_size):\\n\\n new_map = cv2.resize(self.map.copy(), new_size)\\n cur_count = np.sum(new_map)\\n\\n # Avoid dividing by zero\\n if cur_count == 0:\\n return new_map\\n\\n scale = self.count / cur_count\\n new_map *= scale\\n return new_map\",\n \"def _reconstruct(self, num_samples=None):\",\n \"def pixel_shuffle(input, upscale_factor, inplace=False):\\n return FunctionLib.apply(\\n 'DepthToSpace', input.device, [input],\\n outputs=[input if inplace else None],\\n block_size=int(upscale_factor), mode='CRD', data_format='NCHW')\",\n \"def pixel_unshuffle(input, downscale_factor, inplace=False):\\n return FunctionLib.apply(\\n 'SpaceToDepth', input.device, [input],\\n outputs=[input if inplace else None],\\n block_size=int(downscale_factor), mode='CRD', data_format='NCHW')\",\n \"def depth_rendering(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\\n\\n x_indices = np.arange(lf_size[1])\\n y_indices = np.arange(lf_size[2])\\n b_indices = np.arange(lf_size[0])\\n\\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\\n\\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\\n stacked = np.stack(grid, 2)\\n positions = stacked.reshape(-1, 2)\\n\\n # Compute the distance from each lf position from the reference view\\n # Repeat the elements of this to match the size of the disparity map\\n ref_pos = np.array(\\n [lf_one_way // 2, lf_one_way // 2])\\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\\n\\n\\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\\n\\n # Compute the shifted pixels\\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\\n\\n #indices for linear interpolation in a square around the central point\\n x_low = np.around(x_shifted).astype(int)\\n #x_high = x_low + 1\\n\\n y_low = np.around(y_shifted).astype(int)\\n #y_high = y_low + 1\\n\\n #Place co-ordinates outside the image back into the image\\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\\n #x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\\n #y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\\n\\n #Gather the interpolation points\\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\\n #interp_pts_2 = np.stack((x_low_clip, y_high_clip))\\n #interp_pts_3 = np.stack((x_high_clip, y_low_clip))\\n #interp_pts_4 = np.stack((x_high_clip, y_high_clip))\\n\\n #Index into the images\\n desired_shape = lf_size\\n res_1 = torch_big_sample(ref_view, interp_pts_1, desired_shape)\\n return res_1\\n res_2 = torch_big_sample(ref_view, interp_pts_2, desired_shape)\\n res_3 = torch_big_sample(ref_view, interp_pts_3, desired_shape)\\n res_4 = torch_big_sample(ref_view, interp_pts_4, desired_shape)\\n\\n #Compute interpolation weights\\n x_low_f = x_low.astype(np.float32)\\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\\n d_x_high = 1.0 - d_x_low\\n y_low_f = y_low.astype(np.float32)\\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\\n d_y_high = 1.0 - d_y_low\\n\\n w1 = torch.from_numpy(d_x_low * d_y_low)\\n w2 = torch.from_numpy(d_x_low * d_y_high)\\n w3 = torch.from_numpy(d_x_high * d_y_low)\\n w4 = torch.from_numpy(d_x_high * d_y_high)\\n\\n #THEY AGREE AT THIS POINT\\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape), res_1)\\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape), res_2)\\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape), res_3)\\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape), res_4)\\n\\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\\n torch.add(novel_view, weighted_4, out=novel_view)\\n return novel_view\",\n \"def init_map(self, size, random_data = False):\\n heightmap = []\\n\\n if random_data:\\n # random noise background\\n for x in range(size):\\n heightmap.append([])\\n for y in range(size):\\n heightmap[-1].append(random.random())\\n else:\\n # black background\\n for x in range(size):\\n heightmap.append([])\\n for y in range(size):\\n heightmap[-1].append(0.0)\\n\\n return heightmap\",\n \"def reduceFrame(self, depth, height_ratio = 0.5, sub_sample = 0.3, reduce_to = 'lower'):\\n if (height_ratio > 1.0) or (height_ratio < 0.0)\\\\\\n or (sub_sample > 1.0) or (sub_sample < 0.0):\\n print('height_ratio and sub_sample must be between 0 and 1')\\n exit(1)\\n \\n depth_copy = depth.copy()\\n height = depth_copy.shape[0]\\n h = int(height_ratio*(height))\\n cols_to_cut = 0\\n\\n # catches the case when all rows are kept\\n if height_ratio == 1:\\n d_short = depth_copy\\n\\n elif reduce_to == 'lower':\\n d_short = depth_copy[(height - h):,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'middle_lower':\\n upper_brdr = int(3*(height/4.0) - h/2)\\n lower_brdr = upper_brdr + h\\n d_short = depth_copy[upper_brdr:lower_brdr,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'middle':\\n upper_brdr = int((height - h)/2.0)\\n lower_brdr = upper_brdr + h\\n d_short = depth_copy[upper_brdr:lower_brdr,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'middle_upper':\\n upper_brdr = int((height/4.0) - h/2)\\n lower_brdr = upper_brdr + h\\n d_short = depth_copy[upper_brdr:lower_brdr,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'upper':\\n d_short = depth_copy[:h, cols_to_cut:-(cols_to_cut+1)]\\n\\n d_short[d_short <= 0] = np.nan\\n d_short[d_short > self.max_depth] = np.nan\\n \\n rescaled = rescale(d_short, sub_sample, mode='reflect', multichannel=False, anti_aliasing=True)\\n\\n return rescaled\",\n \"def gen_depth_data(scan_folder, dst_folder, normalize=False):\\n # specify the goal folder\\n dst_folder = os.path.join(dst_folder, 'depth')\\n try:\\n os.stat(dst_folder)\\n print('generating depth data in: ', dst_folder)\\n except:\\n print('creating new depth folder: ', dst_folder)\\n os.mkdir(dst_folder)\\n \\n # load LiDAR scan files\\n scan_paths = load_files(scan_folder)\\n\\n depths = []\\n \\n # iterate over all scan files\\n for idx in range(len(scan_paths)):\\n # load a point cloud\\n current_vertex = np.fromfile(scan_paths[idx], dtype=np.float32)\\n current_vertex = current_vertex.reshape((-1, 4))\\n \\n proj_range, _, _, _ = range_projection(current_vertex)\\n \\n # normalize the image\\n if normalize:\\n proj_range = proj_range / np.max(proj_range)\\n \\n # generate the destination path\\n dst_path = os.path.join(dst_folder, str(idx).zfill(6))\\n \\n # save the semantic image as format of .npy\\n np.save(dst_path, proj_range)\\n depths.append(proj_range)\\n print('finished generating depth data at: ', dst_path)\\n\\n return depths\",\n \"def __init__(self):\\n \\tself.transposition = {}\\n \\tself.currentDepthLimit = 0\\n\\tself.counter = 0\\t\\n pass\",\n \"def keepsize(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\\n\\n def residual(inputs, n_filters):\\n x = ReflectionPadding2D()(inputs)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = Activation(activation)(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, inputs])\\n\\n return x\\n\\n inputs = Input(shape=(nx, ny, 1))\\n x = GaussianNoise(noise)(inputs)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x0 = Activation(activation)(x)\\n\\n x = residual(x0, n_filters)\\n\\n for i in range(depth-1):\\n x = residual(x, n_filters)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, x0])\\n\\n# Upsampling for superresolution\\n x = UpSampling2D()(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = Activation(activation)(x)\\n\\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n\\n return Model(inputs=inputs, outputs=final)\",\n \"def infer_depths(self):\\n self.infer_depths_edges_from_cells()\\n self.infer_depths_cells_from_edges()\\n self.copy_depths_to_subgrid(depth_stat='depth_mean')\",\n \"def upsample(x, name, size):\\n with tf.name_scope(name):\\n outputs = tf.image.resize_bilinear(x, size)\\n # Return layer's output\\n return outputs\",\n \"def _build(self, inputs):\\n\\n # calculate how many slots we need from the 3 dimensions of the incoming conv layer (filter w/h plus depth)\\n dims = inputs.get_shape().as_list()\\n new_dim = 1\\n for d in dims[1:]: # leave first axis as is (batch)\\n new_dim = new_dim * d # multiply 'em up\\n return tf.reshape(inputs, [-1, new_dim]) # -1=keep this dimension as is (it could be anything as this is the number of samples) and flatten the others\",\n \"def prepare_cnn_entries(X,n_nodes=100):\\n idx = X[:,:,0] > 0\\n X_nozeros = X[idx]\\n min_X = np.min(X_nozeros[:,0])\\n max_X = np.max(X_nozeros[:,0])\\n del X_nozeros\\n gc.collect() \\n\\n \\n \\n wavelength_all,step = np.linspace(min_X,max_X, num=n_nodes,retstep=True)\\n #wavelength_edges = np.histogram_bin_edges(wavelength_all,bins=n_nodes)\\n\\n X_new = [[[] for i in range(n_nodes)] for j in range(X.shape[0])]\\n\\n \\n print('Start converting to discrete wavelength inputs...')\\n for i in range(X.shape[0]):\\n if(i % int(X.shape[0] / 10) == 0):\\n print('Part 1.... ' + str(round(100*i/X.shape[0],0)) + ' % completed')\\n for j in range(X.shape[1]):\\n if(X[i,j,0]>0):\\n X_new[i][int((X[i,j,0] - min_X) / step)].append(X[i,j,1])\\n #print(X_new[i][int((X[i,j,0] - min_X) / step)])\\n \\n #del X\\n gc.collect()\\n \\n X_new = np.array(X_new)\\n print(np.count_nonzero(X_new))\\n \\n for i in range(X_new.shape[0]):\\n if(i % int(X_new.shape[0] / 10) == 0):\\n print('Part 2.... ' + str(round(100*i/X_new.shape[0])) + ' % completed')\\n for j in range(X_new.shape[1]):\\n X_new[i,j] = np.array(X_new[i,j])\\n if(X_new[i,j].size > 0):\\n X_new[i,j] = np.mean(np.array(X_new[i,j]))\\n else:\\n X_new[i,j] = 0.\\n \\n print(np.count_nonzero(X_new))\\n \\n return X_new\",\n \"def densMap(fit, metricArray, n, overlap, imageSize, imageName):\\n \\n if True: #Make true if you want to calculate densities (i.e. if you have a new fit/new density list) \\n print 'calculating densities'\\n if type(fit)==sklearn.gaussian_process.gaussian_process.GaussianProcess: #If the fit is Gaussian\\n densities, MSE = fit.predict(metricArray, eval_MSE =True)\\n sigma = numpy.sqrt(MSE)\\n print(sigma)\\n else:\\n densities = fit.predict(metricArray) #Use the ML fit to predict the density for each tile \\n #print len(densities)\\n f = open('densities.txt', 'w')\\n print >> f, list(densities)\\n f.close()\\n else: \\n f = open('densities.txt', 'r')\\n data = f.read()\\n densities = eval(data)\\n # print densities\\n densities = numpy.array(densities)\\n f.close()\\n imageName = 'FirstStitchLong.jpg'\\n overlap = 0.2 \\n n = 50\\n image = Image.open(imageName) #open the image\\n imageSize = image.size #get the image size \\n # print 'Image Size is ', imageSize\\n \\n\\n width = imageSize[0] \\n height = imageSize[1] \\n # print 'width ', width \\n #print 'height ', height\\n overlapSize = int(overlap*n)\\n rowTiles = int((width-n)/(overlapSize))+1\\n print 'Row Tiles is ', rowTiles\\n #colTiles = int(((height-n)/(overlapSize))+1)\\n \\n \\n # newArray = numpy.zeros((int((width-n)/(overlapSize)+1),int(((height-n)/(overlapSize))+1)))\\n \\n #newArray = numpy.zeros(width, height)\\n #print newArray\\n points = []\\n for i in range(len(densities)):\\n x = (i%rowTiles)*overlapSize + n/2\\n y = (i/rowTiles)*overlapSize + n/2\\n points += [[x,y]]\\n # newArray[i%(rowTiles),i/(rowTiles)] = densities[i]\\n # newArray[(i%(rowTiles)+1)*(n/2) , (i/(rowTiles)+1)*(n/2)] = densities[i]\\n # points += [[(i%(rowTiles)+1)*(n/2), (i/(rowTiles)+1)*(n/2)]] #Consider the density to be at the center of each tile \\n # print points\\n grid_x, grid_y = numpy.mgrid[0:width, 0:height] #create a meshgrid \\n \\n # print densities\\n # print('Points is ', points) \\n # print('Densities is ', densities)\\n data = griddata(points, densities, (grid_x, grid_y), method = 'linear') #interpolate to get continuous function of points \\n #can change interpolation method\\n print data.size\\n\\n # print 'Max is ', numpy.amax(data)\\n # min_max_scaler = sklearn.preprocessing.MinMaxScaler()\\n #data_minmax = min_max_scaler.fit_transform(data) \\n \\n \\n \\n ##Plotting \\n plt.figure(1)\\n \\n #plt.figure(figsize = (width, height))\\n # print \\\"Hi Cassie\\\"\\n v = numpy.linspace(min(densities), max(densities), 20, endpoint=True)\\n fig = plt.contourf(grid_x, grid_y, data, levels = v, alpha = 0.4, antialiased = True)\\n \\n mapIm = Image.open(imageName)\\n plt.imshow(mapIm)\\n maxDens = max(densities)\\n print maxDens \\n x = plt.colorbar(fig) \\n plt.savefig('ContourPlot.jpg')\\n return data\",\n \"def glimpseSensor(img, normLoc, minRadius=4, depth=1, sensorBandwidth=12):\\n input_shape = img.get_shape().as_list()\\n img_size = input_shape[1]\\n loc = tf.round(((normLoc + 1) / 2.0) * img_size)\\n loc = tf.cast(loc, tf.int32)\\n zooms = []\\n for k in range(batch_size):\\n imgZooms = []\\n one_img = img[k, :, :, :]\\n max_radius = minRadius * (2**(depth - 1))\\n offset = 2 * max_radius\\n one_img = tf.image.pad_to_bounding_box(one_img, offset, offset, max_radius * 4 + img_size,\\n max_radius * 4 + img_size)\\n\\n for i in range(depth):\\n r = int(minRadius * (2**(i)))\\n d_raw = 2 * r\\n d = tf.constant(d_raw, shape=[1])\\n d = tf.tile(d, [2])\\n loc_k = loc[k, :]\\n adjusted_loc = offset + loc_k - r\\n one_img2 = tf.reshape(\\n one_img, (one_img.get_shape()[0].value, one_img.get_shape()[1].value, input_shape[3]))\\n zoom = tf.slice(one_img2, adjusted_loc, d)\\n zoom = tf.image.resize_bilinear(\\n tf.reshape(zoom, (1, d_raw, d_raw, nput_shape[3])), (sensorBandwidth, sensorBandwidth))\\n zoom = tf.reshape(zoom, (sensorBandwidth, sensorBandwidth, input_shape[3]))\\n imgZooms.append(zoom)\\n\\n zooms.append(tf.stack(imgZooms))\\n\\n return tf.stack(zooms)\",\n \"def keepsize_256(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\\n\\n def residual(inputs, n_filters):\\n x = ReflectionPadding2D()(inputs)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = Activation(activation)(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, inputs])\\n\\n return x\\n\\n inputs = Input(shape=(nx, ny, 1))\\n x = GaussianNoise(noise)(inputs)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x0 = Activation(activation)(x)\\n\\n x = residual(x0, n_filters)\\n\\n for i in range(depth-1):\\n x = residual(x, n_filters)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, x0])\\n\\n# Upsampling for superresolution\\n x = UpSampling2D()(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(4*n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = Activation(activation)(x)\\n\\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n\\n return Model(inputs=inputs, outputs=final)\",\n \"def update_dimensions(self):\\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\\n dtype=\\\"int16\\\")\",\n \"def __init__(self, width, height, circular=True):\\n self.width = width\\n self.height = height\\n self.size = width * height\\n self.idx_list = []\\n self._depth_buffer = [[] for _ in range(self.size)]\\n self._depth = [0] * self.size\\n self.circular = circular\",\n \"def __init__(self):\\n self.size = 1000\\n self.mapArray = [None] * self.size\",\n \"def rebuild(self):\\n self.from_samples(self.samples)\",\n \"def resize_lightfield(raw_lightfield, desired_size): # -> lightfield\\n if raw_lightfield.ndim == 6:\\n n_depth, n_cols, n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_depth, n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n\\n for k, depth in enumerate(raw_lightfield):\\n for i, row in enumerate(depth):\\n for j, image_data in enumerate(row):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[k, i, j] = resized_image_data\\n elif raw_lightfield.ndim == 5:\\n n_cols, n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n\\n for i, row in enumerate(raw_lightfield):\\n for j, image_data in enumerate(row):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[i, j] = resized_image_data\\n \\n elif raw_lightfield.ndim == 4:\\n n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n for j, image_data in enumerate(raw_lightfield):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[j] = resized_image_data\\n \\n return output_lightfield\",\n \"def _build_depth_graph(self):\\n self.depth_net = DepthNetwork(self.cfg.STRUCTURE, is_training=False)\\n images = self.images_placeholder[tf.newaxis]\\n poses = self.poses_placeholder[tf.newaxis]\\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\\n\\n # fix the input shape\\n images = tf.reshape(images, [1, 5, 192, 1088, 3])\\n Ts = VideoSE3Transformation(matrix=poses)\\n\\n depths = self.depth_net.forward(Ts, images, intrinsics)\\n self.outputs['depths'] = depths\",\n \"def on_depth_image(self, depth_image):\\n depth_image = depth_image.copy()\\n mask = np.where(self.depth != 0)\\n depth_image[mask] = self.depth[mask]\\n return depth_image\",\n \"def _resize(self, cap):\\n old = self._data\\n self._data = [None] * cap\\n walk = self._front\\n for i in range(self._size):\\n self._data[i] = old[walk]\\n walk = (walk + 1) % len(old)\\n self._front = 0\",\n \"def __init__(self, d=1):\\r\\n self.depth = d\",\n \"def depr_depth_images(self):\\n if not hasattr(self, '_depr_depth_images'):\\n depth_images = self._archive['gaps_depth']\\n self._depr_depth_images = depth_images.reshape([1, 20, 224, 224, 1])\\n return self._depr_depth_images\",\n \"def upsampleImage( arr, kernelSize ):\\n return scipy.ndimage.zoom( arr, kernelSize )\",\n \"def __resize_to_512(input_data):\\n test_size = 720\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\\n axis=-1))\\n for contour in contours] for contours in input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\\n axis=-1)) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * 512 / input_data['img'].shape[0]),\\n np.cast['int32'](point[1] * 512 / input_data['img'].shape[1]))\\n for point in input_data['center_point']]\\n\\n seq = iaa.Sequential([\\n iaa.Scale({'height': 512, 'width': 512}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n return input_data\",\n \"def _preallocate_samples(self):\\n self.prealloc_samples_ = []\\n for _ in range(self.num_prealloc_samples_):\\n self.prealloc_samples_.append(self.sample())\",\n \"def __resize_512p(input_data):\\n rate = 1\\n test_size=512\\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\\n if True: # input_data['img'].shape[1] < 512:\\n rate = test_size / input_data['img'].shape[1]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': \\\"keep-aspect-ratio\\\", 'width': test_size}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n else:\\n if True: # input_data['img'].shape[0] < 512:\\n rate = test_size / input_data['img'].shape[0]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': test_size, 'width': \\\"keep-aspect-ratio\\\"}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\\n input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\\n return input_data\",\n \"def downsample_sam(self, factor):\",\n \"def main():\\n\\n ##############################\\n # Options\\n ##############################\\n # Validation set\\n input_depth_dir = os.path.expanduser(\\n '~/Kitti/depth/train')\\n data_split = 'val'\\n\\n # Test set\\n # input_depth_dir = os.path.expanduser(\\n # '~/Kitti/depth/depth_selection/test_depth_completion_anonymous/velodyne_raw')\\n # data_split = 'test'\\n\\n # Fast fill with Gaussian blur @90Hz (paper result)\\n fill_type = 'fast'\\n extrapolate = True\\n blur_type = 'gaussian'\\n\\n # Fast Fill with bilateral blur, no extrapolation @87Hz (recommended)\\n # fill_type = 'fast'\\n # extrapolate = False\\n # blur_type = 'bilateral'\\n\\n # Multi-scale dilations with extra noise removal, no extrapolation @ 30Hz\\n # fill_type = 'multiscale'\\n # extrapolate = False\\n # blur_type = 'bilateral'\\n\\n # Save output to disk or show process\\n save_output = True\\n\\n ##############################\\n # Processing\\n ##############################\\n if save_output:\\n # Save to Disk\\n show_process = False\\n save_depth_maps = True\\n else:\\n if fill_type == 'fast':\\n raise ValueError('\\\"fast\\\" fill does not support show_process')\\n\\n # Show Process\\n show_process = True\\n save_depth_maps = False\\n\\n # Create output folder\\n this_file_path = os.path.dirname(os.path.realpath(__file__))\\n outputs_dir = this_file_path + '/outputs'\\n os.makedirs(outputs_dir, exist_ok=True)\\n\\n output_folder_prefix = 'depth_' + data_split\\n output_list = sorted(os.listdir(outputs_dir))\\n if len(output_list) > 0:\\n split_folders = [folder for folder in output_list\\n if folder.startswith(output_folder_prefix)]\\n if len(split_folders) > 0:\\n last_output_folder = split_folders[-1]\\n last_output_index = int(last_output_folder.split('_')[-1])\\n else:\\n last_output_index = -1\\n else:\\n last_output_index = -1\\n output_depth_dir = outputs_dir + '/{}_{:03d}'.format(\\n output_folder_prefix, last_output_index + 1)\\n\\n if save_output:\\n if not os.path.exists(output_depth_dir):\\n os.makedirs(output_depth_dir)\\n else:\\n raise FileExistsError('Already exists!')\\n print('Output dir:', output_depth_dir)\\n\\n # Get images in sorted order\\n # images_to_use = sorted(glob.glob(input_depth_dir + '/*'))\\n\\n # Rolling average array of times for time estimation\\n avg_time_arr_length = 10\\n last_fill_times = np.repeat([1.0], avg_time_arr_length)\\n last_total_times = np.repeat([1.0], avg_time_arr_length)\\n\\n images_to_use = []\\n saved_path = []\\n folder_path =\\\"./data_depth_selection/depth_selection/test_depth_completion_anonymous/velodyne_raw\\\"\\n for img_name in os.listdir(folder_path):\\n img_path = os.path.join(folder_path,img_name)\\n saved_path_name = os.path.join(\\\"./output\\\", img_name)\\n saved_path.append(saved_path_name)\\n images_to_use.append(img_path)\\n # if \\\"output\\\" not in os.listdir(\\\"Kitti/depth/\\\"):\\n # os.mkdir(\\\"Kitti/depth/output\\\")\\n # os.mkdir(\\\"output\\\")\\n # for folder in os.listdir(folder_path):\\n # # os.mkdir(\\\"./output/\\\"+folder)\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\")\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\")\\n\\n # inside_folder_path = folder_path + \\\"/\\\" + folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"\\n # for img_folder in os.listdir(inside_folder_path):\\n # print((\\\"/output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder))\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder)\\n # print(inside_folder_path + img_folder)\\n # # os.mkdir(\\\"Kitti/depth/output/\\\"+folder+\\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # img_path = inside_folder_path + img_folder+\\\"/data\\\"\\n # try:\\n # print(\\\"............................................................\\\",\\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # depth_image_folder = os.listdir(\\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # # print(depth_image_folder)\\n # for img in os.listdir(img_path):\\n # # image_path = +\\\"/\\\"+img\\n # # print(img)\\n # if img in depth_image_folder:\\n # # print(\\\"aaya\\\")\\n # depth_image_path = \\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder+\\\"/\\\"+img\\n # images_to_use.append(depth_image_path)\\n # saved_path.append(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder+\\\"/\\\"+img)\\n # except Exception:\\n # print(\\\"folder nahi hai\\\")\\n \\n images_to_use = np.array(images_to_use)\\n \\n num_images = len(images_to_use)\\n\\n print(len(images_to_use))\\n\\n\\n for i in range(num_images):\\n\\n depth_image_path = images_to_use[i]\\n\\n # Calculate average time with last n fill times\\n avg_fill_time = np.mean(last_fill_times)\\n avg_total_time = np.mean(last_total_times)\\n\\n # Show progress\\n sys.stdout.write('\\\\rProcessing {} / {}, '\\n 'Avg Fill Time: {:.5f}s, '\\n 'Avg Total Time: {:.5f}s, '\\n 'Est Time Remaining: {:.3f}s'.format(\\n i, num_images - 1, avg_fill_time, avg_total_time,\\n avg_total_time * (num_images - i)))\\n sys.stdout.flush()\\n\\n # Start timing\\n start_total_time = time.time()\\n print(depth_image_path)\\n # Load depth projections from uint16 image\\n depth_image = cv2.imread(depth_image_path, cv2.IMREAD_ANYDEPTH)\\n projected_depths = np.float32(depth_image / 256.0)\\n\\n # Fill in\\n start_fill_time = time.time()\\n if fill_type == 'fast':\\n final_depths = depth_map_utils.fill_in_fast(\\n projected_depths, extrapolate=extrapolate, blur_type=blur_type)\\n elif fill_type == 'multiscale':\\n final_depths, process_dict = depth_map_utils.fill_in_multiscale(\\n projected_depths, extrapolate=extrapolate, blur_type=blur_type,\\n show_process=show_process)\\n else:\\n raise ValueError('Invalid fill_type {}'.format(fill_type))\\n end_fill_time = time.time()\\n\\n # Display images from process_dict\\n if fill_type == 'multiscale' and show_process:\\n img_size = (570, 165)\\n\\n x_start = 80\\n y_start = 50\\n x_offset = img_size[0]\\n y_offset = img_size[1]\\n x_padding = 0\\n y_padding = 28\\n\\n img_x = x_start\\n img_y = y_start\\n max_x = 1900\\n\\n row_idx = 0\\n for key, value in process_dict.items():\\n\\n image_jet = cv2.applyColorMap(\\n np.uint8(value / np.amax(value) * 255),\\n cv2.COLORMAP_JET)\\n vis_utils.cv2_show_image(\\n key, image_jet,\\n img_size, (img_x, img_y))\\n\\n img_x += x_offset + x_padding\\n if (img_x + x_offset + x_padding) > max_x:\\n img_x = x_start\\n row_idx += 1\\n img_y = y_start + row_idx * (y_offset + y_padding)\\n\\n # Save process images\\n cv2.imwrite('process/' + key + '.png', image_jet)\\n\\n cv2.waitKey()\\n\\n # Save depth images to disk\\n if save_depth_maps:\\n depth_image_file_name = depth_image_path.split(\\\"/\\\")\\n # print(depth_image_file_name)\\n file_path = \\\"\\\"\\n print(len(depth_image_file_name))\\n # for i in range(8):\\n # if(i == 2):\\n # file_path = os.path.join(file_path, \\\"output\\\")\\n # else:\\n # file_path = os.path.join(file_path, depth_image_file_name[i])\\n # cv2.imwrite(file_path, depth_image)\\n # print(\\\"check.............................\\\",saved_path[i])\\n # with open(saved_path[i],'r') as f:\\n # print(\\\"badhiya\\\") \\n depth_image = (final_depths * 256)\\n # plt.imsave(saved_path[i],depth_image)\\n # cv2.imwrite(saved_path[i], depth_image)\\n # print(saved_path[i])\\n # cv2.imwrite(\\\"/media/pankaj/Elements/ip_basic\\\"+saved_path[i], depth_image)\\n \\n try:\\n with open(saved_path[i], 'wb') as f:\\n depth_image = (final_depths * 256).astype(np.uint16)\\n\\n writer = png.Writer(width=depth_image.shape[1],\\n height=depth_image.shape[0],\\n bitdepth=16,\\n greyscale=True)\\n writer.write(f, depth_image)\\n except Exception:\\n print(\\\"nikl.............\\\")\\n\\n end_total_time = time.time()\\n\\n # Update fill times\\n last_fill_times = np.roll(last_fill_times, -1)\\n last_fill_times[-1] = end_fill_time - start_fill_time\\n\\n # Update total times\\n last_total_times = np.roll(last_total_times, -1)\\n last_total_times[-1] = end_total_time - start_total_time\",\n \"def Resize(self):\\n\\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\\n self.FreshStart()\",\n \"def reset_map(self):\\n self.x = None\\n self.X = None\\n self.y = None\\n self.Y = None\\n self.data = None\\n self.sampling = None\\n self.size = None\",\n \"def depth_rendering_gpu(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\\n\\n x_indices = np.arange(lf_size[1])\\n y_indices = np.arange(lf_size[2])\\n b_indices = np.arange(lf_size[0])\\n\\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\\n\\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\\n stacked = np.stack(grid, 2)\\n positions = stacked.reshape(-1, 2)\\n\\n # Compute the distance from each lf position from the reference view\\n # Repeat the elements of this to match the size of the disparity map\\n ref_pos = np.array(\\n [lf_one_way // 2, lf_one_way // 2])\\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\\n\\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\\n\\n # Compute the shifted pixels\\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\\n\\n #indices for linear interpolation in a square around the central point\\n x_low = np.floor(x_shifted).astype(int)\\n x_high = x_low + 1\\n\\n y_low = np.floor(y_shifted).astype(int)\\n y_high = y_low + 1\\n\\n #Place co-ordinates outside the image back into the image\\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\\n x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\\n y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\\n\\n #Gather the interpolation points\\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\\n interp_pts_2 = np.stack((x_low_clip, y_high_clip))\\n interp_pts_3 = np.stack((x_high_clip, y_low_clip))\\n interp_pts_4 = np.stack((x_high_clip, y_high_clip))\\n\\n #Index into the images\\n desired_shape = lf_size\\n ref_view = torch.tensor(ref_view, dtype=torch.float32).cuda()\\n res_1 = torch_tensor_sample(ref_view, interp_pts_1, desired_shape)\\n res_2 = torch_tensor_sample(ref_view, interp_pts_2, desired_shape)\\n res_3 = torch_tensor_sample(ref_view, interp_pts_3, desired_shape)\\n res_4 = torch_tensor_sample(ref_view, interp_pts_4, desired_shape)\\n\\n #Compute interpolation weights\\n x_low_f = x_low.astype(np.float32)\\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\\n d_x_high = 1.0 - d_x_low\\n y_low_f = y_low.astype(np.float32)\\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\\n d_y_high = 1.0 - d_y_low\\n\\n w1 = torch.from_numpy(d_x_low * d_y_low)\\n w2 = torch.from_numpy(d_x_low * d_y_high)\\n w3 = torch.from_numpy(d_x_high * d_y_low)\\n w4 = torch.from_numpy(d_x_high * d_y_high)\\n\\n #THEY AGREE AT THIS POINT\\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape).cuda(), res_1)\\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape).cuda(), res_2)\\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape).cuda(), res_3)\\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape).cuda(), res_4)\\n\\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\\n torch.add(novel_view, weighted_4, out=novel_view)\\n return novel_view\",\n \"def generate_all_sizes():\\n dimension = 4\\n h = 1\\n while h <= dimension:\\n w = 1\\n while w <= dimension:\\n for y in range(0, dimension, h):\\n for x in range(0, dimension, w):\\n yield FeatureSize(x / dimension,\\n y / dimension,\\n w / dimension,\\n h / dimension)\\n w = w * 2\\n h = h * 2\",\n \"def downsample(state):\\n return state[::2, ::2, :]\",\n \"def dryrun_find_featuremap_dims(\\n feature_extractor: FeatureExtractor | GraphModule,\\n input_size: tuple[int, int],\\n layers: list[str],\\n) -> dict[str, dict[str, int | tuple[int, int]]]:\\n\\n dryrun_input = torch.empty(1, 3, *input_size)\\n dryrun_features = feature_extractor(dryrun_input)\\n return {\\n layer: {\\\"num_features\\\": dryrun_features[layer].shape[1], \\\"resolution\\\": dryrun_features[layer].shape[2:]}\\n for layer in layers\\n }\",\n \"def make_map(self, sampling=None, size=None):\\n if sampling is None and self.sampling is None:\\n self.sampling = self.minimum_sampling()\\n elif sampling is not None:\\n self.sampling = sampling\\n \\n if size is None and self.size is None:\\n self.size = self.minimum_size()\\n elif size is not None:\\n self.size = size\\n\\n # Set the number of pixels that spans the full size requested\\n pixsize = numpy.ceil(self.size/self.sampling).astype(int)\\n # Force the pixel size to be odd\\n if pixsize % 2 == 0:\\n pixsize += 1\\n # Adjust the size to be an integer number of pixels\\n _size = pixsize*self.sampling\\n if _size - self.size > 0.1*self.sampling:\\n warnings.warn('Size reset to an integer number of pixels: '\\n ' {0} -> {1} arcsec'.format(self.size, _size))\\n self.size = _size\\n self.y = (pixsize-1)*numpy.linspace(-0.5,0.5,pixsize)*self.sampling\\n self.x = self.y.copy()[::-1]\\n\\n # Sample it\\n self.X, self.Y = numpy.meshgrid(self.x, self.y)\\n self.data = self.__call__(self.X, self.Y)\",\n \"def undistort_rectify_map(self):\\n return cv.initUndistortRectifyMap(self._k, self._dist, np.eye(3), self._k, self.frame_size[::-1], cv.CV_16SC2)\",\n \"def _modify_map_size(self, merged_map):\\n pos_x_white, pos_y_white = np.where(merged_map == 255)\\n pos_x_black, pos_y_black = np.where(merged_map == 0)\\n\\n pos_x_M = np.amax(np.hstack((pos_x_black, pos_x_white)))\\n pos_x_m = np.amin(np.hstack((pos_x_black, pos_x_white)))\\n pos_y_M = np.amax(np.hstack((pos_y_black, pos_y_white)))\\n pos_y_m = np.amin(np.hstack((pos_y_black, pos_y_white)))\\n\\n reduced_map = merged_map[pos_x_m-5:pos_x_M+5, pos_y_m-5:pos_y_M+5]\\n\\n return reduced_map\",\n \"def upsample_filt(size):\\r\\n factor = (size + 1) // 2\\r\\n if size % 2 == 1:\\r\\n center = factor - 1\\r\\n else:\\r\\n center = factor - 0.5\\r\\n og = np.ogrid[:size, :size]\\r\\n return (1 - abs(og[0] - center) / factor) * \\\\\\r\\n (1 - abs(og[1] - center) / factor)\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\\n self._curr_idx = 0\\n self._depths, self._heights = None, None\",\n \"def resize_volume(img):\\n desired_depth = 64\\n desired_width = 128\\n desired_height = 128\\n\\n current_depth = img.shape[-1]\\n current_width = img.shape[0]\\n current_height = img.shape[1]\\n\\n depth = current_depth / desired_depth\\n width = current_width / desired_width\\n height = current_height / desired_height\\n\\n depth_factor = 1 / depth\\n width_factor = 1 / width\\n height_factor = 1 / height\\n\\n img = ndimage.rotate(input=img, angle=90, reshape=False)\\n img = ndimage.zoom(input=img, zoom=(width_factor, height_factor, depth_factor), order=1)\\n\\n return img\",\n \"def __init__(self, input_size=88):\\n self._input_size = input_size\",\n \"def _assign_sizes(self):\",\n \"def __init__(self, output_size, spatial_scale=1.0):\\n super().__init__()\\n self.output_size = output_size\\n self.spatial_scale = spatial_scale\",\n \"def __init__(self, output_size, spatial_scale=1.0):\\n super().__init__()\\n self.output_size = output_size\\n self.spatial_scale = spatial_scale\",\n \"def upsample(inputs, out_shape, data_format):\\n if data_format == 'channels_first':\\n inputs = tf.transpose(inputs, [0, 2, 3, 1])\\n new_height = out_shape[3]\\n new_width = out_shape[2]\\n else:\\n new_height = out_shape[2]\\n new_width = out_shape[1]\\n\\n inputs = tf.image.resize_nearest_neighbor(inputs, (new_height, new_width))\\n if data_format == 'channels_first':\\n inputs = tf.transpose(inputs, [0, 3, 1, 2])\\n return inputs\",\n \"def upsample_2d(x, size=(2, 2)):\\n h, w, _ = x.get_shape().as_list()[1:]\\n size_x, size_y = size\\n output_h = h * size_x\\n output_w = w * size_y\\n return tf.image.resize_bilinear(x, (output_h, output_w), align_corners=None, name='upsampling')\",\n \"def __init__(self, size=(2, 2), **kwargs):\\n super(MaxUnpooling2D, self).__init__(**kwargs)\\n self.size = size\",\n \"def __init__(self,\\n depth_multiplier,\\n min_depth,\\n conv_hyperparams,\\n reuse_weights=None):\\n super(SSDVgg16FeatureExtractor, self).__init__(\\n depth_multiplier, min_depth, conv_hyperparams, reuse_weights)\",\n \"def loadDepthFrame(self):\\n self.DepthFrameRaw = cv2.imread(\\n script_path + \\\"/data/raw_depth.png\\\", 0).astype(np.uint16)\",\n \"def reindex(self):\\n super().reindex()\\n self._depths, self._heights = None, None\\n for p in self.positions():\\n self._compute_depth(p)\\n self._compute_height(p)\",\n \"def _visualize_input(self, input):\\n self.writer.add_image('input', make_grid(input[0, 0, :, :], nrow=8, normalize=True))\",\n \"def __init__(self, size):\\n self.world = [[None for y in range(size)] for x in range(size)]\",\n \"def DEPTH(frame):\\n\\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\\n\\tframe.image.copy_bits( depth.ctypes.data )\\n\\tcv2.imshow( 'VideoDEPTH', depth )\",\n \"def make_hp_map(data, hp_indices, Nside = 2048, nest = True):\\n \\n print(\\\"len hp_indices: {}\\\".format(len(hp_indices)))\\n hp_indices = np.array(hp_indices)\\n print(\\\"shape of hp_indices: {}\\\".format(hp_indices.shape))\\n hp_indices = np.squeeze(hp_indices)\\n \\n Npix = 12*Nside**2\\n map_data = np.zeros(Npix, np.float_)\\n map_data[hp_indices] = data\\n \\n return map_data\",\n \"def f() -> None:\\n x = torch.rand(7, 3).to(self.device)\\n kernel = ScaleKernel(MaternKernel())\\n allocator = GreedyVarianceReduction()\\n allocator.allocate_inducing_points(x, kernel, 4, x.shape[:-2])\",\n \"def _increase_size(self) -> None:\\n keys_vals_to_move = [item for item in self.HashMap if item]\\n self.length = 0\\n self.capacity = self.capacity * 2\\n self.HashMap = [None] * self.capacity\\n for item in keys_vals_to_move:\\n while len(item) > 0:\\n self.add(item[0], item[1])\\n item.pop(0)\\n item.pop(0)\",\n \"def dimensions():\",\n \"def _build_reprojection_graph(self):\\n EPS = 1e-8\\n depths = self.depths_placeholder[tf.newaxis]\\n poses = self.poses_placeholder[tf.newaxis]\\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\\n\\n batch, num, ht, wd = tf.unstack(tf.shape(depths), num=4)\\n Ts = VideoSE3Transformation(matrix=poses)\\n intrinsics = intrinsics_vec_to_matrix(intrinsics)\\n\\n ii, jj = tf.meshgrid(tf.range(0, num), tf.range(num, num+1))\\n ii = tf.reshape(ii, [-1])\\n jj = tf.reshape(jj, [-1])\\n\\n Tij = Ts.gather(jj) * Ts.gather(ii).inv()\\n X0 = projective_ops.backproject(depths, intrinsics)\\n X1 = Tij(X0)\\n\\n coords = projective_ops.project(X1, intrinsics)\\n depths = X1[..., 2]\\n\\n indicies = tf.cast(coords[..., ::-1] + .5, tf.int32)\\n indicies = tf.reshape(indicies, [-1, 2])\\n depths = tf.reshape(depths, [-1])\\n\\n depth = tf.scatter_nd(indicies, depths, [ht, wd])\\n count = tf.scatter_nd(indicies, tf.ones_like(depths), [ht, wd])\\n\\n depth = depth / (count + EPS)\\n self.outputs['depth_reprojection'] = depth\",\n \"def draw(self):\\n\\n super().draw()\\n \\n self.dim = self.getdim()\\n start_x, start_y, = self.x(), self.y()\\n\\n for y in range(self.r):\\n for x in range(self.c):\\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\\n self.tiles[y][x].resize(x_pos, y_pos, self.dim, self.dim)\",\n \"def edit(self):\\n wmap = 512\\n if not self.mapd:\\n data = self.data[24:]\\n mapd = self.mapd = []\\n for index in xrange(0,3*wmap*wmap,3):\\n mapd.append(data[index:index+3])\\n self.setChanged()\",\n \"def resize_volumes(x, depth_factor, height_factor, width_factor, data_format='channels_last'):\\n if data_format == 'channels_first':\\n output = repeat_elements(x, depth_factor, axis=2)\\n output = repeat_elements(output, height_factor, axis=3)\\n output = repeat_elements(output, width_factor, axis=4)\\n return output\\n elif data_format == 'channels_last':\\n output = repeat_elements(x, depth_factor, axis=1)\\n output = repeat_elements(output, height_factor, axis=2)\\n output = repeat_elements(output, width_factor, axis=3)\\n return output\\n else:\\n raise ValueError('Invalid data_format:', data_format)\",\n \"def initiate_memory(self):\\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]\",\n \"def show_rgbd(self):\\n while self.depth_data is None:\\n pass\\n\\n while not rospy.is_shutdown():\\n rospy.Rate(10).sleep()\\n d = self.depth_data * self.cam.DEPTH_UNIT\\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\\n dc = np.concatenate((d, self.rgb_data), axis=1)\\n cv2.imshow('RGB & Depth Image', dc)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n cv2.destroyAllWindows()\",\n \"def __init__(self, width, height):\\n self.clean_tiles = []\\n self.width = width\\n self.height = height\",\n \"def __init__(self, width, height):\\n self.w = width\\n self.h = height\\n self.cleanTiles = []\\n self.tiles = [[False] * width for i in range(height)]\\n self.cleaned = 0\",\n \"def run(self, depth):\\n\\t\\tdepth = depth.invert()\\n\\t\\t\\\"\\\"\\\"use this to convert it into cm, or into m by changing 10 to 100\\\"\\\"\\\"\\n\\t\\tdepth = divide(depth, 10)\\n\\t\\t\\\"\\\"\\\"Makes blobs easier to detect\\\"\\\"\\\"\\n\\t\\tdepth = depth.erode()\\n\\t\\tblob_array = self.blob_detect(depth)\\n\\t\\tif blob_array:\\n\\t\\t\\ttheadau_array = self.get_theadaus(blob_array)\\n\\t\\t\\tprint theadau_array\\n\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\tUntill i fill in outside coord array, i will get rid of this code\\n\\t\\t\\toutside_coord_array = self.get_outside_points(blob_array)\\n\\t\\t\\tblob_width_array = self.get_width(outside_coord_array, theadau_array)\\n\\t\\t\\treturn blob_width_array\\t\\n\\t\\t\\t\\\"\\\"\\\"\\t\\n\\t\\treturn blob_array\",\n \"def resize(self):\\n pass\",\n \"def depth_callback(self, data):\\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\\\"passthrough\\\")\\n self.depth_mutex.acquire()\\n self.depth_image = cv_image\\n self.depth_mutex.release()\",\n \"def polylinedictarraycopy(d):#d——原始图层多段线字典 \\r\\n dictlist=[]\\r\\n ratiolist=[] #放缩率列表\\r\\n rationumaccumulationlist=[] #放缩率数量累加列表\\r\\n \\r\\n eachrationum=globalconfig.X_ARRAY_NUM//globalconfig.RATIO_NUM\\r\\n leftrationum=globalconfig.X_ARRAY_NUM%globalconfig.RATIO_NUM\\r\\n \\r\\n eachrationumlist=[eachrationum]*globalconfig.RATIO_NUM #各个放缩率对应数量的列表\\r\\n \\r\\n for i in range((globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2,(globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2+leftrationum):\\r\\n eachrationumlist[i]=eachrationumlist[i]+1 #将整除后的余值加入到靠中间放缩率的方案中。\\r\\n \\r\\n rationumaccumulationlist.append(0) \\r\\n \\r\\n for i in range(1,globalconfig.RATIO_NUM): #计算放缩率数量累加列表\\r\\n rationumaccumulationlist.append(rationumaccumulationlist[i-1]+eachrationumlist[i-1])\\r\\n \\r\\n for i in range(0,globalconfig.RATIO_NUM): #计算放缩率列表\\r\\n ratiolist.append((globalconfig.CENTER_RATIO-((globalconfig.RATIO_NUM+1)//2-1)*globalconfig.RATIO_DIFF)+i*globalconfig.RATIO_DIFF) \\r\\n \\r\\n for i in range(0,globalconfig.RATIO_NUM): #每种放缩率\\r\\n for j in range(0,eachrationumlist[i]): #每种放缩率对应数量\\r\\n newdict={}\\r\\n for e in d: #将字典中值即每一图层对应的多段线列表进行复制并移动到指定位置\\r\\n newdict[e]=polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist)) \\r\\n #newdict.append([e,polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist))])\\r\\n dictlist.append(newdict) \\r\\n return (dictlist,ratiolist,eachrationumlist)\",\n \"def __resize_to_32x(input_data):\\n rate = 1\\n while min(input_data['img'].shape[:2])>736:\\n test_size = 736\\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\\n if True: # input_data['img'].shape[1] < 512:\\n rate = test_size / input_data['img'].shape[1]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': \\\"keep-aspect-ratio\\\", 'width': test_size}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n else:\\n if True: # input_data['img'].shape[0] < 512:\\n rate = test_size / input_data['img'].shape[0]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': test_size, 'width': \\\"keep-aspect-ratio\\\"}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\\n input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\\n p_row = 0\\n while True:\\n if (input_data['img'].shape[0] + p_row) % 32 == 0:\\n break\\n p_row += 1\\n p_col = 0\\n while True:\\n if (input_data['img'].shape[1] + p_col) % 32 == 0:\\n break\\n p_col += 1\\n\\n input_data['img'] = np.pad(input_data['img'], ((0, p_row), (0, p_col), (0, 0)), mode='constant')\\n\\n return input_data\",\n \"def resize_function(input):\\n\\n from keras.backend import tf as ktf\\n return ktf.image.resize_images(input, (64, 64))\",\n \"def registerDepthFrame(self, frame):\\n h, w = frame.shape[:2]\\n frame = cv2.warpAffine(frame,self.depth2rgb_affine,(w,h))\\n\\n return frame\",\n \"def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\\n\\n def get_states(start):\\n frontier = [start]\\n frontier_set = {start}\\n explored = set()\\n\\n states = [False for _ in range(len(depths))]\\n while not all(states):\\n node = frontier.pop(0)\\n frontier_set.remove(node)\\n explored.add(node)\\n\\n children = node.get_children()\\n\\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\\n # produced from the parent by the same action) produced at a certain depth will always be selected,\\n # and children produced by other actions will never be selected\\n shuffle(children)\\n\\n for child in children:\\n if child not in frontier_set and child not in explored:\\n frontier_set.add(child)\\n frontier.append(child)\\n child.path_cost = node.path_cost+1\\n index = depths.index(child.path_cost) if child.path_cost in depths else None\\n if index is not None and not states[index]:\\n states[index] = {'start': start.sequence, 'end': child.sequence}\\n\\n return states\\n\\n depth_sample = [[] for depth in range(len(depths))]\\n\\n for _ in range(num_samples):\\n start = list(range(1,n+2))\\n shuffle(start)\\n start = PuzzleState(start, path_cost=0)\\n\\n states = get_states(start)\\n print('\\\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\\n list(map(list.append, depth_sample, states))\\n\\n return depth_sample\",\n \"def upscale(x, n):\\n if n == 1:\\n return x\\n x_shape = tf.shape(x)\\n height, width = x_shape[1], x_shape[2]\\n return tf.image.resize_nearest_neighbor(x, [n * height, n * width])\\n # return tf.batch_to_space(tf.tile(x, [n**2, 1, 1, 1]), [[0, 0], [0, 0]], n)\",\n \"def sample(self, size=1):\\n pass\",\n \"def __init__(self,\\n name,\\n input_size,\\n state_size):\\n self._input_size = input_size\\n self._state_size = state_size\\n super(GRU, self).__init__(name)\",\n \"def resize(final_grid, alpha, beta):\\n # init the filter before resize\\n adjusted = cv2.convertScaleAbs(final_grid, alpha, beta)\\n sharpen_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])\\n sharpen = cv2.filter2D(final_grid, -1, sharpen_kernel)\\n\\n # resize the map to the wanted size\\n map_w_border_row = WIDTH_G + 2\\n map_w_border_col = LENGTH_G + 2\\n vis_map = cv2.resize(sharpen, (map_w_border_col, map_w_border_row), cv2.INTER_AREA)\\n return vis_map\",\n \"def _get_depth_map_scale_subfolder(self):\\n if self.im_scale <= 0.25:\\n if self.im_scale <= 0.125:\\n return \\\"Depth/0.125/\\\"\\n else:\\n return \\\"Depth/0.25/\\\"\\n else: \\n return \\\"Depth/\\\"\",\n \"def reconstructed_data(self):\\n try:\\n data = np.sum(\\n np.array([\\n self.partial_reconstructed_data(i)\\n for i in range(self._max_level)\\n ]),\\n axis=0)\\n except MemoryError:\\n data = np.array(self.partial_reconstructed_data(0))\\n for i in range(1, self._max_level):\\n data = np.sum([data,\\n np.array(self.partial_reconstructed_data(i))], axis=0)\\n return data\",\n \"def positions(self, tileID, numSamples):\",\n \"def layers_sizes(self):\\n return iter([self.delta_h*l for l in range(int(self.h/self.delta_h)-1)])\",\n \"def _read_IntM_from_pdata(p_data, out_size=None, cam_id=2):\\n\\n # IntM = np.zeros((4,4))\\n raw_img_size = p_data.get_cam2(0).size if cam_id == 2 else p_data.get_cam3(0).size\\n width = int(raw_img_size[0])\\n height = int(raw_img_size[1])\\n IntM = p_data.calib.K_cam2 if cam_id == 2 else p_data.calib.K_cam3\\n focal_length = np.mean([IntM[0, 0], IntM[1, 1]])\\n h_fov = math.degrees(math.atan(IntM[0, 2] / IntM[0, 0]) * 2)\\n v_fov = math.degrees(math.atan(IntM[1, 2] / IntM[1, 1]) * 2)\\n\\n if out_size is not None: # the depth map is re-scaled #\\n camera_intrinsics = np.zeros((3, 3))\\n pixel_width, pixel_height = out_size[0], out_size[1]\\n camera_intrinsics[2, 2] = 1.\\n camera_intrinsics[0, 0] = IntM[0, 0] # (pixel_width/2.0)/math.tan(math.radians(h_fov/2.0))\\n camera_intrinsics[0, 2] = (pixel_width - 1)/2.0\\n camera_intrinsics[1, 1] = IntM[1, 1] # (pixel_height/2.0)/math.tan(math.radians(v_fov/2.0))\\n camera_intrinsics[1, 2] = (pixel_height - 1) /2.0\\n\\n IntM = camera_intrinsics\\n focal_length = pixel_width / width * focal_length\\n width, height = pixel_width, pixel_height\\n\\n\\n # In scanenet dataset, the depth is perperdicular z, not ray distance #\\n pixel_to_ray_array = View.normalised_pixel_to_ray_array(width=width, height=height,\\n hfov=h_fov, vfov=v_fov, normalize_z=True)\\n\\n pixel_to_ray_array_2dM = np.reshape(np.transpose( pixel_to_ray_array, axes=[2, 0, 1]), [3, -1])\\n pixel_to_ray_array_2dM = torch.from_numpy(pixel_to_ray_array_2dM.astype(np.float32))\\n cam_intrinsic = {\\n 'hfov': h_fov, 'vfov': v_fov,\\n 'unit_ray_array': pixel_to_ray_array,\\n 'unit_ray_array_2D': pixel_to_ray_array_2dM,\\n 'focal_length': focal_length,\\n 'intrinsic_M': IntM} \\n return cam_intrinsic\",\n \"def _resize(self, new_capacity):\\n temp_array = self.make_array(new_capacity)\\n for i in range(self.n):\\n temp_array[i] = self.original_array[i]\\n self.original_array = temp_array\\n self.capacity = new_capacity\",\n \"def __init__(self):\\n self.VideoFrame = np.array([])\\n self.DepthFrameRaw = np.array([]).astype(np.uint16)\\n \\\"\\\"\\\" Extra arrays for colormaping the depth image\\\"\\\"\\\"\\n self.DepthFrameHSV = np.zeros((480, 640, 3)).astype(np.uint8)\\n self.DepthFrameRGB = np.array([])\\n\\n \\\"\\\"\\\"initialize kinect & turn off auto gain and whitebalance\\\"\\\"\\\"\\n freenect.sync_get_video_with_res(resolution=freenect.RESOLUTION_HIGH)\\n # print(freenect.sync_set_autoexposure(False))\\n freenect.sync_set_autoexposure(False)\\n # print(freenect.sync_set_whitebalance(False))\\n freenect.sync_set_whitebalance(False)\\n \\\"\\\"\\\"check depth returns a frame, and flag kinectConnected\\\"\\\"\\\"\\n if(freenect.sync_get_depth_with_res(format=freenect.DEPTH_11BIT) == None):\\n self.kinectConnected = False\\n else:\\n self.kinectConnected = True\\n\\n # mouse clicks & calibration variables\\n self.depth2rgb_affine = np.array(list(csv.reader(open(\\\"depth2rgb_affine.cfg\\\"))), dtype=float)\\n self.kinectCalibrated = False\\n self.last_click = np.array([0, 0])\\n self.new_click = False\\n self.rgb_click_points = np.zeros((5, 2), int)\\n self.depth_click_points = np.zeros((5, 2), int)\\n\\n \\\"\\\"\\\" block info \\\"\\\"\\\"\\n self.block_contours = np.array([])\\n self.block_detections = np.array([])\\n\\n \\\"\\\"\\\"camera calibration\\\"\\\"\\\"\\n self.cam_int_mat = [] # np.array([])\\n self.cam_ext_mat = []\\n self.dist_coeffs = []\\n\\n \\\"\\\"\\\"depth info\\\"\\\"\\\"\\n self.max_depth = 0.95\\n self.affine_transform = False\",\n \"def _reshape(self, data):\\n\\n\\t\\t\\td = np.zeros((32,32,3))\\n\\t\\t\\td_r = data[0:1024].reshape(32,32)\\n\\t\\t\\td_g = data[1024:2048].reshape(32,32)\\n\\t\\t\\td_b = data[2048:].reshape(32,32)\\n\\n\\t\\t\\tfor h in range(32):\\n\\t\\t\\t for w in range(32):\\n\\t\\t\\t for c in range(3):\\n\\n\\t\\t\\t if c == 0 : d[h,w,c] = d_r[h,w]\\n\\t\\t\\t elif c == 1 : d[h,w,c] = d_g[h,w]\\n\\t\\t\\t else : d[h,w,c] = d_b[h,w]\\n\\n\\t\\t\\tarray = np.array(d, dtype=np.uint8)\\n\\t\\t\\timg = Image.fromarray(array)\\n\\t\\t\\ttemp = img.resize(size = (64,64))\\n\\t\\t\\td = image.img_to_array(temp)\\n\\n\\t\\t\\t#plt.imshow(d)\\n\\t\\t\\t#plt.show()\\n\\t\\t\\treturn d\",\n \"def registerDepthFrame(self, frame):\\n frame = cv2.warpAffine(frame, self.depth2rgb_affine,\\n (frame.shape[1], frame.shape[0]))\\n return frame\",\n \"def zoom_to_size(self, *p):\\n\\t\\tif self.image is None or self.allocation is None:\\n\\t\\t\\treturn\\n\\t\\tif __debug__: print self.allocation.width, self.image.get_width()\\n\\t\\tif __debug__: print self.allocation.width, self.image.get_width(), self.allocation.width/self.image.get_width()\\n\\t\\tz = min(\\n\\t\\t\\tself.allocation.width/self.image.get_width(),\\n\\t\\t\\tself.allocation.height/self.image.get_height()\\n\\t\\t\\t)\\n\\t\\tif __debug__: print \\\"zoom_to_size\\\", \\\"z=\\\", z\\n\\t\\tself.zoom = z\",\n \"def resizeGL(self,Width,Height):\\n return\",\n \"def getDimensions():\",\n \"def _set_z_size(self):\\n self._level_gen.size = (self._level_gen.size[X],\\n self._level_gen.size[Y],\\n self._level_size_z_spinbox.value())\\n self._refresh_view()\",\n \"def generate_depth_image(self, cloud):\\n points = self.get_hand_points(cloud)\\n\\n im1 = self.compute_height_map(points, 2)\\n im2 = self.compute_height_map(points, 1)\\n im3 = self.compute_height_map(points, 0)\\n\\n im1 = grey_dilation(im1, size=3)\\n im2 = grey_dilation(im2, size=3)\\n im3 = grey_dilation(im3, size=3)\\n\\n self.image = np.stack((im1, im2, im3), 0)\",\n \"def _convert_to_depth(self, dist):\\n return self.dist_to_bottom - dist\",\n \"def _shrink(values, last_dim, reduction_factor):\\n\\n shape = tf.shape(values)\\n new_shape = [\\n shape[0],\\n shape[1] // reduction_factor,\\n last_dim * reduction_factor\\n ]\\n values = tf.reshape(values, new_shape)\\n return values\",\n \"def __init__(self, size: int):\\n self.size = size\\n self.window = []\",\n \"def _conv_filter(state_dict, patch_size=16):\\n out_dict = {}\\n for k, v in state_dict.items():\\n if 'patch_embed.proj.weight' in k:\\n v = v.reshape((v.shape[0], 3, patch_size, patch_size))\\n out_dict[k] = v\\n return out_dict\",\n \"def _get_state_sizes(self):\\n ds = self.builder.nodes[self.ds_inputs[0]]\\n return [[ds.xdim]]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6337556","0.58340174","0.58162516","0.5748601","0.5645124","0.558781","0.55794656","0.5574537","0.5515735","0.5503842","0.5475208","0.54662806","0.546386","0.54406154","0.5417694","0.5378523","0.5363706","0.5360747","0.53576624","0.5348146","0.5339047","0.53314734","0.53257746","0.5320312","0.53154093","0.5297349","0.52937376","0.52880275","0.5271779","0.52661616","0.5252537","0.52520776","0.52445424","0.52366596","0.5231084","0.5219759","0.52132565","0.5211054","0.52066946","0.51881194","0.51876265","0.5180839","0.51596195","0.51545733","0.51527065","0.5152692","0.5151207","0.51484764","0.51484764","0.51464796","0.5146267","0.5141789","0.5123416","0.512339","0.51172245","0.5116021","0.51147646","0.5105741","0.5105144","0.5104161","0.5104069","0.5101356","0.51010346","0.5090911","0.5082009","0.50783074","0.50666076","0.5062282","0.50602657","0.5048662","0.50466317","0.50302684","0.5019892","0.5017012","0.5011147","0.50015306","0.49970916","0.49952757","0.49897617","0.49855056","0.4984619","0.49845567","0.49843636","0.4983274","0.4972647","0.49714375","0.49641496","0.4954373","0.49532208","0.49489912","0.4947661","0.4944356","0.4941341","0.49396676","0.4937595","0.4936694","0.49346015","0.49341375","0.49320462","0.4927108","0.492432"],"string":"[\n \"0.6337556\",\n \"0.58340174\",\n \"0.58162516\",\n \"0.5748601\",\n \"0.5645124\",\n \"0.558781\",\n \"0.55794656\",\n \"0.5574537\",\n \"0.5515735\",\n \"0.5503842\",\n \"0.5475208\",\n \"0.54662806\",\n \"0.546386\",\n \"0.54406154\",\n \"0.5417694\",\n \"0.5378523\",\n \"0.5363706\",\n \"0.5360747\",\n \"0.53576624\",\n \"0.5348146\",\n \"0.5339047\",\n \"0.53314734\",\n \"0.53257746\",\n \"0.5320312\",\n \"0.53154093\",\n \"0.5297349\",\n \"0.52937376\",\n \"0.52880275\",\n \"0.5271779\",\n \"0.52661616\",\n \"0.5252537\",\n \"0.52520776\",\n \"0.52445424\",\n \"0.52366596\",\n \"0.5231084\",\n \"0.5219759\",\n \"0.52132565\",\n \"0.5211054\",\n \"0.52066946\",\n \"0.51881194\",\n \"0.51876265\",\n \"0.5180839\",\n \"0.51596195\",\n \"0.51545733\",\n \"0.51527065\",\n \"0.5152692\",\n \"0.5151207\",\n \"0.51484764\",\n \"0.51484764\",\n \"0.51464796\",\n \"0.5146267\",\n \"0.5141789\",\n \"0.5123416\",\n \"0.512339\",\n \"0.51172245\",\n \"0.5116021\",\n \"0.51147646\",\n \"0.5105741\",\n \"0.5105144\",\n \"0.5104161\",\n \"0.5104069\",\n \"0.5101356\",\n \"0.51010346\",\n \"0.5090911\",\n \"0.5082009\",\n \"0.50783074\",\n \"0.50666076\",\n \"0.5062282\",\n \"0.50602657\",\n \"0.5048662\",\n \"0.50466317\",\n \"0.50302684\",\n \"0.5019892\",\n \"0.5017012\",\n \"0.5011147\",\n \"0.50015306\",\n \"0.49970916\",\n \"0.49952757\",\n \"0.49897617\",\n \"0.49855056\",\n \"0.4984619\",\n \"0.49845567\",\n \"0.49843636\",\n \"0.4983274\",\n \"0.4972647\",\n \"0.49714375\",\n \"0.49641496\",\n \"0.4954373\",\n \"0.49532208\",\n \"0.49489912\",\n \"0.4947661\",\n \"0.4944356\",\n \"0.4941341\",\n \"0.49396676\",\n \"0.4937595\",\n \"0.4936694\",\n \"0.49346015\",\n \"0.49341375\",\n \"0.49320462\",\n \"0.4927108\",\n \"0.492432\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88994,"cells":{"query":{"kind":"string","value":"resize input in order to produce sampled depth map"},"document":{"kind":"string","value":"def scale_mvs_camera(cams, scale=1):\n for view in range(FLAGS.view_num):\n cams[view] = scale_camera(cams[view], scale=scale)\n return cams"},"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 resized_map(self, new_size):\n\n new_map = cv2.resize(self.map.copy(), new_size)\n cur_count = np.sum(new_map)\n\n # Avoid dividing by zero\n if cur_count == 0:\n return new_map\n\n scale = self.count / cur_count\n new_map *= scale\n return new_map","def _reconstruct(self, num_samples=None):","def pixel_shuffle(input, upscale_factor, inplace=False):\n return FunctionLib.apply(\n 'DepthToSpace', input.device, [input],\n outputs=[input if inplace else None],\n block_size=int(upscale_factor), mode='CRD', data_format='NCHW')","def pixel_unshuffle(input, downscale_factor, inplace=False):\n return FunctionLib.apply(\n 'SpaceToDepth', input.device, [input],\n outputs=[input if inplace else None],\n block_size=int(downscale_factor), mode='CRD', data_format='NCHW')","def depth_rendering(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\n\n x_indices = np.arange(lf_size[1])\n y_indices = np.arange(lf_size[2])\n b_indices = np.arange(lf_size[0])\n\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\n\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\n stacked = np.stack(grid, 2)\n positions = stacked.reshape(-1, 2)\n\n # Compute the distance from each lf position from the reference view\n # Repeat the elements of this to match the size of the disparity map\n ref_pos = np.array(\n [lf_one_way // 2, lf_one_way // 2])\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\n\n\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\n\n # Compute the shifted pixels\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\n\n #indices for linear interpolation in a square around the central point\n x_low = np.around(x_shifted).astype(int)\n #x_high = x_low + 1\n\n y_low = np.around(y_shifted).astype(int)\n #y_high = y_low + 1\n\n #Place co-ordinates outside the image back into the image\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\n #x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\n #y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\n\n #Gather the interpolation points\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\n #interp_pts_2 = np.stack((x_low_clip, y_high_clip))\n #interp_pts_3 = np.stack((x_high_clip, y_low_clip))\n #interp_pts_4 = np.stack((x_high_clip, y_high_clip))\n\n #Index into the images\n desired_shape = lf_size\n res_1 = torch_big_sample(ref_view, interp_pts_1, desired_shape)\n return res_1\n res_2 = torch_big_sample(ref_view, interp_pts_2, desired_shape)\n res_3 = torch_big_sample(ref_view, interp_pts_3, desired_shape)\n res_4 = torch_big_sample(ref_view, interp_pts_4, desired_shape)\n\n #Compute interpolation weights\n x_low_f = x_low.astype(np.float32)\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\n d_x_high = 1.0 - d_x_low\n y_low_f = y_low.astype(np.float32)\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\n d_y_high = 1.0 - d_y_low\n\n w1 = torch.from_numpy(d_x_low * d_y_low)\n w2 = torch.from_numpy(d_x_low * d_y_high)\n w3 = torch.from_numpy(d_x_high * d_y_low)\n w4 = torch.from_numpy(d_x_high * d_y_high)\n\n #THEY AGREE AT THIS POINT\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape), res_1)\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape), res_2)\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape), res_3)\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape), res_4)\n\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\n torch.add(novel_view, weighted_4, out=novel_view)\n return novel_view","def init_map(self, size, random_data = False):\n heightmap = []\n\n if random_data:\n # random noise background\n for x in range(size):\n heightmap.append([])\n for y in range(size):\n heightmap[-1].append(random.random())\n else:\n # black background\n for x in range(size):\n heightmap.append([])\n for y in range(size):\n heightmap[-1].append(0.0)\n\n return heightmap","def reduceFrame(self, depth, height_ratio = 0.5, sub_sample = 0.3, reduce_to = 'lower'):\n if (height_ratio > 1.0) or (height_ratio < 0.0)\\\n or (sub_sample > 1.0) or (sub_sample < 0.0):\n print('height_ratio and sub_sample must be between 0 and 1')\n exit(1)\n \n depth_copy = depth.copy()\n height = depth_copy.shape[0]\n h = int(height_ratio*(height))\n cols_to_cut = 0\n\n # catches the case when all rows are kept\n if height_ratio == 1:\n d_short = depth_copy\n\n elif reduce_to == 'lower':\n d_short = depth_copy[(height - h):,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'middle_lower':\n upper_brdr = int(3*(height/4.0) - h/2)\n lower_brdr = upper_brdr + h\n d_short = depth_copy[upper_brdr:lower_brdr,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'middle':\n upper_brdr = int((height - h)/2.0)\n lower_brdr = upper_brdr + h\n d_short = depth_copy[upper_brdr:lower_brdr,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'middle_upper':\n upper_brdr = int((height/4.0) - h/2)\n lower_brdr = upper_brdr + h\n d_short = depth_copy[upper_brdr:lower_brdr,\\\n cols_to_cut:-(cols_to_cut+1)]\n\n elif reduce_to == 'upper':\n d_short = depth_copy[:h, cols_to_cut:-(cols_to_cut+1)]\n\n d_short[d_short <= 0] = np.nan\n d_short[d_short > self.max_depth] = np.nan\n \n rescaled = rescale(d_short, sub_sample, mode='reflect', multichannel=False, anti_aliasing=True)\n\n return rescaled","def gen_depth_data(scan_folder, dst_folder, normalize=False):\n # specify the goal folder\n dst_folder = os.path.join(dst_folder, 'depth')\n try:\n os.stat(dst_folder)\n print('generating depth data in: ', dst_folder)\n except:\n print('creating new depth folder: ', dst_folder)\n os.mkdir(dst_folder)\n \n # load LiDAR scan files\n scan_paths = load_files(scan_folder)\n\n depths = []\n \n # iterate over all scan files\n for idx in range(len(scan_paths)):\n # load a point cloud\n current_vertex = np.fromfile(scan_paths[idx], dtype=np.float32)\n current_vertex = current_vertex.reshape((-1, 4))\n \n proj_range, _, _, _ = range_projection(current_vertex)\n \n # normalize the image\n if normalize:\n proj_range = proj_range / np.max(proj_range)\n \n # generate the destination path\n dst_path = os.path.join(dst_folder, str(idx).zfill(6))\n \n # save the semantic image as format of .npy\n np.save(dst_path, proj_range)\n depths.append(proj_range)\n print('finished generating depth data at: ', dst_path)\n\n return depths","def __init__(self):\n \tself.transposition = {}\n \tself.currentDepthLimit = 0\n\tself.counter = 0\t\n pass","def keepsize(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\n\n def residual(inputs, n_filters):\n x = ReflectionPadding2D()(inputs)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = Activation(activation)(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, inputs])\n\n return x\n\n inputs = Input(shape=(nx, ny, 1))\n x = GaussianNoise(noise)(inputs)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x0 = Activation(activation)(x)\n\n x = residual(x0, n_filters)\n\n for i in range(depth-1):\n x = residual(x, n_filters)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, x0])\n\n# Upsampling for superresolution\n x = UpSampling2D()(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = Activation(activation)(x)\n\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n\n return Model(inputs=inputs, outputs=final)","def infer_depths(self):\n self.infer_depths_edges_from_cells()\n self.infer_depths_cells_from_edges()\n self.copy_depths_to_subgrid(depth_stat='depth_mean')","def upsample(x, name, size):\n with tf.name_scope(name):\n outputs = tf.image.resize_bilinear(x, size)\n # Return layer's output\n return outputs","def _build(self, inputs):\n\n # calculate how many slots we need from the 3 dimensions of the incoming conv layer (filter w/h plus depth)\n dims = inputs.get_shape().as_list()\n new_dim = 1\n for d in dims[1:]: # leave first axis as is (batch)\n new_dim = new_dim * d # multiply 'em up\n return tf.reshape(inputs, [-1, new_dim]) # -1=keep this dimension as is (it could be anything as this is the number of samples) and flatten the others","def prepare_cnn_entries(X,n_nodes=100):\n idx = X[:,:,0] > 0\n X_nozeros = X[idx]\n min_X = np.min(X_nozeros[:,0])\n max_X = np.max(X_nozeros[:,0])\n del X_nozeros\n gc.collect() \n\n \n \n wavelength_all,step = np.linspace(min_X,max_X, num=n_nodes,retstep=True)\n #wavelength_edges = np.histogram_bin_edges(wavelength_all,bins=n_nodes)\n\n X_new = [[[] for i in range(n_nodes)] for j in range(X.shape[0])]\n\n \n print('Start converting to discrete wavelength inputs...')\n for i in range(X.shape[0]):\n if(i % int(X.shape[0] / 10) == 0):\n print('Part 1.... ' + str(round(100*i/X.shape[0],0)) + ' % completed')\n for j in range(X.shape[1]):\n if(X[i,j,0]>0):\n X_new[i][int((X[i,j,0] - min_X) / step)].append(X[i,j,1])\n #print(X_new[i][int((X[i,j,0] - min_X) / step)])\n \n #del X\n gc.collect()\n \n X_new = np.array(X_new)\n print(np.count_nonzero(X_new))\n \n for i in range(X_new.shape[0]):\n if(i % int(X_new.shape[0] / 10) == 0):\n print('Part 2.... ' + str(round(100*i/X_new.shape[0])) + ' % completed')\n for j in range(X_new.shape[1]):\n X_new[i,j] = np.array(X_new[i,j])\n if(X_new[i,j].size > 0):\n X_new[i,j] = np.mean(np.array(X_new[i,j]))\n else:\n X_new[i,j] = 0.\n \n print(np.count_nonzero(X_new))\n \n return X_new","def densMap(fit, metricArray, n, overlap, imageSize, imageName):\n \n if True: #Make true if you want to calculate densities (i.e. if you have a new fit/new density list) \n print 'calculating densities'\n if type(fit)==sklearn.gaussian_process.gaussian_process.GaussianProcess: #If the fit is Gaussian\n densities, MSE = fit.predict(metricArray, eval_MSE =True)\n sigma = numpy.sqrt(MSE)\n print(sigma)\n else:\n densities = fit.predict(metricArray) #Use the ML fit to predict the density for each tile \n #print len(densities)\n f = open('densities.txt', 'w')\n print >> f, list(densities)\n f.close()\n else: \n f = open('densities.txt', 'r')\n data = f.read()\n densities = eval(data)\n # print densities\n densities = numpy.array(densities)\n f.close()\n imageName = 'FirstStitchLong.jpg'\n overlap = 0.2 \n n = 50\n image = Image.open(imageName) #open the image\n imageSize = image.size #get the image size \n # print 'Image Size is ', imageSize\n \n\n width = imageSize[0] \n height = imageSize[1] \n # print 'width ', width \n #print 'height ', height\n overlapSize = int(overlap*n)\n rowTiles = int((width-n)/(overlapSize))+1\n print 'Row Tiles is ', rowTiles\n #colTiles = int(((height-n)/(overlapSize))+1)\n \n \n # newArray = numpy.zeros((int((width-n)/(overlapSize)+1),int(((height-n)/(overlapSize))+1)))\n \n #newArray = numpy.zeros(width, height)\n #print newArray\n points = []\n for i in range(len(densities)):\n x = (i%rowTiles)*overlapSize + n/2\n y = (i/rowTiles)*overlapSize + n/2\n points += [[x,y]]\n # newArray[i%(rowTiles),i/(rowTiles)] = densities[i]\n # newArray[(i%(rowTiles)+1)*(n/2) , (i/(rowTiles)+1)*(n/2)] = densities[i]\n # points += [[(i%(rowTiles)+1)*(n/2), (i/(rowTiles)+1)*(n/2)]] #Consider the density to be at the center of each tile \n # print points\n grid_x, grid_y = numpy.mgrid[0:width, 0:height] #create a meshgrid \n \n # print densities\n # print('Points is ', points) \n # print('Densities is ', densities)\n data = griddata(points, densities, (grid_x, grid_y), method = 'linear') #interpolate to get continuous function of points \n #can change interpolation method\n print data.size\n\n # print 'Max is ', numpy.amax(data)\n # min_max_scaler = sklearn.preprocessing.MinMaxScaler()\n #data_minmax = min_max_scaler.fit_transform(data) \n \n \n \n ##Plotting \n plt.figure(1)\n \n #plt.figure(figsize = (width, height))\n # print \"Hi Cassie\"\n v = numpy.linspace(min(densities), max(densities), 20, endpoint=True)\n fig = plt.contourf(grid_x, grid_y, data, levels = v, alpha = 0.4, antialiased = True)\n \n mapIm = Image.open(imageName)\n plt.imshow(mapIm)\n maxDens = max(densities)\n print maxDens \n x = plt.colorbar(fig) \n plt.savefig('ContourPlot.jpg')\n return data","def glimpseSensor(img, normLoc, minRadius=4, depth=1, sensorBandwidth=12):\n input_shape = img.get_shape().as_list()\n img_size = input_shape[1]\n loc = tf.round(((normLoc + 1) / 2.0) * img_size)\n loc = tf.cast(loc, tf.int32)\n zooms = []\n for k in range(batch_size):\n imgZooms = []\n one_img = img[k, :, :, :]\n max_radius = minRadius * (2**(depth - 1))\n offset = 2 * max_radius\n one_img = tf.image.pad_to_bounding_box(one_img, offset, offset, max_radius * 4 + img_size,\n max_radius * 4 + img_size)\n\n for i in range(depth):\n r = int(minRadius * (2**(i)))\n d_raw = 2 * r\n d = tf.constant(d_raw, shape=[1])\n d = tf.tile(d, [2])\n loc_k = loc[k, :]\n adjusted_loc = offset + loc_k - r\n one_img2 = tf.reshape(\n one_img, (one_img.get_shape()[0].value, one_img.get_shape()[1].value, input_shape[3]))\n zoom = tf.slice(one_img2, adjusted_loc, d)\n zoom = tf.image.resize_bilinear(\n tf.reshape(zoom, (1, d_raw, d_raw, nput_shape[3])), (sensorBandwidth, sensorBandwidth))\n zoom = tf.reshape(zoom, (sensorBandwidth, sensorBandwidth, input_shape[3]))\n imgZooms.append(zoom)\n\n zooms.append(tf.stack(imgZooms))\n\n return tf.stack(zooms)","def keepsize_256(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\n\n def residual(inputs, n_filters):\n x = ReflectionPadding2D()(inputs)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = Activation(activation)(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, inputs])\n\n return x\n\n inputs = Input(shape=(nx, ny, 1))\n x = GaussianNoise(noise)(inputs)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x0 = Activation(activation)(x)\n\n x = residual(x0, n_filters)\n\n for i in range(depth-1):\n x = residual(x, n_filters)\n\n x = ReflectionPadding2D()(x)\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = BatchNormalization()(x)\n x = add([x, x0])\n\n# Upsampling for superresolution\n x = UpSampling2D()(x)\n x = ReflectionPadding2D()(x)\n x = Conv2D(4*n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n x = Activation(activation)(x)\n\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\n\n return Model(inputs=inputs, outputs=final)","def update_dimensions(self):\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\n dtype=\"int16\")","def __init__(self, width, height, circular=True):\n self.width = width\n self.height = height\n self.size = width * height\n self.idx_list = []\n self._depth_buffer = [[] for _ in range(self.size)]\n self._depth = [0] * self.size\n self.circular = circular","def __init__(self):\n self.size = 1000\n self.mapArray = [None] * self.size","def rebuild(self):\n self.from_samples(self.samples)","def resize_lightfield(raw_lightfield, desired_size): # -> lightfield\n if raw_lightfield.ndim == 6:\n n_depth, n_cols, n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_depth, n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n\n for k, depth in enumerate(raw_lightfield):\n for i, row in enumerate(depth):\n for j, image_data in enumerate(row):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[k, i, j] = resized_image_data\n elif raw_lightfield.ndim == 5:\n n_cols, n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n\n for i, row in enumerate(raw_lightfield):\n for j, image_data in enumerate(row):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[i, j] = resized_image_data\n \n elif raw_lightfield.ndim == 4:\n n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n for j, image_data in enumerate(raw_lightfield):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[j] = resized_image_data\n \n return output_lightfield","def _build_depth_graph(self):\n self.depth_net = DepthNetwork(self.cfg.STRUCTURE, is_training=False)\n images = self.images_placeholder[tf.newaxis]\n poses = self.poses_placeholder[tf.newaxis]\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\n\n # fix the input shape\n images = tf.reshape(images, [1, 5, 192, 1088, 3])\n Ts = VideoSE3Transformation(matrix=poses)\n\n depths = self.depth_net.forward(Ts, images, intrinsics)\n self.outputs['depths'] = depths","def on_depth_image(self, depth_image):\n depth_image = depth_image.copy()\n mask = np.where(self.depth != 0)\n depth_image[mask] = self.depth[mask]\n return depth_image","def _resize(self, cap):\n old = self._data\n self._data = [None] * cap\n walk = self._front\n for i in range(self._size):\n self._data[i] = old[walk]\n walk = (walk + 1) % len(old)\n self._front = 0","def __init__(self, d=1):\r\n self.depth = d","def depr_depth_images(self):\n if not hasattr(self, '_depr_depth_images'):\n depth_images = self._archive['gaps_depth']\n self._depr_depth_images = depth_images.reshape([1, 20, 224, 224, 1])\n return self._depr_depth_images","def upsampleImage( arr, kernelSize ):\n return scipy.ndimage.zoom( arr, kernelSize )","def __resize_to_512(input_data):\n test_size = 720\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\n axis=-1))\n for contour in contours] for contours in input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\n axis=-1)) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * 512 / input_data['img'].shape[0]),\n np.cast['int32'](point[1] * 512 / input_data['img'].shape[1]))\n for point in input_data['center_point']]\n\n seq = iaa.Sequential([\n iaa.Scale({'height': 512, 'width': 512}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n return input_data","def _preallocate_samples(self):\n self.prealloc_samples_ = []\n for _ in range(self.num_prealloc_samples_):\n self.prealloc_samples_.append(self.sample())","def downsample_sam(self, factor):","def __resize_512p(input_data):\n rate = 1\n test_size=512\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\n if True: # input_data['img'].shape[1] < 512:\n rate = test_size / input_data['img'].shape[1]\n seq = iaa.Sequential([\n iaa.Scale({'height': \"keep-aspect-ratio\", 'width': test_size}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n else:\n if True: # input_data['img'].shape[0] < 512:\n rate = test_size / input_data['img'].shape[0]\n seq = iaa.Sequential([\n iaa.Scale({'height': test_size, 'width': \"keep-aspect-ratio\"}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\n input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\n return input_data","def main():\n\n ##############################\n # Options\n ##############################\n # Validation set\n input_depth_dir = os.path.expanduser(\n '~/Kitti/depth/train')\n data_split = 'val'\n\n # Test set\n # input_depth_dir = os.path.expanduser(\n # '~/Kitti/depth/depth_selection/test_depth_completion_anonymous/velodyne_raw')\n # data_split = 'test'\n\n # Fast fill with Gaussian blur @90Hz (paper result)\n fill_type = 'fast'\n extrapolate = True\n blur_type = 'gaussian'\n\n # Fast Fill with bilateral blur, no extrapolation @87Hz (recommended)\n # fill_type = 'fast'\n # extrapolate = False\n # blur_type = 'bilateral'\n\n # Multi-scale dilations with extra noise removal, no extrapolation @ 30Hz\n # fill_type = 'multiscale'\n # extrapolate = False\n # blur_type = 'bilateral'\n\n # Save output to disk or show process\n save_output = True\n\n ##############################\n # Processing\n ##############################\n if save_output:\n # Save to Disk\n show_process = False\n save_depth_maps = True\n else:\n if fill_type == 'fast':\n raise ValueError('\"fast\" fill does not support show_process')\n\n # Show Process\n show_process = True\n save_depth_maps = False\n\n # Create output folder\n this_file_path = os.path.dirname(os.path.realpath(__file__))\n outputs_dir = this_file_path + '/outputs'\n os.makedirs(outputs_dir, exist_ok=True)\n\n output_folder_prefix = 'depth_' + data_split\n output_list = sorted(os.listdir(outputs_dir))\n if len(output_list) > 0:\n split_folders = [folder for folder in output_list\n if folder.startswith(output_folder_prefix)]\n if len(split_folders) > 0:\n last_output_folder = split_folders[-1]\n last_output_index = int(last_output_folder.split('_')[-1])\n else:\n last_output_index = -1\n else:\n last_output_index = -1\n output_depth_dir = outputs_dir + '/{}_{:03d}'.format(\n output_folder_prefix, last_output_index + 1)\n\n if save_output:\n if not os.path.exists(output_depth_dir):\n os.makedirs(output_depth_dir)\n else:\n raise FileExistsError('Already exists!')\n print('Output dir:', output_depth_dir)\n\n # Get images in sorted order\n # images_to_use = sorted(glob.glob(input_depth_dir + '/*'))\n\n # Rolling average array of times for time estimation\n avg_time_arr_length = 10\n last_fill_times = np.repeat([1.0], avg_time_arr_length)\n last_total_times = np.repeat([1.0], avg_time_arr_length)\n\n images_to_use = []\n saved_path = []\n folder_path =\"./data_depth_selection/depth_selection/test_depth_completion_anonymous/velodyne_raw\"\n for img_name in os.listdir(folder_path):\n img_path = os.path.join(folder_path,img_name)\n saved_path_name = os.path.join(\"./output\", img_name)\n saved_path.append(saved_path_name)\n images_to_use.append(img_path)\n # if \"output\" not in os.listdir(\"Kitti/depth/\"):\n # os.mkdir(\"Kitti/depth/output\")\n # os.mkdir(\"output\")\n # for folder in os.listdir(folder_path):\n # # os.mkdir(\"./output/\"+folder)\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\")\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\")\n\n # inside_folder_path = folder_path + \"/\" + folder+\"/2011_09_26/\"+folder+\"/\"\n # for img_folder in os.listdir(inside_folder_path):\n # print((\"/output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder))\n # # os.mkdir(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder)\n # print(inside_folder_path + img_folder)\n # # os.mkdir(\"Kitti/depth/output/\"+folder+\"/proj_depth/groundtruth/\"+img_folder)\n # img_path = inside_folder_path + img_folder+\"/data\"\n # try:\n # print(\"............................................................\",\"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder)\n # depth_image_folder = os.listdir(\"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder)\n # # print(depth_image_folder)\n # for img in os.listdir(img_path):\n # # image_path = +\"/\"+img\n # # print(img)\n # if img in depth_image_folder:\n # # print(\"aaya\")\n # depth_image_path = \"./depth_images/train/\" + folder + \"/proj_depth/groundtruth/\"+img_folder+\"/\"+img\n # images_to_use.append(depth_image_path)\n # saved_path.append(\"./output/\"+folder+\"/2011_09_26/\"+folder+\"/\"+img_folder+\"/\"+img)\n # except Exception:\n # print(\"folder nahi hai\")\n \n images_to_use = np.array(images_to_use)\n \n num_images = len(images_to_use)\n\n print(len(images_to_use))\n\n\n for i in range(num_images):\n\n depth_image_path = images_to_use[i]\n\n # Calculate average time with last n fill times\n avg_fill_time = np.mean(last_fill_times)\n avg_total_time = np.mean(last_total_times)\n\n # Show progress\n sys.stdout.write('\\rProcessing {} / {}, '\n 'Avg Fill Time: {:.5f}s, '\n 'Avg Total Time: {:.5f}s, '\n 'Est Time Remaining: {:.3f}s'.format(\n i, num_images - 1, avg_fill_time, avg_total_time,\n avg_total_time * (num_images - i)))\n sys.stdout.flush()\n\n # Start timing\n start_total_time = time.time()\n print(depth_image_path)\n # Load depth projections from uint16 image\n depth_image = cv2.imread(depth_image_path, cv2.IMREAD_ANYDEPTH)\n projected_depths = np.float32(depth_image / 256.0)\n\n # Fill in\n start_fill_time = time.time()\n if fill_type == 'fast':\n final_depths = depth_map_utils.fill_in_fast(\n projected_depths, extrapolate=extrapolate, blur_type=blur_type)\n elif fill_type == 'multiscale':\n final_depths, process_dict = depth_map_utils.fill_in_multiscale(\n projected_depths, extrapolate=extrapolate, blur_type=blur_type,\n show_process=show_process)\n else:\n raise ValueError('Invalid fill_type {}'.format(fill_type))\n end_fill_time = time.time()\n\n # Display images from process_dict\n if fill_type == 'multiscale' and show_process:\n img_size = (570, 165)\n\n x_start = 80\n y_start = 50\n x_offset = img_size[0]\n y_offset = img_size[1]\n x_padding = 0\n y_padding = 28\n\n img_x = x_start\n img_y = y_start\n max_x = 1900\n\n row_idx = 0\n for key, value in process_dict.items():\n\n image_jet = cv2.applyColorMap(\n np.uint8(value / np.amax(value) * 255),\n cv2.COLORMAP_JET)\n vis_utils.cv2_show_image(\n key, image_jet,\n img_size, (img_x, img_y))\n\n img_x += x_offset + x_padding\n if (img_x + x_offset + x_padding) > max_x:\n img_x = x_start\n row_idx += 1\n img_y = y_start + row_idx * (y_offset + y_padding)\n\n # Save process images\n cv2.imwrite('process/' + key + '.png', image_jet)\n\n cv2.waitKey()\n\n # Save depth images to disk\n if save_depth_maps:\n depth_image_file_name = depth_image_path.split(\"/\")\n # print(depth_image_file_name)\n file_path = \"\"\n print(len(depth_image_file_name))\n # for i in range(8):\n # if(i == 2):\n # file_path = os.path.join(file_path, \"output\")\n # else:\n # file_path = os.path.join(file_path, depth_image_file_name[i])\n # cv2.imwrite(file_path, depth_image)\n # print(\"check.............................\",saved_path[i])\n # with open(saved_path[i],'r') as f:\n # print(\"badhiya\") \n depth_image = (final_depths * 256)\n # plt.imsave(saved_path[i],depth_image)\n # cv2.imwrite(saved_path[i], depth_image)\n # print(saved_path[i])\n # cv2.imwrite(\"/media/pankaj/Elements/ip_basic\"+saved_path[i], depth_image)\n \n try:\n with open(saved_path[i], 'wb') as f:\n depth_image = (final_depths * 256).astype(np.uint16)\n\n writer = png.Writer(width=depth_image.shape[1],\n height=depth_image.shape[0],\n bitdepth=16,\n greyscale=True)\n writer.write(f, depth_image)\n except Exception:\n print(\"nikl.............\")\n\n end_total_time = time.time()\n\n # Update fill times\n last_fill_times = np.roll(last_fill_times, -1)\n last_fill_times[-1] = end_fill_time - start_fill_time\n\n # Update total times\n last_total_times = np.roll(last_total_times, -1)\n last_total_times[-1] = end_total_time - start_total_time","def Resize(self):\n\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\n self.FreshStart()","def reset_map(self):\n self.x = None\n self.X = None\n self.y = None\n self.Y = None\n self.data = None\n self.sampling = None\n self.size = None","def depth_rendering_gpu(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\n\n x_indices = np.arange(lf_size[1])\n y_indices = np.arange(lf_size[2])\n b_indices = np.arange(lf_size[0])\n\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\n\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\n stacked = np.stack(grid, 2)\n positions = stacked.reshape(-1, 2)\n\n # Compute the distance from each lf position from the reference view\n # Repeat the elements of this to match the size of the disparity map\n ref_pos = np.array(\n [lf_one_way // 2, lf_one_way // 2])\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\n\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\n\n # Compute the shifted pixels\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\n\n #indices for linear interpolation in a square around the central point\n x_low = np.floor(x_shifted).astype(int)\n x_high = x_low + 1\n\n y_low = np.floor(y_shifted).astype(int)\n y_high = y_low + 1\n\n #Place co-ordinates outside the image back into the image\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\n x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\n y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\n\n #Gather the interpolation points\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\n interp_pts_2 = np.stack((x_low_clip, y_high_clip))\n interp_pts_3 = np.stack((x_high_clip, y_low_clip))\n interp_pts_4 = np.stack((x_high_clip, y_high_clip))\n\n #Index into the images\n desired_shape = lf_size\n ref_view = torch.tensor(ref_view, dtype=torch.float32).cuda()\n res_1 = torch_tensor_sample(ref_view, interp_pts_1, desired_shape)\n res_2 = torch_tensor_sample(ref_view, interp_pts_2, desired_shape)\n res_3 = torch_tensor_sample(ref_view, interp_pts_3, desired_shape)\n res_4 = torch_tensor_sample(ref_view, interp_pts_4, desired_shape)\n\n #Compute interpolation weights\n x_low_f = x_low.astype(np.float32)\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\n d_x_high = 1.0 - d_x_low\n y_low_f = y_low.astype(np.float32)\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\n d_y_high = 1.0 - d_y_low\n\n w1 = torch.from_numpy(d_x_low * d_y_low)\n w2 = torch.from_numpy(d_x_low * d_y_high)\n w3 = torch.from_numpy(d_x_high * d_y_low)\n w4 = torch.from_numpy(d_x_high * d_y_high)\n\n #THEY AGREE AT THIS POINT\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape).cuda(), res_1)\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape).cuda(), res_2)\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape).cuda(), res_3)\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape).cuda(), res_4)\n\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\n torch.add(novel_view, weighted_4, out=novel_view)\n return novel_view","def generate_all_sizes():\n dimension = 4\n h = 1\n while h <= dimension:\n w = 1\n while w <= dimension:\n for y in range(0, dimension, h):\n for x in range(0, dimension, w):\n yield FeatureSize(x / dimension,\n y / dimension,\n w / dimension,\n h / dimension)\n w = w * 2\n h = h * 2","def downsample(state):\n return state[::2, ::2, :]","def dryrun_find_featuremap_dims(\n feature_extractor: FeatureExtractor | GraphModule,\n input_size: tuple[int, int],\n layers: list[str],\n) -> dict[str, dict[str, int | tuple[int, int]]]:\n\n dryrun_input = torch.empty(1, 3, *input_size)\n dryrun_features = feature_extractor(dryrun_input)\n return {\n layer: {\"num_features\": dryrun_features[layer].shape[1], \"resolution\": dryrun_features[layer].shape[2:]}\n for layer in layers\n }","def undistort_rectify_map(self):\n return cv.initUndistortRectifyMap(self._k, self._dist, np.eye(3), self._k, self.frame_size[::-1], cv.CV_16SC2)","def make_map(self, sampling=None, size=None):\n if sampling is None and self.sampling is None:\n self.sampling = self.minimum_sampling()\n elif sampling is not None:\n self.sampling = sampling\n \n if size is None and self.size is None:\n self.size = self.minimum_size()\n elif size is not None:\n self.size = size\n\n # Set the number of pixels that spans the full size requested\n pixsize = numpy.ceil(self.size/self.sampling).astype(int)\n # Force the pixel size to be odd\n if pixsize % 2 == 0:\n pixsize += 1\n # Adjust the size to be an integer number of pixels\n _size = pixsize*self.sampling\n if _size - self.size > 0.1*self.sampling:\n warnings.warn('Size reset to an integer number of pixels: '\n ' {0} -> {1} arcsec'.format(self.size, _size))\n self.size = _size\n self.y = (pixsize-1)*numpy.linspace(-0.5,0.5,pixsize)*self.sampling\n self.x = self.y.copy()[::-1]\n\n # Sample it\n self.X, self.Y = numpy.meshgrid(self.x, self.y)\n self.data = self.__call__(self.X, self.Y)","def _modify_map_size(self, merged_map):\n pos_x_white, pos_y_white = np.where(merged_map == 255)\n pos_x_black, pos_y_black = np.where(merged_map == 0)\n\n pos_x_M = np.amax(np.hstack((pos_x_black, pos_x_white)))\n pos_x_m = np.amin(np.hstack((pos_x_black, pos_x_white)))\n pos_y_M = np.amax(np.hstack((pos_y_black, pos_y_white)))\n pos_y_m = np.amin(np.hstack((pos_y_black, pos_y_white)))\n\n reduced_map = merged_map[pos_x_m-5:pos_x_M+5, pos_y_m-5:pos_y_M+5]\n\n return reduced_map","def upsample_filt(size):\r\n factor = (size + 1) // 2\r\n if size % 2 == 1:\r\n center = factor - 1\r\n else:\r\n center = factor - 0.5\r\n og = np.ogrid[:size, :size]\r\n return (1 - abs(og[0] - center) / factor) * \\\r\n (1 - abs(og[1] - center) / factor)","def __init__(self):\n self._root = None\n self._size = 0\n self._curr_idx = 0\n self._depths, self._heights = None, None","def __init__(self, input_size=88):\n self._input_size = input_size","def resize_volume(img):\n desired_depth = 64\n desired_width = 128\n desired_height = 128\n\n current_depth = img.shape[-1]\n current_width = img.shape[0]\n current_height = img.shape[1]\n\n depth = current_depth / desired_depth\n width = current_width / desired_width\n height = current_height / desired_height\n\n depth_factor = 1 / depth\n width_factor = 1 / width\n height_factor = 1 / height\n\n img = ndimage.rotate(input=img, angle=90, reshape=False)\n img = ndimage.zoom(input=img, zoom=(width_factor, height_factor, depth_factor), order=1)\n\n return img","def _assign_sizes(self):","def __init__(self, output_size, spatial_scale=1.0):\n super().__init__()\n self.output_size = output_size\n self.spatial_scale = spatial_scale","def __init__(self, output_size, spatial_scale=1.0):\n super().__init__()\n self.output_size = output_size\n self.spatial_scale = spatial_scale","def upsample(inputs, out_shape, data_format):\n if data_format == 'channels_first':\n inputs = tf.transpose(inputs, [0, 2, 3, 1])\n new_height = out_shape[3]\n new_width = out_shape[2]\n else:\n new_height = out_shape[2]\n new_width = out_shape[1]\n\n inputs = tf.image.resize_nearest_neighbor(inputs, (new_height, new_width))\n if data_format == 'channels_first':\n inputs = tf.transpose(inputs, [0, 3, 1, 2])\n return inputs","def upsample_2d(x, size=(2, 2)):\n h, w, _ = x.get_shape().as_list()[1:]\n size_x, size_y = size\n output_h = h * size_x\n output_w = w * size_y\n return tf.image.resize_bilinear(x, (output_h, output_w), align_corners=None, name='upsampling')","def __init__(self, size=(2, 2), **kwargs):\n super(MaxUnpooling2D, self).__init__(**kwargs)\n self.size = size","def loadDepthFrame(self):\n self.DepthFrameRaw = cv2.imread(\n script_path + \"/data/raw_depth.png\", 0).astype(np.uint16)","def __init__(self,\n depth_multiplier,\n min_depth,\n conv_hyperparams,\n reuse_weights=None):\n super(SSDVgg16FeatureExtractor, self).__init__(\n depth_multiplier, min_depth, conv_hyperparams, reuse_weights)","def reindex(self):\n super().reindex()\n self._depths, self._heights = None, None\n for p in self.positions():\n self._compute_depth(p)\n self._compute_height(p)","def __init__(self, size):\n self.world = [[None for y in range(size)] for x in range(size)]","def _visualize_input(self, input):\n self.writer.add_image('input', make_grid(input[0, 0, :, :], nrow=8, normalize=True))","def make_hp_map(data, hp_indices, Nside = 2048, nest = True):\n \n print(\"len hp_indices: {}\".format(len(hp_indices)))\n hp_indices = np.array(hp_indices)\n print(\"shape of hp_indices: {}\".format(hp_indices.shape))\n hp_indices = np.squeeze(hp_indices)\n \n Npix = 12*Nside**2\n map_data = np.zeros(Npix, np.float_)\n map_data[hp_indices] = data\n \n return map_data","def _increase_size(self) -> None:\n keys_vals_to_move = [item for item in self.HashMap if item]\n self.length = 0\n self.capacity = self.capacity * 2\n self.HashMap = [None] * self.capacity\n for item in keys_vals_to_move:\n while len(item) > 0:\n self.add(item[0], item[1])\n item.pop(0)\n item.pop(0)","def f() -> None:\n x = torch.rand(7, 3).to(self.device)\n kernel = ScaleKernel(MaternKernel())\n allocator = GreedyVarianceReduction()\n allocator.allocate_inducing_points(x, kernel, 4, x.shape[:-2])","def DEPTH(frame):\n\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\n\tframe.image.copy_bits( depth.ctypes.data )\n\tcv2.imshow( 'VideoDEPTH', depth )","def _build_reprojection_graph(self):\n EPS = 1e-8\n depths = self.depths_placeholder[tf.newaxis]\n poses = self.poses_placeholder[tf.newaxis]\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\n\n batch, num, ht, wd = tf.unstack(tf.shape(depths), num=4)\n Ts = VideoSE3Transformation(matrix=poses)\n intrinsics = intrinsics_vec_to_matrix(intrinsics)\n\n ii, jj = tf.meshgrid(tf.range(0, num), tf.range(num, num+1))\n ii = tf.reshape(ii, [-1])\n jj = tf.reshape(jj, [-1])\n\n Tij = Ts.gather(jj) * Ts.gather(ii).inv()\n X0 = projective_ops.backproject(depths, intrinsics)\n X1 = Tij(X0)\n\n coords = projective_ops.project(X1, intrinsics)\n depths = X1[..., 2]\n\n indicies = tf.cast(coords[..., ::-1] + .5, tf.int32)\n indicies = tf.reshape(indicies, [-1, 2])\n depths = tf.reshape(depths, [-1])\n\n depth = tf.scatter_nd(indicies, depths, [ht, wd])\n count = tf.scatter_nd(indicies, tf.ones_like(depths), [ht, wd])\n\n depth = depth / (count + EPS)\n self.outputs['depth_reprojection'] = depth","def dimensions():","def draw(self):\n\n super().draw()\n \n self.dim = self.getdim()\n start_x, start_y, = self.x(), self.y()\n\n for y in range(self.r):\n for x in range(self.c):\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\n self.tiles[y][x].resize(x_pos, y_pos, self.dim, self.dim)","def edit(self):\n wmap = 512\n if not self.mapd:\n data = self.data[24:]\n mapd = self.mapd = []\n for index in xrange(0,3*wmap*wmap,3):\n mapd.append(data[index:index+3])\n self.setChanged()","def resize_volumes(x, depth_factor, height_factor, width_factor, data_format='channels_last'):\n if data_format == 'channels_first':\n output = repeat_elements(x, depth_factor, axis=2)\n output = repeat_elements(output, height_factor, axis=3)\n output = repeat_elements(output, width_factor, axis=4)\n return output\n elif data_format == 'channels_last':\n output = repeat_elements(x, depth_factor, axis=1)\n output = repeat_elements(output, height_factor, axis=2)\n output = repeat_elements(output, width_factor, axis=3)\n return output\n else:\n raise ValueError('Invalid data_format:', data_format)","def initiate_memory(self):\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]","def show_rgbd(self):\n while self.depth_data is None:\n pass\n\n while not rospy.is_shutdown():\n rospy.Rate(10).sleep()\n d = self.depth_data * self.cam.DEPTH_UNIT\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\n dc = np.concatenate((d, self.rgb_data), axis=1)\n cv2.imshow('RGB & Depth Image', dc)\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n cv2.destroyAllWindows()","def __init__(self, width, height):\n self.clean_tiles = []\n self.width = width\n self.height = height","def __init__(self, width, height):\n self.w = width\n self.h = height\n self.cleanTiles = []\n self.tiles = [[False] * width for i in range(height)]\n self.cleaned = 0","def run(self, depth):\n\t\tdepth = depth.invert()\n\t\t\"\"\"use this to convert it into cm, or into m by changing 10 to 100\"\"\"\n\t\tdepth = divide(depth, 10)\n\t\t\"\"\"Makes blobs easier to detect\"\"\"\n\t\tdepth = depth.erode()\n\t\tblob_array = self.blob_detect(depth)\n\t\tif blob_array:\n\t\t\ttheadau_array = self.get_theadaus(blob_array)\n\t\t\tprint theadau_array\n\t\t\t\"\"\"\n\t\t\tUntill i fill in outside coord array, i will get rid of this code\n\t\t\toutside_coord_array = self.get_outside_points(blob_array)\n\t\t\tblob_width_array = self.get_width(outside_coord_array, theadau_array)\n\t\t\treturn blob_width_array\t\n\t\t\t\"\"\"\t\n\t\treturn blob_array","def resize(self):\n pass","def depth_callback(self, data):\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\"passthrough\")\n self.depth_mutex.acquire()\n self.depth_image = cv_image\n self.depth_mutex.release()","def polylinedictarraycopy(d):#d——原始图层多段线字典 \r\n dictlist=[]\r\n ratiolist=[] #放缩率列表\r\n rationumaccumulationlist=[] #放缩率数量累加列表\r\n \r\n eachrationum=globalconfig.X_ARRAY_NUM//globalconfig.RATIO_NUM\r\n leftrationum=globalconfig.X_ARRAY_NUM%globalconfig.RATIO_NUM\r\n \r\n eachrationumlist=[eachrationum]*globalconfig.RATIO_NUM #各个放缩率对应数量的列表\r\n \r\n for i in range((globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2,(globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2+leftrationum):\r\n eachrationumlist[i]=eachrationumlist[i]+1 #将整除后的余值加入到靠中间放缩率的方案中。\r\n \r\n rationumaccumulationlist.append(0) \r\n \r\n for i in range(1,globalconfig.RATIO_NUM): #计算放缩率数量累加列表\r\n rationumaccumulationlist.append(rationumaccumulationlist[i-1]+eachrationumlist[i-1])\r\n \r\n for i in range(0,globalconfig.RATIO_NUM): #计算放缩率列表\r\n ratiolist.append((globalconfig.CENTER_RATIO-((globalconfig.RATIO_NUM+1)//2-1)*globalconfig.RATIO_DIFF)+i*globalconfig.RATIO_DIFF) \r\n \r\n for i in range(0,globalconfig.RATIO_NUM): #每种放缩率\r\n for j in range(0,eachrationumlist[i]): #每种放缩率对应数量\r\n newdict={}\r\n for e in d: #将字典中值即每一图层对应的多段线列表进行复制并移动到指定位置\r\n newdict[e]=polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist)) \r\n #newdict.append([e,polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist))])\r\n dictlist.append(newdict) \r\n return (dictlist,ratiolist,eachrationumlist)","def __resize_to_32x(input_data):\n rate = 1\n while min(input_data['img'].shape[:2])>736:\n test_size = 736\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\n if True: # input_data['img'].shape[1] < 512:\n rate = test_size / input_data['img'].shape[1]\n seq = iaa.Sequential([\n iaa.Scale({'height': \"keep-aspect-ratio\", 'width': test_size}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n else:\n if True: # input_data['img'].shape[0] < 512:\n rate = test_size / input_data['img'].shape[0]\n seq = iaa.Sequential([\n iaa.Scale({'height': test_size, 'width': \"keep-aspect-ratio\"}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\n input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\n p_row = 0\n while True:\n if (input_data['img'].shape[0] + p_row) % 32 == 0:\n break\n p_row += 1\n p_col = 0\n while True:\n if (input_data['img'].shape[1] + p_col) % 32 == 0:\n break\n p_col += 1\n\n input_data['img'] = np.pad(input_data['img'], ((0, p_row), (0, p_col), (0, 0)), mode='constant')\n\n return input_data","def resize_function(input):\n\n from keras.backend import tf as ktf\n return ktf.image.resize_images(input, (64, 64))","def registerDepthFrame(self, frame):\n h, w = frame.shape[:2]\n frame = cv2.warpAffine(frame,self.depth2rgb_affine,(w,h))\n\n return frame","def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\n\n def get_states(start):\n frontier = [start]\n frontier_set = {start}\n explored = set()\n\n states = [False for _ in range(len(depths))]\n while not all(states):\n node = frontier.pop(0)\n frontier_set.remove(node)\n explored.add(node)\n\n children = node.get_children()\n\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\n # produced from the parent by the same action) produced at a certain depth will always be selected,\n # and children produced by other actions will never be selected\n shuffle(children)\n\n for child in children:\n if child not in frontier_set and child not in explored:\n frontier_set.add(child)\n frontier.append(child)\n child.path_cost = node.path_cost+1\n index = depths.index(child.path_cost) if child.path_cost in depths else None\n if index is not None and not states[index]:\n states[index] = {'start': start.sequence, 'end': child.sequence}\n\n return states\n\n depth_sample = [[] for depth in range(len(depths))]\n\n for _ in range(num_samples):\n start = list(range(1,n+2))\n shuffle(start)\n start = PuzzleState(start, path_cost=0)\n\n states = get_states(start)\n print('\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\n list(map(list.append, depth_sample, states))\n\n return depth_sample","def upscale(x, n):\n if n == 1:\n return x\n x_shape = tf.shape(x)\n height, width = x_shape[1], x_shape[2]\n return tf.image.resize_nearest_neighbor(x, [n * height, n * width])\n # return tf.batch_to_space(tf.tile(x, [n**2, 1, 1, 1]), [[0, 0], [0, 0]], n)","def resize(final_grid, alpha, beta):\n # init the filter before resize\n adjusted = cv2.convertScaleAbs(final_grid, alpha, beta)\n sharpen_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])\n sharpen = cv2.filter2D(final_grid, -1, sharpen_kernel)\n\n # resize the map to the wanted size\n map_w_border_row = WIDTH_G + 2\n map_w_border_col = LENGTH_G + 2\n vis_map = cv2.resize(sharpen, (map_w_border_col, map_w_border_row), cv2.INTER_AREA)\n return vis_map","def __init__(self,\n name,\n input_size,\n state_size):\n self._input_size = input_size\n self._state_size = state_size\n super(GRU, self).__init__(name)","def sample(self, size=1):\n pass","def _get_depth_map_scale_subfolder(self):\n if self.im_scale <= 0.25:\n if self.im_scale <= 0.125:\n return \"Depth/0.125/\"\n else:\n return \"Depth/0.25/\"\n else: \n return \"Depth/\"","def reconstructed_data(self):\n try:\n data = np.sum(\n np.array([\n self.partial_reconstructed_data(i)\n for i in range(self._max_level)\n ]),\n axis=0)\n except MemoryError:\n data = np.array(self.partial_reconstructed_data(0))\n for i in range(1, self._max_level):\n data = np.sum([data,\n np.array(self.partial_reconstructed_data(i))], axis=0)\n return data","def positions(self, tileID, numSamples):","def layers_sizes(self):\n return iter([self.delta_h*l for l in range(int(self.h/self.delta_h)-1)])","def _read_IntM_from_pdata(p_data, out_size=None, cam_id=2):\n\n # IntM = np.zeros((4,4))\n raw_img_size = p_data.get_cam2(0).size if cam_id == 2 else p_data.get_cam3(0).size\n width = int(raw_img_size[0])\n height = int(raw_img_size[1])\n IntM = p_data.calib.K_cam2 if cam_id == 2 else p_data.calib.K_cam3\n focal_length = np.mean([IntM[0, 0], IntM[1, 1]])\n h_fov = math.degrees(math.atan(IntM[0, 2] / IntM[0, 0]) * 2)\n v_fov = math.degrees(math.atan(IntM[1, 2] / IntM[1, 1]) * 2)\n\n if out_size is not None: # the depth map is re-scaled #\n camera_intrinsics = np.zeros((3, 3))\n pixel_width, pixel_height = out_size[0], out_size[1]\n camera_intrinsics[2, 2] = 1.\n camera_intrinsics[0, 0] = IntM[0, 0] # (pixel_width/2.0)/math.tan(math.radians(h_fov/2.0))\n camera_intrinsics[0, 2] = (pixel_width - 1)/2.0\n camera_intrinsics[1, 1] = IntM[1, 1] # (pixel_height/2.0)/math.tan(math.radians(v_fov/2.0))\n camera_intrinsics[1, 2] = (pixel_height - 1) /2.0\n\n IntM = camera_intrinsics\n focal_length = pixel_width / width * focal_length\n width, height = pixel_width, pixel_height\n\n\n # In scanenet dataset, the depth is perperdicular z, not ray distance #\n pixel_to_ray_array = View.normalised_pixel_to_ray_array(width=width, height=height,\n hfov=h_fov, vfov=v_fov, normalize_z=True)\n\n pixel_to_ray_array_2dM = np.reshape(np.transpose( pixel_to_ray_array, axes=[2, 0, 1]), [3, -1])\n pixel_to_ray_array_2dM = torch.from_numpy(pixel_to_ray_array_2dM.astype(np.float32))\n cam_intrinsic = {\n 'hfov': h_fov, 'vfov': v_fov,\n 'unit_ray_array': pixel_to_ray_array,\n 'unit_ray_array_2D': pixel_to_ray_array_2dM,\n 'focal_length': focal_length,\n 'intrinsic_M': IntM} \n return cam_intrinsic","def _resize(self, new_capacity):\n temp_array = self.make_array(new_capacity)\n for i in range(self.n):\n temp_array[i] = self.original_array[i]\n self.original_array = temp_array\n self.capacity = new_capacity","def __init__(self):\n self.VideoFrame = np.array([])\n self.DepthFrameRaw = np.array([]).astype(np.uint16)\n \"\"\" Extra arrays for colormaping the depth image\"\"\"\n self.DepthFrameHSV = np.zeros((480, 640, 3)).astype(np.uint8)\n self.DepthFrameRGB = np.array([])\n\n \"\"\"initialize kinect & turn off auto gain and whitebalance\"\"\"\n freenect.sync_get_video_with_res(resolution=freenect.RESOLUTION_HIGH)\n # print(freenect.sync_set_autoexposure(False))\n freenect.sync_set_autoexposure(False)\n # print(freenect.sync_set_whitebalance(False))\n freenect.sync_set_whitebalance(False)\n \"\"\"check depth returns a frame, and flag kinectConnected\"\"\"\n if(freenect.sync_get_depth_with_res(format=freenect.DEPTH_11BIT) == None):\n self.kinectConnected = False\n else:\n self.kinectConnected = True\n\n # mouse clicks & calibration variables\n self.depth2rgb_affine = np.array(list(csv.reader(open(\"depth2rgb_affine.cfg\"))), dtype=float)\n self.kinectCalibrated = False\n self.last_click = np.array([0, 0])\n self.new_click = False\n self.rgb_click_points = np.zeros((5, 2), int)\n self.depth_click_points = np.zeros((5, 2), int)\n\n \"\"\" block info \"\"\"\n self.block_contours = np.array([])\n self.block_detections = np.array([])\n\n \"\"\"camera calibration\"\"\"\n self.cam_int_mat = [] # np.array([])\n self.cam_ext_mat = []\n self.dist_coeffs = []\n\n \"\"\"depth info\"\"\"\n self.max_depth = 0.95\n self.affine_transform = False","def _reshape(self, data):\n\n\t\t\td = np.zeros((32,32,3))\n\t\t\td_r = data[0:1024].reshape(32,32)\n\t\t\td_g = data[1024:2048].reshape(32,32)\n\t\t\td_b = data[2048:].reshape(32,32)\n\n\t\t\tfor h in range(32):\n\t\t\t for w in range(32):\n\t\t\t for c in range(3):\n\n\t\t\t if c == 0 : d[h,w,c] = d_r[h,w]\n\t\t\t elif c == 1 : d[h,w,c] = d_g[h,w]\n\t\t\t else : d[h,w,c] = d_b[h,w]\n\n\t\t\tarray = np.array(d, dtype=np.uint8)\n\t\t\timg = Image.fromarray(array)\n\t\t\ttemp = img.resize(size = (64,64))\n\t\t\td = image.img_to_array(temp)\n\n\t\t\t#plt.imshow(d)\n\t\t\t#plt.show()\n\t\t\treturn d","def registerDepthFrame(self, frame):\n frame = cv2.warpAffine(frame, self.depth2rgb_affine,\n (frame.shape[1], frame.shape[0]))\n return frame","def zoom_to_size(self, *p):\n\t\tif self.image is None or self.allocation is None:\n\t\t\treturn\n\t\tif __debug__: print self.allocation.width, self.image.get_width()\n\t\tif __debug__: print self.allocation.width, self.image.get_width(), self.allocation.width/self.image.get_width()\n\t\tz = min(\n\t\t\tself.allocation.width/self.image.get_width(),\n\t\t\tself.allocation.height/self.image.get_height()\n\t\t\t)\n\t\tif __debug__: print \"zoom_to_size\", \"z=\", z\n\t\tself.zoom = z","def resizeGL(self,Width,Height):\n return","def getDimensions():","def _set_z_size(self):\n self._level_gen.size = (self._level_gen.size[X],\n self._level_gen.size[Y],\n self._level_size_z_spinbox.value())\n self._refresh_view()","def generate_depth_image(self, cloud):\n points = self.get_hand_points(cloud)\n\n im1 = self.compute_height_map(points, 2)\n im2 = self.compute_height_map(points, 1)\n im3 = self.compute_height_map(points, 0)\n\n im1 = grey_dilation(im1, size=3)\n im2 = grey_dilation(im2, size=3)\n im3 = grey_dilation(im3, size=3)\n\n self.image = np.stack((im1, im2, im3), 0)","def _convert_to_depth(self, dist):\n return self.dist_to_bottom - dist","def _shrink(values, last_dim, reduction_factor):\n\n shape = tf.shape(values)\n new_shape = [\n shape[0],\n shape[1] // reduction_factor,\n last_dim * reduction_factor\n ]\n values = tf.reshape(values, new_shape)\n return values","def __init__(self, size: int):\n self.size = size\n self.window = []","def _conv_filter(state_dict, patch_size=16):\n out_dict = {}\n for k, v in state_dict.items():\n if 'patch_embed.proj.weight' in k:\n v = v.reshape((v.shape[0], 3, patch_size, patch_size))\n out_dict[k] = v\n return out_dict","def _get_state_sizes(self):\n ds = self.builder.nodes[self.ds_inputs[0]]\n return [[ds.xdim]]"],"string":"[\n \"def resized_map(self, new_size):\\n\\n new_map = cv2.resize(self.map.copy(), new_size)\\n cur_count = np.sum(new_map)\\n\\n # Avoid dividing by zero\\n if cur_count == 0:\\n return new_map\\n\\n scale = self.count / cur_count\\n new_map *= scale\\n return new_map\",\n \"def _reconstruct(self, num_samples=None):\",\n \"def pixel_shuffle(input, upscale_factor, inplace=False):\\n return FunctionLib.apply(\\n 'DepthToSpace', input.device, [input],\\n outputs=[input if inplace else None],\\n block_size=int(upscale_factor), mode='CRD', data_format='NCHW')\",\n \"def pixel_unshuffle(input, downscale_factor, inplace=False):\\n return FunctionLib.apply(\\n 'SpaceToDepth', input.device, [input],\\n outputs=[input if inplace else None],\\n block_size=int(downscale_factor), mode='CRD', data_format='NCHW')\",\n \"def depth_rendering(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\\n\\n x_indices = np.arange(lf_size[1])\\n y_indices = np.arange(lf_size[2])\\n b_indices = np.arange(lf_size[0])\\n\\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\\n\\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\\n stacked = np.stack(grid, 2)\\n positions = stacked.reshape(-1, 2)\\n\\n # Compute the distance from each lf position from the reference view\\n # Repeat the elements of this to match the size of the disparity map\\n ref_pos = np.array(\\n [lf_one_way // 2, lf_one_way // 2])\\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\\n\\n\\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\\n\\n # Compute the shifted pixels\\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\\n\\n #indices for linear interpolation in a square around the central point\\n x_low = np.around(x_shifted).astype(int)\\n #x_high = x_low + 1\\n\\n y_low = np.around(y_shifted).astype(int)\\n #y_high = y_low + 1\\n\\n #Place co-ordinates outside the image back into the image\\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\\n #x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\\n #y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\\n\\n #Gather the interpolation points\\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\\n #interp_pts_2 = np.stack((x_low_clip, y_high_clip))\\n #interp_pts_3 = np.stack((x_high_clip, y_low_clip))\\n #interp_pts_4 = np.stack((x_high_clip, y_high_clip))\\n\\n #Index into the images\\n desired_shape = lf_size\\n res_1 = torch_big_sample(ref_view, interp_pts_1, desired_shape)\\n return res_1\\n res_2 = torch_big_sample(ref_view, interp_pts_2, desired_shape)\\n res_3 = torch_big_sample(ref_view, interp_pts_3, desired_shape)\\n res_4 = torch_big_sample(ref_view, interp_pts_4, desired_shape)\\n\\n #Compute interpolation weights\\n x_low_f = x_low.astype(np.float32)\\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\\n d_x_high = 1.0 - d_x_low\\n y_low_f = y_low.astype(np.float32)\\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\\n d_y_high = 1.0 - d_y_low\\n\\n w1 = torch.from_numpy(d_x_low * d_y_low)\\n w2 = torch.from_numpy(d_x_low * d_y_high)\\n w3 = torch.from_numpy(d_x_high * d_y_low)\\n w4 = torch.from_numpy(d_x_high * d_y_high)\\n\\n #THEY AGREE AT THIS POINT\\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape), res_1)\\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape), res_2)\\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape), res_3)\\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape), res_4)\\n\\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\\n torch.add(novel_view, weighted_4, out=novel_view)\\n return novel_view\",\n \"def init_map(self, size, random_data = False):\\n heightmap = []\\n\\n if random_data:\\n # random noise background\\n for x in range(size):\\n heightmap.append([])\\n for y in range(size):\\n heightmap[-1].append(random.random())\\n else:\\n # black background\\n for x in range(size):\\n heightmap.append([])\\n for y in range(size):\\n heightmap[-1].append(0.0)\\n\\n return heightmap\",\n \"def reduceFrame(self, depth, height_ratio = 0.5, sub_sample = 0.3, reduce_to = 'lower'):\\n if (height_ratio > 1.0) or (height_ratio < 0.0)\\\\\\n or (sub_sample > 1.0) or (sub_sample < 0.0):\\n print('height_ratio and sub_sample must be between 0 and 1')\\n exit(1)\\n \\n depth_copy = depth.copy()\\n height = depth_copy.shape[0]\\n h = int(height_ratio*(height))\\n cols_to_cut = 0\\n\\n # catches the case when all rows are kept\\n if height_ratio == 1:\\n d_short = depth_copy\\n\\n elif reduce_to == 'lower':\\n d_short = depth_copy[(height - h):,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'middle_lower':\\n upper_brdr = int(3*(height/4.0) - h/2)\\n lower_brdr = upper_brdr + h\\n d_short = depth_copy[upper_brdr:lower_brdr,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'middle':\\n upper_brdr = int((height - h)/2.0)\\n lower_brdr = upper_brdr + h\\n d_short = depth_copy[upper_brdr:lower_brdr,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'middle_upper':\\n upper_brdr = int((height/4.0) - h/2)\\n lower_brdr = upper_brdr + h\\n d_short = depth_copy[upper_brdr:lower_brdr,\\\\\\n cols_to_cut:-(cols_to_cut+1)]\\n\\n elif reduce_to == 'upper':\\n d_short = depth_copy[:h, cols_to_cut:-(cols_to_cut+1)]\\n\\n d_short[d_short <= 0] = np.nan\\n d_short[d_short > self.max_depth] = np.nan\\n \\n rescaled = rescale(d_short, sub_sample, mode='reflect', multichannel=False, anti_aliasing=True)\\n\\n return rescaled\",\n \"def gen_depth_data(scan_folder, dst_folder, normalize=False):\\n # specify the goal folder\\n dst_folder = os.path.join(dst_folder, 'depth')\\n try:\\n os.stat(dst_folder)\\n print('generating depth data in: ', dst_folder)\\n except:\\n print('creating new depth folder: ', dst_folder)\\n os.mkdir(dst_folder)\\n \\n # load LiDAR scan files\\n scan_paths = load_files(scan_folder)\\n\\n depths = []\\n \\n # iterate over all scan files\\n for idx in range(len(scan_paths)):\\n # load a point cloud\\n current_vertex = np.fromfile(scan_paths[idx], dtype=np.float32)\\n current_vertex = current_vertex.reshape((-1, 4))\\n \\n proj_range, _, _, _ = range_projection(current_vertex)\\n \\n # normalize the image\\n if normalize:\\n proj_range = proj_range / np.max(proj_range)\\n \\n # generate the destination path\\n dst_path = os.path.join(dst_folder, str(idx).zfill(6))\\n \\n # save the semantic image as format of .npy\\n np.save(dst_path, proj_range)\\n depths.append(proj_range)\\n print('finished generating depth data at: ', dst_path)\\n\\n return depths\",\n \"def __init__(self):\\n \\tself.transposition = {}\\n \\tself.currentDepthLimit = 0\\n\\tself.counter = 0\\t\\n pass\",\n \"def keepsize(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\\n\\n def residual(inputs, n_filters):\\n x = ReflectionPadding2D()(inputs)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = Activation(activation)(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, inputs])\\n\\n return x\\n\\n inputs = Input(shape=(nx, ny, 1))\\n x = GaussianNoise(noise)(inputs)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x0 = Activation(activation)(x)\\n\\n x = residual(x0, n_filters)\\n\\n for i in range(depth-1):\\n x = residual(x, n_filters)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, x0])\\n\\n# Upsampling for superresolution\\n x = UpSampling2D()(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = Activation(activation)(x)\\n\\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n\\n return Model(inputs=inputs, outputs=final)\",\n \"def infer_depths(self):\\n self.infer_depths_edges_from_cells()\\n self.infer_depths_cells_from_edges()\\n self.copy_depths_to_subgrid(depth_stat='depth_mean')\",\n \"def upsample(x, name, size):\\n with tf.name_scope(name):\\n outputs = tf.image.resize_bilinear(x, size)\\n # Return layer's output\\n return outputs\",\n \"def _build(self, inputs):\\n\\n # calculate how many slots we need from the 3 dimensions of the incoming conv layer (filter w/h plus depth)\\n dims = inputs.get_shape().as_list()\\n new_dim = 1\\n for d in dims[1:]: # leave first axis as is (batch)\\n new_dim = new_dim * d # multiply 'em up\\n return tf.reshape(inputs, [-1, new_dim]) # -1=keep this dimension as is (it could be anything as this is the number of samples) and flatten the others\",\n \"def prepare_cnn_entries(X,n_nodes=100):\\n idx = X[:,:,0] > 0\\n X_nozeros = X[idx]\\n min_X = np.min(X_nozeros[:,0])\\n max_X = np.max(X_nozeros[:,0])\\n del X_nozeros\\n gc.collect() \\n\\n \\n \\n wavelength_all,step = np.linspace(min_X,max_X, num=n_nodes,retstep=True)\\n #wavelength_edges = np.histogram_bin_edges(wavelength_all,bins=n_nodes)\\n\\n X_new = [[[] for i in range(n_nodes)] for j in range(X.shape[0])]\\n\\n \\n print('Start converting to discrete wavelength inputs...')\\n for i in range(X.shape[0]):\\n if(i % int(X.shape[0] / 10) == 0):\\n print('Part 1.... ' + str(round(100*i/X.shape[0],0)) + ' % completed')\\n for j in range(X.shape[1]):\\n if(X[i,j,0]>0):\\n X_new[i][int((X[i,j,0] - min_X) / step)].append(X[i,j,1])\\n #print(X_new[i][int((X[i,j,0] - min_X) / step)])\\n \\n #del X\\n gc.collect()\\n \\n X_new = np.array(X_new)\\n print(np.count_nonzero(X_new))\\n \\n for i in range(X_new.shape[0]):\\n if(i % int(X_new.shape[0] / 10) == 0):\\n print('Part 2.... ' + str(round(100*i/X_new.shape[0])) + ' % completed')\\n for j in range(X_new.shape[1]):\\n X_new[i,j] = np.array(X_new[i,j])\\n if(X_new[i,j].size > 0):\\n X_new[i,j] = np.mean(np.array(X_new[i,j]))\\n else:\\n X_new[i,j] = 0.\\n \\n print(np.count_nonzero(X_new))\\n \\n return X_new\",\n \"def densMap(fit, metricArray, n, overlap, imageSize, imageName):\\n \\n if True: #Make true if you want to calculate densities (i.e. if you have a new fit/new density list) \\n print 'calculating densities'\\n if type(fit)==sklearn.gaussian_process.gaussian_process.GaussianProcess: #If the fit is Gaussian\\n densities, MSE = fit.predict(metricArray, eval_MSE =True)\\n sigma = numpy.sqrt(MSE)\\n print(sigma)\\n else:\\n densities = fit.predict(metricArray) #Use the ML fit to predict the density for each tile \\n #print len(densities)\\n f = open('densities.txt', 'w')\\n print >> f, list(densities)\\n f.close()\\n else: \\n f = open('densities.txt', 'r')\\n data = f.read()\\n densities = eval(data)\\n # print densities\\n densities = numpy.array(densities)\\n f.close()\\n imageName = 'FirstStitchLong.jpg'\\n overlap = 0.2 \\n n = 50\\n image = Image.open(imageName) #open the image\\n imageSize = image.size #get the image size \\n # print 'Image Size is ', imageSize\\n \\n\\n width = imageSize[0] \\n height = imageSize[1] \\n # print 'width ', width \\n #print 'height ', height\\n overlapSize = int(overlap*n)\\n rowTiles = int((width-n)/(overlapSize))+1\\n print 'Row Tiles is ', rowTiles\\n #colTiles = int(((height-n)/(overlapSize))+1)\\n \\n \\n # newArray = numpy.zeros((int((width-n)/(overlapSize)+1),int(((height-n)/(overlapSize))+1)))\\n \\n #newArray = numpy.zeros(width, height)\\n #print newArray\\n points = []\\n for i in range(len(densities)):\\n x = (i%rowTiles)*overlapSize + n/2\\n y = (i/rowTiles)*overlapSize + n/2\\n points += [[x,y]]\\n # newArray[i%(rowTiles),i/(rowTiles)] = densities[i]\\n # newArray[(i%(rowTiles)+1)*(n/2) , (i/(rowTiles)+1)*(n/2)] = densities[i]\\n # points += [[(i%(rowTiles)+1)*(n/2), (i/(rowTiles)+1)*(n/2)]] #Consider the density to be at the center of each tile \\n # print points\\n grid_x, grid_y = numpy.mgrid[0:width, 0:height] #create a meshgrid \\n \\n # print densities\\n # print('Points is ', points) \\n # print('Densities is ', densities)\\n data = griddata(points, densities, (grid_x, grid_y), method = 'linear') #interpolate to get continuous function of points \\n #can change interpolation method\\n print data.size\\n\\n # print 'Max is ', numpy.amax(data)\\n # min_max_scaler = sklearn.preprocessing.MinMaxScaler()\\n #data_minmax = min_max_scaler.fit_transform(data) \\n \\n \\n \\n ##Plotting \\n plt.figure(1)\\n \\n #plt.figure(figsize = (width, height))\\n # print \\\"Hi Cassie\\\"\\n v = numpy.linspace(min(densities), max(densities), 20, endpoint=True)\\n fig = plt.contourf(grid_x, grid_y, data, levels = v, alpha = 0.4, antialiased = True)\\n \\n mapIm = Image.open(imageName)\\n plt.imshow(mapIm)\\n maxDens = max(densities)\\n print maxDens \\n x = plt.colorbar(fig) \\n plt.savefig('ContourPlot.jpg')\\n return data\",\n \"def glimpseSensor(img, normLoc, minRadius=4, depth=1, sensorBandwidth=12):\\n input_shape = img.get_shape().as_list()\\n img_size = input_shape[1]\\n loc = tf.round(((normLoc + 1) / 2.0) * img_size)\\n loc = tf.cast(loc, tf.int32)\\n zooms = []\\n for k in range(batch_size):\\n imgZooms = []\\n one_img = img[k, :, :, :]\\n max_radius = minRadius * (2**(depth - 1))\\n offset = 2 * max_radius\\n one_img = tf.image.pad_to_bounding_box(one_img, offset, offset, max_radius * 4 + img_size,\\n max_radius * 4 + img_size)\\n\\n for i in range(depth):\\n r = int(minRadius * (2**(i)))\\n d_raw = 2 * r\\n d = tf.constant(d_raw, shape=[1])\\n d = tf.tile(d, [2])\\n loc_k = loc[k, :]\\n adjusted_loc = offset + loc_k - r\\n one_img2 = tf.reshape(\\n one_img, (one_img.get_shape()[0].value, one_img.get_shape()[1].value, input_shape[3]))\\n zoom = tf.slice(one_img2, adjusted_loc, d)\\n zoom = tf.image.resize_bilinear(\\n tf.reshape(zoom, (1, d_raw, d_raw, nput_shape[3])), (sensorBandwidth, sensorBandwidth))\\n zoom = tf.reshape(zoom, (sensorBandwidth, sensorBandwidth, input_shape[3]))\\n imgZooms.append(zoom)\\n\\n zooms.append(tf.stack(imgZooms))\\n\\n return tf.stack(zooms)\",\n \"def keepsize_256(nx, ny, noise, depth, activation='relu', n_filters=64, l2_reg=1e-7):\\n\\n def residual(inputs, n_filters):\\n x = ReflectionPadding2D()(inputs)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = Activation(activation)(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, inputs])\\n\\n return x\\n\\n inputs = Input(shape=(nx, ny, 1))\\n x = GaussianNoise(noise)(inputs)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x0 = Activation(activation)(x)\\n\\n x = residual(x0, n_filters)\\n\\n for i in range(depth-1):\\n x = residual(x, n_filters)\\n\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = BatchNormalization()(x)\\n x = add([x, x0])\\n\\n# Upsampling for superresolution\\n x = UpSampling2D()(x)\\n x = ReflectionPadding2D()(x)\\n x = Conv2D(4*n_filters, (3, 3), padding='valid', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n x = Activation(activation)(x)\\n\\n final = Conv2D(1, (1, 1), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(l2_reg))(x)\\n\\n return Model(inputs=inputs, outputs=final)\",\n \"def update_dimensions(self):\\n self.chunk = numpy.full((self.current_height, self.current_width), fill_value=Constants.VALUE_INITIALIZER,\\n dtype=\\\"int16\\\")\",\n \"def __init__(self, width, height, circular=True):\\n self.width = width\\n self.height = height\\n self.size = width * height\\n self.idx_list = []\\n self._depth_buffer = [[] for _ in range(self.size)]\\n self._depth = [0] * self.size\\n self.circular = circular\",\n \"def __init__(self):\\n self.size = 1000\\n self.mapArray = [None] * self.size\",\n \"def rebuild(self):\\n self.from_samples(self.samples)\",\n \"def resize_lightfield(raw_lightfield, desired_size): # -> lightfield\\n if raw_lightfield.ndim == 6:\\n n_depth, n_cols, n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_depth, n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n\\n for k, depth in enumerate(raw_lightfield):\\n for i, row in enumerate(depth):\\n for j, image_data in enumerate(row):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[k, i, j] = resized_image_data\\n elif raw_lightfield.ndim == 5:\\n n_cols, n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n\\n for i, row in enumerate(raw_lightfield):\\n for j, image_data in enumerate(row):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[i, j] = resized_image_data\\n \\n elif raw_lightfield.ndim == 4:\\n n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n for j, image_data in enumerate(raw_lightfield):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[j] = resized_image_data\\n \\n return output_lightfield\",\n \"def _build_depth_graph(self):\\n self.depth_net = DepthNetwork(self.cfg.STRUCTURE, is_training=False)\\n images = self.images_placeholder[tf.newaxis]\\n poses = self.poses_placeholder[tf.newaxis]\\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\\n\\n # fix the input shape\\n images = tf.reshape(images, [1, 5, 192, 1088, 3])\\n Ts = VideoSE3Transformation(matrix=poses)\\n\\n depths = self.depth_net.forward(Ts, images, intrinsics)\\n self.outputs['depths'] = depths\",\n \"def on_depth_image(self, depth_image):\\n depth_image = depth_image.copy()\\n mask = np.where(self.depth != 0)\\n depth_image[mask] = self.depth[mask]\\n return depth_image\",\n \"def _resize(self, cap):\\n old = self._data\\n self._data = [None] * cap\\n walk = self._front\\n for i in range(self._size):\\n self._data[i] = old[walk]\\n walk = (walk + 1) % len(old)\\n self._front = 0\",\n \"def __init__(self, d=1):\\r\\n self.depth = d\",\n \"def depr_depth_images(self):\\n if not hasattr(self, '_depr_depth_images'):\\n depth_images = self._archive['gaps_depth']\\n self._depr_depth_images = depth_images.reshape([1, 20, 224, 224, 1])\\n return self._depr_depth_images\",\n \"def upsampleImage( arr, kernelSize ):\\n return scipy.ndimage.zoom( arr, kernelSize )\",\n \"def __resize_to_512(input_data):\\n test_size = 720\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\\n axis=-1))\\n for contour in contours] for contours in input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\\n axis=-1)) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * 512 / input_data['img'].shape[0]),\\n np.cast['int32'](point[1] * 512 / input_data['img'].shape[1]))\\n for point in input_data['center_point']]\\n\\n seq = iaa.Sequential([\\n iaa.Scale({'height': 512, 'width': 512}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n return input_data\",\n \"def _preallocate_samples(self):\\n self.prealloc_samples_ = []\\n for _ in range(self.num_prealloc_samples_):\\n self.prealloc_samples_.append(self.sample())\",\n \"def downsample_sam(self, factor):\",\n \"def __resize_512p(input_data):\\n rate = 1\\n test_size=512\\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\\n if True: # input_data['img'].shape[1] < 512:\\n rate = test_size / input_data['img'].shape[1]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': \\\"keep-aspect-ratio\\\", 'width': test_size}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n else:\\n if True: # input_data['img'].shape[0] < 512:\\n rate = test_size / input_data['img'].shape[0]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': test_size, 'width': \\\"keep-aspect-ratio\\\"}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\\n input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\\n return input_data\",\n \"def main():\\n\\n ##############################\\n # Options\\n ##############################\\n # Validation set\\n input_depth_dir = os.path.expanduser(\\n '~/Kitti/depth/train')\\n data_split = 'val'\\n\\n # Test set\\n # input_depth_dir = os.path.expanduser(\\n # '~/Kitti/depth/depth_selection/test_depth_completion_anonymous/velodyne_raw')\\n # data_split = 'test'\\n\\n # Fast fill with Gaussian blur @90Hz (paper result)\\n fill_type = 'fast'\\n extrapolate = True\\n blur_type = 'gaussian'\\n\\n # Fast Fill with bilateral blur, no extrapolation @87Hz (recommended)\\n # fill_type = 'fast'\\n # extrapolate = False\\n # blur_type = 'bilateral'\\n\\n # Multi-scale dilations with extra noise removal, no extrapolation @ 30Hz\\n # fill_type = 'multiscale'\\n # extrapolate = False\\n # blur_type = 'bilateral'\\n\\n # Save output to disk or show process\\n save_output = True\\n\\n ##############################\\n # Processing\\n ##############################\\n if save_output:\\n # Save to Disk\\n show_process = False\\n save_depth_maps = True\\n else:\\n if fill_type == 'fast':\\n raise ValueError('\\\"fast\\\" fill does not support show_process')\\n\\n # Show Process\\n show_process = True\\n save_depth_maps = False\\n\\n # Create output folder\\n this_file_path = os.path.dirname(os.path.realpath(__file__))\\n outputs_dir = this_file_path + '/outputs'\\n os.makedirs(outputs_dir, exist_ok=True)\\n\\n output_folder_prefix = 'depth_' + data_split\\n output_list = sorted(os.listdir(outputs_dir))\\n if len(output_list) > 0:\\n split_folders = [folder for folder in output_list\\n if folder.startswith(output_folder_prefix)]\\n if len(split_folders) > 0:\\n last_output_folder = split_folders[-1]\\n last_output_index = int(last_output_folder.split('_')[-1])\\n else:\\n last_output_index = -1\\n else:\\n last_output_index = -1\\n output_depth_dir = outputs_dir + '/{}_{:03d}'.format(\\n output_folder_prefix, last_output_index + 1)\\n\\n if save_output:\\n if not os.path.exists(output_depth_dir):\\n os.makedirs(output_depth_dir)\\n else:\\n raise FileExistsError('Already exists!')\\n print('Output dir:', output_depth_dir)\\n\\n # Get images in sorted order\\n # images_to_use = sorted(glob.glob(input_depth_dir + '/*'))\\n\\n # Rolling average array of times for time estimation\\n avg_time_arr_length = 10\\n last_fill_times = np.repeat([1.0], avg_time_arr_length)\\n last_total_times = np.repeat([1.0], avg_time_arr_length)\\n\\n images_to_use = []\\n saved_path = []\\n folder_path =\\\"./data_depth_selection/depth_selection/test_depth_completion_anonymous/velodyne_raw\\\"\\n for img_name in os.listdir(folder_path):\\n img_path = os.path.join(folder_path,img_name)\\n saved_path_name = os.path.join(\\\"./output\\\", img_name)\\n saved_path.append(saved_path_name)\\n images_to_use.append(img_path)\\n # if \\\"output\\\" not in os.listdir(\\\"Kitti/depth/\\\"):\\n # os.mkdir(\\\"Kitti/depth/output\\\")\\n # os.mkdir(\\\"output\\\")\\n # for folder in os.listdir(folder_path):\\n # # os.mkdir(\\\"./output/\\\"+folder)\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\")\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\")\\n\\n # inside_folder_path = folder_path + \\\"/\\\" + folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"\\n # for img_folder in os.listdir(inside_folder_path):\\n # print((\\\"/output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder))\\n # # os.mkdir(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder)\\n # print(inside_folder_path + img_folder)\\n # # os.mkdir(\\\"Kitti/depth/output/\\\"+folder+\\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # img_path = inside_folder_path + img_folder+\\\"/data\\\"\\n # try:\\n # print(\\\"............................................................\\\",\\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # depth_image_folder = os.listdir(\\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder)\\n # # print(depth_image_folder)\\n # for img in os.listdir(img_path):\\n # # image_path = +\\\"/\\\"+img\\n # # print(img)\\n # if img in depth_image_folder:\\n # # print(\\\"aaya\\\")\\n # depth_image_path = \\\"./depth_images/train/\\\" + folder + \\\"/proj_depth/groundtruth/\\\"+img_folder+\\\"/\\\"+img\\n # images_to_use.append(depth_image_path)\\n # saved_path.append(\\\"./output/\\\"+folder+\\\"/2011_09_26/\\\"+folder+\\\"/\\\"+img_folder+\\\"/\\\"+img)\\n # except Exception:\\n # print(\\\"folder nahi hai\\\")\\n \\n images_to_use = np.array(images_to_use)\\n \\n num_images = len(images_to_use)\\n\\n print(len(images_to_use))\\n\\n\\n for i in range(num_images):\\n\\n depth_image_path = images_to_use[i]\\n\\n # Calculate average time with last n fill times\\n avg_fill_time = np.mean(last_fill_times)\\n avg_total_time = np.mean(last_total_times)\\n\\n # Show progress\\n sys.stdout.write('\\\\rProcessing {} / {}, '\\n 'Avg Fill Time: {:.5f}s, '\\n 'Avg Total Time: {:.5f}s, '\\n 'Est Time Remaining: {:.3f}s'.format(\\n i, num_images - 1, avg_fill_time, avg_total_time,\\n avg_total_time * (num_images - i)))\\n sys.stdout.flush()\\n\\n # Start timing\\n start_total_time = time.time()\\n print(depth_image_path)\\n # Load depth projections from uint16 image\\n depth_image = cv2.imread(depth_image_path, cv2.IMREAD_ANYDEPTH)\\n projected_depths = np.float32(depth_image / 256.0)\\n\\n # Fill in\\n start_fill_time = time.time()\\n if fill_type == 'fast':\\n final_depths = depth_map_utils.fill_in_fast(\\n projected_depths, extrapolate=extrapolate, blur_type=blur_type)\\n elif fill_type == 'multiscale':\\n final_depths, process_dict = depth_map_utils.fill_in_multiscale(\\n projected_depths, extrapolate=extrapolate, blur_type=blur_type,\\n show_process=show_process)\\n else:\\n raise ValueError('Invalid fill_type {}'.format(fill_type))\\n end_fill_time = time.time()\\n\\n # Display images from process_dict\\n if fill_type == 'multiscale' and show_process:\\n img_size = (570, 165)\\n\\n x_start = 80\\n y_start = 50\\n x_offset = img_size[0]\\n y_offset = img_size[1]\\n x_padding = 0\\n y_padding = 28\\n\\n img_x = x_start\\n img_y = y_start\\n max_x = 1900\\n\\n row_idx = 0\\n for key, value in process_dict.items():\\n\\n image_jet = cv2.applyColorMap(\\n np.uint8(value / np.amax(value) * 255),\\n cv2.COLORMAP_JET)\\n vis_utils.cv2_show_image(\\n key, image_jet,\\n img_size, (img_x, img_y))\\n\\n img_x += x_offset + x_padding\\n if (img_x + x_offset + x_padding) > max_x:\\n img_x = x_start\\n row_idx += 1\\n img_y = y_start + row_idx * (y_offset + y_padding)\\n\\n # Save process images\\n cv2.imwrite('process/' + key + '.png', image_jet)\\n\\n cv2.waitKey()\\n\\n # Save depth images to disk\\n if save_depth_maps:\\n depth_image_file_name = depth_image_path.split(\\\"/\\\")\\n # print(depth_image_file_name)\\n file_path = \\\"\\\"\\n print(len(depth_image_file_name))\\n # for i in range(8):\\n # if(i == 2):\\n # file_path = os.path.join(file_path, \\\"output\\\")\\n # else:\\n # file_path = os.path.join(file_path, depth_image_file_name[i])\\n # cv2.imwrite(file_path, depth_image)\\n # print(\\\"check.............................\\\",saved_path[i])\\n # with open(saved_path[i],'r') as f:\\n # print(\\\"badhiya\\\") \\n depth_image = (final_depths * 256)\\n # plt.imsave(saved_path[i],depth_image)\\n # cv2.imwrite(saved_path[i], depth_image)\\n # print(saved_path[i])\\n # cv2.imwrite(\\\"/media/pankaj/Elements/ip_basic\\\"+saved_path[i], depth_image)\\n \\n try:\\n with open(saved_path[i], 'wb') as f:\\n depth_image = (final_depths * 256).astype(np.uint16)\\n\\n writer = png.Writer(width=depth_image.shape[1],\\n height=depth_image.shape[0],\\n bitdepth=16,\\n greyscale=True)\\n writer.write(f, depth_image)\\n except Exception:\\n print(\\\"nikl.............\\\")\\n\\n end_total_time = time.time()\\n\\n # Update fill times\\n last_fill_times = np.roll(last_fill_times, -1)\\n last_fill_times[-1] = end_fill_time - start_fill_time\\n\\n # Update total times\\n last_total_times = np.roll(last_total_times, -1)\\n last_total_times[-1] = end_total_time - start_total_time\",\n \"def Resize(self):\\n\\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\\n self.FreshStart()\",\n \"def reset_map(self):\\n self.x = None\\n self.X = None\\n self.y = None\\n self.Y = None\\n self.data = None\\n self.sampling = None\\n self.size = None\",\n \"def depth_rendering_gpu(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\\n\\n x_indices = np.arange(lf_size[1])\\n y_indices = np.arange(lf_size[2])\\n b_indices = np.arange(lf_size[0])\\n\\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\\n\\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\\n stacked = np.stack(grid, 2)\\n positions = stacked.reshape(-1, 2)\\n\\n # Compute the distance from each lf position from the reference view\\n # Repeat the elements of this to match the size of the disparity map\\n ref_pos = np.array(\\n [lf_one_way // 2, lf_one_way // 2])\\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\\n\\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\\n\\n # Compute the shifted pixels\\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\\n\\n #indices for linear interpolation in a square around the central point\\n x_low = np.floor(x_shifted).astype(int)\\n x_high = x_low + 1\\n\\n y_low = np.floor(y_shifted).astype(int)\\n y_high = y_low + 1\\n\\n #Place co-ordinates outside the image back into the image\\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\\n x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\\n y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\\n\\n #Gather the interpolation points\\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\\n interp_pts_2 = np.stack((x_low_clip, y_high_clip))\\n interp_pts_3 = np.stack((x_high_clip, y_low_clip))\\n interp_pts_4 = np.stack((x_high_clip, y_high_clip))\\n\\n #Index into the images\\n desired_shape = lf_size\\n ref_view = torch.tensor(ref_view, dtype=torch.float32).cuda()\\n res_1 = torch_tensor_sample(ref_view, interp_pts_1, desired_shape)\\n res_2 = torch_tensor_sample(ref_view, interp_pts_2, desired_shape)\\n res_3 = torch_tensor_sample(ref_view, interp_pts_3, desired_shape)\\n res_4 = torch_tensor_sample(ref_view, interp_pts_4, desired_shape)\\n\\n #Compute interpolation weights\\n x_low_f = x_low.astype(np.float32)\\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\\n d_x_high = 1.0 - d_x_low\\n y_low_f = y_low.astype(np.float32)\\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\\n d_y_high = 1.0 - d_y_low\\n\\n w1 = torch.from_numpy(d_x_low * d_y_low)\\n w2 = torch.from_numpy(d_x_low * d_y_high)\\n w3 = torch.from_numpy(d_x_high * d_y_low)\\n w4 = torch.from_numpy(d_x_high * d_y_high)\\n\\n #THEY AGREE AT THIS POINT\\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape).cuda(), res_1)\\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape).cuda(), res_2)\\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape).cuda(), res_3)\\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape).cuda(), res_4)\\n\\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\\n torch.add(novel_view, weighted_4, out=novel_view)\\n return novel_view\",\n \"def generate_all_sizes():\\n dimension = 4\\n h = 1\\n while h <= dimension:\\n w = 1\\n while w <= dimension:\\n for y in range(0, dimension, h):\\n for x in range(0, dimension, w):\\n yield FeatureSize(x / dimension,\\n y / dimension,\\n w / dimension,\\n h / dimension)\\n w = w * 2\\n h = h * 2\",\n \"def downsample(state):\\n return state[::2, ::2, :]\",\n \"def dryrun_find_featuremap_dims(\\n feature_extractor: FeatureExtractor | GraphModule,\\n input_size: tuple[int, int],\\n layers: list[str],\\n) -> dict[str, dict[str, int | tuple[int, int]]]:\\n\\n dryrun_input = torch.empty(1, 3, *input_size)\\n dryrun_features = feature_extractor(dryrun_input)\\n return {\\n layer: {\\\"num_features\\\": dryrun_features[layer].shape[1], \\\"resolution\\\": dryrun_features[layer].shape[2:]}\\n for layer in layers\\n }\",\n \"def undistort_rectify_map(self):\\n return cv.initUndistortRectifyMap(self._k, self._dist, np.eye(3), self._k, self.frame_size[::-1], cv.CV_16SC2)\",\n \"def make_map(self, sampling=None, size=None):\\n if sampling is None and self.sampling is None:\\n self.sampling = self.minimum_sampling()\\n elif sampling is not None:\\n self.sampling = sampling\\n \\n if size is None and self.size is None:\\n self.size = self.minimum_size()\\n elif size is not None:\\n self.size = size\\n\\n # Set the number of pixels that spans the full size requested\\n pixsize = numpy.ceil(self.size/self.sampling).astype(int)\\n # Force the pixel size to be odd\\n if pixsize % 2 == 0:\\n pixsize += 1\\n # Adjust the size to be an integer number of pixels\\n _size = pixsize*self.sampling\\n if _size - self.size > 0.1*self.sampling:\\n warnings.warn('Size reset to an integer number of pixels: '\\n ' {0} -> {1} arcsec'.format(self.size, _size))\\n self.size = _size\\n self.y = (pixsize-1)*numpy.linspace(-0.5,0.5,pixsize)*self.sampling\\n self.x = self.y.copy()[::-1]\\n\\n # Sample it\\n self.X, self.Y = numpy.meshgrid(self.x, self.y)\\n self.data = self.__call__(self.X, self.Y)\",\n \"def _modify_map_size(self, merged_map):\\n pos_x_white, pos_y_white = np.where(merged_map == 255)\\n pos_x_black, pos_y_black = np.where(merged_map == 0)\\n\\n pos_x_M = np.amax(np.hstack((pos_x_black, pos_x_white)))\\n pos_x_m = np.amin(np.hstack((pos_x_black, pos_x_white)))\\n pos_y_M = np.amax(np.hstack((pos_y_black, pos_y_white)))\\n pos_y_m = np.amin(np.hstack((pos_y_black, pos_y_white)))\\n\\n reduced_map = merged_map[pos_x_m-5:pos_x_M+5, pos_y_m-5:pos_y_M+5]\\n\\n return reduced_map\",\n \"def upsample_filt(size):\\r\\n factor = (size + 1) // 2\\r\\n if size % 2 == 1:\\r\\n center = factor - 1\\r\\n else:\\r\\n center = factor - 0.5\\r\\n og = np.ogrid[:size, :size]\\r\\n return (1 - abs(og[0] - center) / factor) * \\\\\\r\\n (1 - abs(og[1] - center) / factor)\",\n \"def __init__(self):\\n self._root = None\\n self._size = 0\\n self._curr_idx = 0\\n self._depths, self._heights = None, None\",\n \"def __init__(self, input_size=88):\\n self._input_size = input_size\",\n \"def resize_volume(img):\\n desired_depth = 64\\n desired_width = 128\\n desired_height = 128\\n\\n current_depth = img.shape[-1]\\n current_width = img.shape[0]\\n current_height = img.shape[1]\\n\\n depth = current_depth / desired_depth\\n width = current_width / desired_width\\n height = current_height / desired_height\\n\\n depth_factor = 1 / depth\\n width_factor = 1 / width\\n height_factor = 1 / height\\n\\n img = ndimage.rotate(input=img, angle=90, reshape=False)\\n img = ndimage.zoom(input=img, zoom=(width_factor, height_factor, depth_factor), order=1)\\n\\n return img\",\n \"def _assign_sizes(self):\",\n \"def __init__(self, output_size, spatial_scale=1.0):\\n super().__init__()\\n self.output_size = output_size\\n self.spatial_scale = spatial_scale\",\n \"def __init__(self, output_size, spatial_scale=1.0):\\n super().__init__()\\n self.output_size = output_size\\n self.spatial_scale = spatial_scale\",\n \"def upsample(inputs, out_shape, data_format):\\n if data_format == 'channels_first':\\n inputs = tf.transpose(inputs, [0, 2, 3, 1])\\n new_height = out_shape[3]\\n new_width = out_shape[2]\\n else:\\n new_height = out_shape[2]\\n new_width = out_shape[1]\\n\\n inputs = tf.image.resize_nearest_neighbor(inputs, (new_height, new_width))\\n if data_format == 'channels_first':\\n inputs = tf.transpose(inputs, [0, 3, 1, 2])\\n return inputs\",\n \"def upsample_2d(x, size=(2, 2)):\\n h, w, _ = x.get_shape().as_list()[1:]\\n size_x, size_y = size\\n output_h = h * size_x\\n output_w = w * size_y\\n return tf.image.resize_bilinear(x, (output_h, output_w), align_corners=None, name='upsampling')\",\n \"def __init__(self, size=(2, 2), **kwargs):\\n super(MaxUnpooling2D, self).__init__(**kwargs)\\n self.size = size\",\n \"def loadDepthFrame(self):\\n self.DepthFrameRaw = cv2.imread(\\n script_path + \\\"/data/raw_depth.png\\\", 0).astype(np.uint16)\",\n \"def __init__(self,\\n depth_multiplier,\\n min_depth,\\n conv_hyperparams,\\n reuse_weights=None):\\n super(SSDVgg16FeatureExtractor, self).__init__(\\n depth_multiplier, min_depth, conv_hyperparams, reuse_weights)\",\n \"def reindex(self):\\n super().reindex()\\n self._depths, self._heights = None, None\\n for p in self.positions():\\n self._compute_depth(p)\\n self._compute_height(p)\",\n \"def __init__(self, size):\\n self.world = [[None for y in range(size)] for x in range(size)]\",\n \"def _visualize_input(self, input):\\n self.writer.add_image('input', make_grid(input[0, 0, :, :], nrow=8, normalize=True))\",\n \"def make_hp_map(data, hp_indices, Nside = 2048, nest = True):\\n \\n print(\\\"len hp_indices: {}\\\".format(len(hp_indices)))\\n hp_indices = np.array(hp_indices)\\n print(\\\"shape of hp_indices: {}\\\".format(hp_indices.shape))\\n hp_indices = np.squeeze(hp_indices)\\n \\n Npix = 12*Nside**2\\n map_data = np.zeros(Npix, np.float_)\\n map_data[hp_indices] = data\\n \\n return map_data\",\n \"def _increase_size(self) -> None:\\n keys_vals_to_move = [item for item in self.HashMap if item]\\n self.length = 0\\n self.capacity = self.capacity * 2\\n self.HashMap = [None] * self.capacity\\n for item in keys_vals_to_move:\\n while len(item) > 0:\\n self.add(item[0], item[1])\\n item.pop(0)\\n item.pop(0)\",\n \"def f() -> None:\\n x = torch.rand(7, 3).to(self.device)\\n kernel = ScaleKernel(MaternKernel())\\n allocator = GreedyVarianceReduction()\\n allocator.allocate_inducing_points(x, kernel, 4, x.shape[:-2])\",\n \"def DEPTH(frame):\\n\\tdepth = np.empty(( 240, 320, 1 ), np.uint16)\\n\\tframe.image.copy_bits( depth.ctypes.data )\\n\\tcv2.imshow( 'VideoDEPTH', depth )\",\n \"def _build_reprojection_graph(self):\\n EPS = 1e-8\\n depths = self.depths_placeholder[tf.newaxis]\\n poses = self.poses_placeholder[tf.newaxis]\\n intrinsics = self.intrinsics_placeholder[tf.newaxis]\\n\\n batch, num, ht, wd = tf.unstack(tf.shape(depths), num=4)\\n Ts = VideoSE3Transformation(matrix=poses)\\n intrinsics = intrinsics_vec_to_matrix(intrinsics)\\n\\n ii, jj = tf.meshgrid(tf.range(0, num), tf.range(num, num+1))\\n ii = tf.reshape(ii, [-1])\\n jj = tf.reshape(jj, [-1])\\n\\n Tij = Ts.gather(jj) * Ts.gather(ii).inv()\\n X0 = projective_ops.backproject(depths, intrinsics)\\n X1 = Tij(X0)\\n\\n coords = projective_ops.project(X1, intrinsics)\\n depths = X1[..., 2]\\n\\n indicies = tf.cast(coords[..., ::-1] + .5, tf.int32)\\n indicies = tf.reshape(indicies, [-1, 2])\\n depths = tf.reshape(depths, [-1])\\n\\n depth = tf.scatter_nd(indicies, depths, [ht, wd])\\n count = tf.scatter_nd(indicies, tf.ones_like(depths), [ht, wd])\\n\\n depth = depth / (count + EPS)\\n self.outputs['depth_reprojection'] = depth\",\n \"def dimensions():\",\n \"def draw(self):\\n\\n super().draw()\\n \\n self.dim = self.getdim()\\n start_x, start_y, = self.x(), self.y()\\n\\n for y in range(self.r):\\n for x in range(self.c):\\n x_pos, y_pos = start_x + (self.dim * x), start_y + (self.dim * y)\\n self.tiles[y][x].resize(x_pos, y_pos, self.dim, self.dim)\",\n \"def edit(self):\\n wmap = 512\\n if not self.mapd:\\n data = self.data[24:]\\n mapd = self.mapd = []\\n for index in xrange(0,3*wmap*wmap,3):\\n mapd.append(data[index:index+3])\\n self.setChanged()\",\n \"def resize_volumes(x, depth_factor, height_factor, width_factor, data_format='channels_last'):\\n if data_format == 'channels_first':\\n output = repeat_elements(x, depth_factor, axis=2)\\n output = repeat_elements(output, height_factor, axis=3)\\n output = repeat_elements(output, width_factor, axis=4)\\n return output\\n elif data_format == 'channels_last':\\n output = repeat_elements(x, depth_factor, axis=1)\\n output = repeat_elements(output, height_factor, axis=2)\\n output = repeat_elements(output, width_factor, axis=3)\\n return output\\n else:\\n raise ValueError('Invalid data_format:', data_format)\",\n \"def initiate_memory(self):\\n rows = constants.WINDOW_HEIGHT / constants.GRID_TILE_LENGTH\\n cols = constants.WINDOW_WIDTH / constants.GRID_TILE_LENGTH\\n self.memory = [[None for x in xrange(cols)] for x in xrange(rows)]\",\n \"def show_rgbd(self):\\n while self.depth_data is None:\\n pass\\n\\n while not rospy.is_shutdown():\\n rospy.Rate(10).sleep()\\n d = self.depth_data * self.cam.DEPTH_UNIT\\n d = cv2.applyColorMap(d.astype(np.uint8), cv2.COLORMAP_RAINBOW)\\n dc = np.concatenate((d, self.rgb_data), axis=1)\\n cv2.imshow('RGB & Depth Image', dc)\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\n break\\n cv2.destroyAllWindows()\",\n \"def __init__(self, width, height):\\n self.clean_tiles = []\\n self.width = width\\n self.height = height\",\n \"def __init__(self, width, height):\\n self.w = width\\n self.h = height\\n self.cleanTiles = []\\n self.tiles = [[False] * width for i in range(height)]\\n self.cleaned = 0\",\n \"def run(self, depth):\\n\\t\\tdepth = depth.invert()\\n\\t\\t\\\"\\\"\\\"use this to convert it into cm, or into m by changing 10 to 100\\\"\\\"\\\"\\n\\t\\tdepth = divide(depth, 10)\\n\\t\\t\\\"\\\"\\\"Makes blobs easier to detect\\\"\\\"\\\"\\n\\t\\tdepth = depth.erode()\\n\\t\\tblob_array = self.blob_detect(depth)\\n\\t\\tif blob_array:\\n\\t\\t\\ttheadau_array = self.get_theadaus(blob_array)\\n\\t\\t\\tprint theadau_array\\n\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\tUntill i fill in outside coord array, i will get rid of this code\\n\\t\\t\\toutside_coord_array = self.get_outside_points(blob_array)\\n\\t\\t\\tblob_width_array = self.get_width(outside_coord_array, theadau_array)\\n\\t\\t\\treturn blob_width_array\\t\\n\\t\\t\\t\\\"\\\"\\\"\\t\\n\\t\\treturn blob_array\",\n \"def resize(self):\\n pass\",\n \"def depth_callback(self, data):\\n cv_image = self.bridge.imgmsg_to_cv2(data, desired_encoding=\\\"passthrough\\\")\\n self.depth_mutex.acquire()\\n self.depth_image = cv_image\\n self.depth_mutex.release()\",\n \"def polylinedictarraycopy(d):#d——原始图层多段线字典 \\r\\n dictlist=[]\\r\\n ratiolist=[] #放缩率列表\\r\\n rationumaccumulationlist=[] #放缩率数量累加列表\\r\\n \\r\\n eachrationum=globalconfig.X_ARRAY_NUM//globalconfig.RATIO_NUM\\r\\n leftrationum=globalconfig.X_ARRAY_NUM%globalconfig.RATIO_NUM\\r\\n \\r\\n eachrationumlist=[eachrationum]*globalconfig.RATIO_NUM #各个放缩率对应数量的列表\\r\\n \\r\\n for i in range((globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2,(globalconfig.RATIO_NUM-1)//2-(leftrationum-1)//2+leftrationum):\\r\\n eachrationumlist[i]=eachrationumlist[i]+1 #将整除后的余值加入到靠中间放缩率的方案中。\\r\\n \\r\\n rationumaccumulationlist.append(0) \\r\\n \\r\\n for i in range(1,globalconfig.RATIO_NUM): #计算放缩率数量累加列表\\r\\n rationumaccumulationlist.append(rationumaccumulationlist[i-1]+eachrationumlist[i-1])\\r\\n \\r\\n for i in range(0,globalconfig.RATIO_NUM): #计算放缩率列表\\r\\n ratiolist.append((globalconfig.CENTER_RATIO-((globalconfig.RATIO_NUM+1)//2-1)*globalconfig.RATIO_DIFF)+i*globalconfig.RATIO_DIFF) \\r\\n \\r\\n for i in range(0,globalconfig.RATIO_NUM): #每种放缩率\\r\\n for j in range(0,eachrationumlist[i]): #每种放缩率对应数量\\r\\n newdict={}\\r\\n for e in d: #将字典中值即每一图层对应的多段线列表进行复制并移动到指定位置\\r\\n newdict[e]=polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist)) \\r\\n #newdict.append([e,polylinedatasetarraycopy(d[e],ratiolist[i],globalconfig.CUTLINE_X_OFFSET+globalconfig.X_BLANK+(rationumaccumulationlist[i]+j+0.5)*globalconfig.X_LENGTH/globalconfig.CENTER_RATIO,globalconfig.CUTLINE_Y_OFFSET+globalconfig.Y_BLANK+0.5*globalconfig.Y_LENGTH/globalconfig.CENTER_RATIO,e,len(dictlist))])\\r\\n dictlist.append(newdict) \\r\\n return (dictlist,ratiolist,eachrationumlist)\",\n \"def __resize_to_32x(input_data):\\n rate = 1\\n while min(input_data['img'].shape[:2])>736:\\n test_size = 736\\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\\n if True: # input_data['img'].shape[1] < 512:\\n rate = test_size / input_data['img'].shape[1]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': \\\"keep-aspect-ratio\\\", 'width': test_size}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n else:\\n if True: # input_data['img'].shape[0] < 512:\\n rate = test_size / input_data['img'].shape[0]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': test_size, 'width': \\\"keep-aspect-ratio\\\"}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\\n input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\\n p_row = 0\\n while True:\\n if (input_data['img'].shape[0] + p_row) % 32 == 0:\\n break\\n p_row += 1\\n p_col = 0\\n while True:\\n if (input_data['img'].shape[1] + p_col) % 32 == 0:\\n break\\n p_col += 1\\n\\n input_data['img'] = np.pad(input_data['img'], ((0, p_row), (0, p_col), (0, 0)), mode='constant')\\n\\n return input_data\",\n \"def resize_function(input):\\n\\n from keras.backend import tf as ktf\\n return ktf.image.resize_images(input, (64, 64))\",\n \"def registerDepthFrame(self, frame):\\n h, w = frame.shape[:2]\\n frame = cv2.warpAffine(frame,self.depth2rgb_affine,(w,h))\\n\\n return frame\",\n \"def get_random_depth_sample(n=8, depths=list(range(2,26,2)), num_samples=100):\\n\\n def get_states(start):\\n frontier = [start]\\n frontier_set = {start}\\n explored = set()\\n\\n states = [False for _ in range(len(depths))]\\n while not all(states):\\n node = frontier.pop(0)\\n frontier_set.remove(node)\\n explored.add(node)\\n\\n children = node.get_children()\\n\\n # It's necessary to shuffle children to get a truly random sample; otherwise, the first child (always\\n # produced from the parent by the same action) produced at a certain depth will always be selected,\\n # and children produced by other actions will never be selected\\n shuffle(children)\\n\\n for child in children:\\n if child not in frontier_set and child not in explored:\\n frontier_set.add(child)\\n frontier.append(child)\\n child.path_cost = node.path_cost+1\\n index = depths.index(child.path_cost) if child.path_cost in depths else None\\n if index is not None and not states[index]:\\n states[index] = {'start': start.sequence, 'end': child.sequence}\\n\\n return states\\n\\n depth_sample = [[] for depth in range(len(depths))]\\n\\n for _ in range(num_samples):\\n start = list(range(1,n+2))\\n shuffle(start)\\n start = PuzzleState(start, path_cost=0)\\n\\n states = get_states(start)\\n print('\\\\rSet ' + str(_+1) + ' of ' + str(num_samples) + ' complete', end='', flush=True)\\n list(map(list.append, depth_sample, states))\\n\\n return depth_sample\",\n \"def upscale(x, n):\\n if n == 1:\\n return x\\n x_shape = tf.shape(x)\\n height, width = x_shape[1], x_shape[2]\\n return tf.image.resize_nearest_neighbor(x, [n * height, n * width])\\n # return tf.batch_to_space(tf.tile(x, [n**2, 1, 1, 1]), [[0, 0], [0, 0]], n)\",\n \"def resize(final_grid, alpha, beta):\\n # init the filter before resize\\n adjusted = cv2.convertScaleAbs(final_grid, alpha, beta)\\n sharpen_kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])\\n sharpen = cv2.filter2D(final_grid, -1, sharpen_kernel)\\n\\n # resize the map to the wanted size\\n map_w_border_row = WIDTH_G + 2\\n map_w_border_col = LENGTH_G + 2\\n vis_map = cv2.resize(sharpen, (map_w_border_col, map_w_border_row), cv2.INTER_AREA)\\n return vis_map\",\n \"def __init__(self,\\n name,\\n input_size,\\n state_size):\\n self._input_size = input_size\\n self._state_size = state_size\\n super(GRU, self).__init__(name)\",\n \"def sample(self, size=1):\\n pass\",\n \"def _get_depth_map_scale_subfolder(self):\\n if self.im_scale <= 0.25:\\n if self.im_scale <= 0.125:\\n return \\\"Depth/0.125/\\\"\\n else:\\n return \\\"Depth/0.25/\\\"\\n else: \\n return \\\"Depth/\\\"\",\n \"def reconstructed_data(self):\\n try:\\n data = np.sum(\\n np.array([\\n self.partial_reconstructed_data(i)\\n for i in range(self._max_level)\\n ]),\\n axis=0)\\n except MemoryError:\\n data = np.array(self.partial_reconstructed_data(0))\\n for i in range(1, self._max_level):\\n data = np.sum([data,\\n np.array(self.partial_reconstructed_data(i))], axis=0)\\n return data\",\n \"def positions(self, tileID, numSamples):\",\n \"def layers_sizes(self):\\n return iter([self.delta_h*l for l in range(int(self.h/self.delta_h)-1)])\",\n \"def _read_IntM_from_pdata(p_data, out_size=None, cam_id=2):\\n\\n # IntM = np.zeros((4,4))\\n raw_img_size = p_data.get_cam2(0).size if cam_id == 2 else p_data.get_cam3(0).size\\n width = int(raw_img_size[0])\\n height = int(raw_img_size[1])\\n IntM = p_data.calib.K_cam2 if cam_id == 2 else p_data.calib.K_cam3\\n focal_length = np.mean([IntM[0, 0], IntM[1, 1]])\\n h_fov = math.degrees(math.atan(IntM[0, 2] / IntM[0, 0]) * 2)\\n v_fov = math.degrees(math.atan(IntM[1, 2] / IntM[1, 1]) * 2)\\n\\n if out_size is not None: # the depth map is re-scaled #\\n camera_intrinsics = np.zeros((3, 3))\\n pixel_width, pixel_height = out_size[0], out_size[1]\\n camera_intrinsics[2, 2] = 1.\\n camera_intrinsics[0, 0] = IntM[0, 0] # (pixel_width/2.0)/math.tan(math.radians(h_fov/2.0))\\n camera_intrinsics[0, 2] = (pixel_width - 1)/2.0\\n camera_intrinsics[1, 1] = IntM[1, 1] # (pixel_height/2.0)/math.tan(math.radians(v_fov/2.0))\\n camera_intrinsics[1, 2] = (pixel_height - 1) /2.0\\n\\n IntM = camera_intrinsics\\n focal_length = pixel_width / width * focal_length\\n width, height = pixel_width, pixel_height\\n\\n\\n # In scanenet dataset, the depth is perperdicular z, not ray distance #\\n pixel_to_ray_array = View.normalised_pixel_to_ray_array(width=width, height=height,\\n hfov=h_fov, vfov=v_fov, normalize_z=True)\\n\\n pixel_to_ray_array_2dM = np.reshape(np.transpose( pixel_to_ray_array, axes=[2, 0, 1]), [3, -1])\\n pixel_to_ray_array_2dM = torch.from_numpy(pixel_to_ray_array_2dM.astype(np.float32))\\n cam_intrinsic = {\\n 'hfov': h_fov, 'vfov': v_fov,\\n 'unit_ray_array': pixel_to_ray_array,\\n 'unit_ray_array_2D': pixel_to_ray_array_2dM,\\n 'focal_length': focal_length,\\n 'intrinsic_M': IntM} \\n return cam_intrinsic\",\n \"def _resize(self, new_capacity):\\n temp_array = self.make_array(new_capacity)\\n for i in range(self.n):\\n temp_array[i] = self.original_array[i]\\n self.original_array = temp_array\\n self.capacity = new_capacity\",\n \"def __init__(self):\\n self.VideoFrame = np.array([])\\n self.DepthFrameRaw = np.array([]).astype(np.uint16)\\n \\\"\\\"\\\" Extra arrays for colormaping the depth image\\\"\\\"\\\"\\n self.DepthFrameHSV = np.zeros((480, 640, 3)).astype(np.uint8)\\n self.DepthFrameRGB = np.array([])\\n\\n \\\"\\\"\\\"initialize kinect & turn off auto gain and whitebalance\\\"\\\"\\\"\\n freenect.sync_get_video_with_res(resolution=freenect.RESOLUTION_HIGH)\\n # print(freenect.sync_set_autoexposure(False))\\n freenect.sync_set_autoexposure(False)\\n # print(freenect.sync_set_whitebalance(False))\\n freenect.sync_set_whitebalance(False)\\n \\\"\\\"\\\"check depth returns a frame, and flag kinectConnected\\\"\\\"\\\"\\n if(freenect.sync_get_depth_with_res(format=freenect.DEPTH_11BIT) == None):\\n self.kinectConnected = False\\n else:\\n self.kinectConnected = True\\n\\n # mouse clicks & calibration variables\\n self.depth2rgb_affine = np.array(list(csv.reader(open(\\\"depth2rgb_affine.cfg\\\"))), dtype=float)\\n self.kinectCalibrated = False\\n self.last_click = np.array([0, 0])\\n self.new_click = False\\n self.rgb_click_points = np.zeros((5, 2), int)\\n self.depth_click_points = np.zeros((5, 2), int)\\n\\n \\\"\\\"\\\" block info \\\"\\\"\\\"\\n self.block_contours = np.array([])\\n self.block_detections = np.array([])\\n\\n \\\"\\\"\\\"camera calibration\\\"\\\"\\\"\\n self.cam_int_mat = [] # np.array([])\\n self.cam_ext_mat = []\\n self.dist_coeffs = []\\n\\n \\\"\\\"\\\"depth info\\\"\\\"\\\"\\n self.max_depth = 0.95\\n self.affine_transform = False\",\n \"def _reshape(self, data):\\n\\n\\t\\t\\td = np.zeros((32,32,3))\\n\\t\\t\\td_r = data[0:1024].reshape(32,32)\\n\\t\\t\\td_g = data[1024:2048].reshape(32,32)\\n\\t\\t\\td_b = data[2048:].reshape(32,32)\\n\\n\\t\\t\\tfor h in range(32):\\n\\t\\t\\t for w in range(32):\\n\\t\\t\\t for c in range(3):\\n\\n\\t\\t\\t if c == 0 : d[h,w,c] = d_r[h,w]\\n\\t\\t\\t elif c == 1 : d[h,w,c] = d_g[h,w]\\n\\t\\t\\t else : d[h,w,c] = d_b[h,w]\\n\\n\\t\\t\\tarray = np.array(d, dtype=np.uint8)\\n\\t\\t\\timg = Image.fromarray(array)\\n\\t\\t\\ttemp = img.resize(size = (64,64))\\n\\t\\t\\td = image.img_to_array(temp)\\n\\n\\t\\t\\t#plt.imshow(d)\\n\\t\\t\\t#plt.show()\\n\\t\\t\\treturn d\",\n \"def registerDepthFrame(self, frame):\\n frame = cv2.warpAffine(frame, self.depth2rgb_affine,\\n (frame.shape[1], frame.shape[0]))\\n return frame\",\n \"def zoom_to_size(self, *p):\\n\\t\\tif self.image is None or self.allocation is None:\\n\\t\\t\\treturn\\n\\t\\tif __debug__: print self.allocation.width, self.image.get_width()\\n\\t\\tif __debug__: print self.allocation.width, self.image.get_width(), self.allocation.width/self.image.get_width()\\n\\t\\tz = min(\\n\\t\\t\\tself.allocation.width/self.image.get_width(),\\n\\t\\t\\tself.allocation.height/self.image.get_height()\\n\\t\\t\\t)\\n\\t\\tif __debug__: print \\\"zoom_to_size\\\", \\\"z=\\\", z\\n\\t\\tself.zoom = z\",\n \"def resizeGL(self,Width,Height):\\n return\",\n \"def getDimensions():\",\n \"def _set_z_size(self):\\n self._level_gen.size = (self._level_gen.size[X],\\n self._level_gen.size[Y],\\n self._level_size_z_spinbox.value())\\n self._refresh_view()\",\n \"def generate_depth_image(self, cloud):\\n points = self.get_hand_points(cloud)\\n\\n im1 = self.compute_height_map(points, 2)\\n im2 = self.compute_height_map(points, 1)\\n im3 = self.compute_height_map(points, 0)\\n\\n im1 = grey_dilation(im1, size=3)\\n im2 = grey_dilation(im2, size=3)\\n im3 = grey_dilation(im3, size=3)\\n\\n self.image = np.stack((im1, im2, im3), 0)\",\n \"def _convert_to_depth(self, dist):\\n return self.dist_to_bottom - dist\",\n \"def _shrink(values, last_dim, reduction_factor):\\n\\n shape = tf.shape(values)\\n new_shape = [\\n shape[0],\\n shape[1] // reduction_factor,\\n last_dim * reduction_factor\\n ]\\n values = tf.reshape(values, new_shape)\\n return values\",\n \"def __init__(self, size: int):\\n self.size = size\\n self.window = []\",\n \"def _conv_filter(state_dict, patch_size=16):\\n out_dict = {}\\n for k, v in state_dict.items():\\n if 'patch_embed.proj.weight' in k:\\n v = v.reshape((v.shape[0], 3, patch_size, patch_size))\\n out_dict[k] = v\\n return out_dict\",\n \"def _get_state_sizes(self):\\n ds = self.builder.nodes[self.ds_inputs[0]]\\n return [[ds.xdim]]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6338632","0.5834115","0.5815747","0.5748118","0.5644575","0.5589045","0.5579177","0.55736023","0.55167085","0.5504079","0.5475519","0.5465852","0.5462426","0.54406005","0.5418562","0.5378243","0.53638965","0.5361241","0.53567934","0.53504694","0.53395516","0.5331368","0.5325652","0.5319759","0.53159046","0.5297023","0.52931947","0.52880865","0.52718633","0.526757","0.5252036","0.5251792","0.5244948","0.52383435","0.52344507","0.5219603","0.5212777","0.5210962","0.5207473","0.5189559","0.5188086","0.5181749","0.5159597","0.5154825","0.5152439","0.5152138","0.51510483","0.5148803","0.5148803","0.5146035","0.5145797","0.5141703","0.51228124","0.5122621","0.5118355","0.51165026","0.51157135","0.51062083","0.510576","0.51049536","0.51041096","0.51014316","0.5100966","0.50911844","0.50843513","0.5076791","0.5068638","0.5062257","0.50609225","0.50490826","0.5045458","0.5031361","0.50181806","0.50171894","0.501038","0.5001917","0.499579","0.4994159","0.4989336","0.49859062","0.49848327","0.49847427","0.49841553","0.49830925","0.4972941","0.49707332","0.4963628","0.49555162","0.4952466","0.49484813","0.4946278","0.4943511","0.49417704","0.49391788","0.49386057","0.49368674","0.4933824","0.4933645","0.4932264","0.49272478","0.49237806"],"string":"[\n \"0.6338632\",\n \"0.5834115\",\n \"0.5815747\",\n \"0.5748118\",\n \"0.5644575\",\n \"0.5589045\",\n \"0.5579177\",\n \"0.55736023\",\n \"0.55167085\",\n \"0.5504079\",\n \"0.5475519\",\n \"0.5465852\",\n \"0.5462426\",\n \"0.54406005\",\n \"0.5418562\",\n \"0.5378243\",\n \"0.53638965\",\n \"0.5361241\",\n \"0.53567934\",\n \"0.53504694\",\n \"0.53395516\",\n \"0.5331368\",\n \"0.5325652\",\n \"0.5319759\",\n \"0.53159046\",\n \"0.5297023\",\n \"0.52931947\",\n \"0.52880865\",\n \"0.52718633\",\n \"0.526757\",\n \"0.5252036\",\n \"0.5251792\",\n \"0.5244948\",\n \"0.52383435\",\n \"0.52344507\",\n \"0.5219603\",\n \"0.5212777\",\n \"0.5210962\",\n \"0.5207473\",\n \"0.5189559\",\n \"0.5188086\",\n \"0.5181749\",\n \"0.5159597\",\n \"0.5154825\",\n \"0.5152439\",\n \"0.5152138\",\n \"0.51510483\",\n \"0.5148803\",\n \"0.5148803\",\n \"0.5146035\",\n \"0.5145797\",\n \"0.5141703\",\n \"0.51228124\",\n \"0.5122621\",\n \"0.5118355\",\n \"0.51165026\",\n \"0.51157135\",\n \"0.51062083\",\n \"0.510576\",\n \"0.51049536\",\n \"0.51041096\",\n \"0.51014316\",\n \"0.5100966\",\n \"0.50911844\",\n \"0.50843513\",\n \"0.5076791\",\n \"0.5068638\",\n \"0.5062257\",\n \"0.50609225\",\n \"0.50490826\",\n \"0.5045458\",\n \"0.5031361\",\n \"0.50181806\",\n \"0.50171894\",\n \"0.501038\",\n \"0.5001917\",\n \"0.499579\",\n \"0.4994159\",\n \"0.4989336\",\n \"0.49859062\",\n \"0.49848327\",\n \"0.49847427\",\n \"0.49841553\",\n \"0.49830925\",\n \"0.4972941\",\n \"0.49707332\",\n \"0.4963628\",\n \"0.49555162\",\n \"0.4952466\",\n \"0.49484813\",\n \"0.4946278\",\n \"0.4943511\",\n \"0.49417704\",\n \"0.49391788\",\n \"0.49386057\",\n \"0.49368674\",\n \"0.4933824\",\n \"0.4933645\",\n \"0.4932264\",\n \"0.49272478\",\n \"0.49237806\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88995,"cells":{"query":{"kind":"string","value":"resize image using cv2"},"document":{"kind":"string","value":"def scale_image(image, scale=1, interpolation='linear'):\n if interpolation == 'linear':\n return cv2.resize(image, None, fx=scale, fy=scale, interpolation=cv2.INTER_LINEAR)\n if interpolation == 'nearest':\n return cv2.resize(image, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST)"},"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 resize(image):\r\n return cv2.resize(image, (200, 66), interpolation=cv2.INTER_AREA)","def resize_image(img, width, height):\n\n return cv2.resize(img, (width, height))","def resize_image(image_path):\n img = cv2.imread(image_path);\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB);\n img = cv2.resize(img, (IMAGE_SIZE,IMAGE_SIZE), interpolation=cv2.INTER_AREA);\n return img;","def resize(img, size):\n img = cv2.resize(img, tuple(size[::-1]))\n return img","def __resize_image(self, img):\n return cv2.resize(img, self.g.img_size, \n interpolation = cv2.INTER_CUBIC)","def resizeImage(image, newSize):\n\n # scale image\n scaledImage = cv2.resize(image, newSize)\n return scaledImage","def resize(image):\n return cv2.resize(image, (320, 160), interpolation=cv2.INTER_AREA)","def resize(image):\n\treturn cv2.resize(image, \n\t\t\t\t\t (FACE_WIDTH, FACE_HEIGHT), \n\t\t\t\t\t interpolation=cv2.INTER_LANCZOS4)","def resizeImages(img_path,size=(50,50)):\n image = cv2.imread(img_path)\n resized = cv2.resize(image, size, interpolation=cv2.INTER_CUBIC)\n img=np.array([resized.flatten()])\n #print('resized image')\n return img","def resize_image(image, target_size):\n image = cv2.resize(image, target_size)\n return image","def resize_img(img, width, height):\n return cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA)","def resize_for_interface(cv_img):\n\n height, width, channels = cv_img.shape\n width_ratio = width / Images.IMAGES_WIDTH\n height_ratio = height / Images.IMAGES_HEIGHT\n\n ratio = max(width_ratio, height_ratio)\n\n if ratio > 1:\n new_size = (int(width / ratio), int(height / ratio))\n return cv2.resize(cv_img, new_size)\n else:\n # No need to resize\n return cv_img","def resize_128(img): \n return cv2.resize(img,(128,128))","def resize(img, height=800):\n ratio = height / img.shape[0]\n return cv2.resize(img, (int(ratio * img.shape[1]), height))","def resize(self, new_size):\n resized_img = opencv.resize(self.img, new_size)\n return Image(resized_img)","def process_image(fl):\n #print(\"processing of images\")\n print(fl)\n img = cv2.imread(fl, cv2.IMREAD_COLOR)\n resized_img = cv2.resize(img, (146, 243), interpolation=cv2.INTER_CUBIC)\n return resized_img","def resize(img, height=800):\n if img.shape[0] > height:\n ratio = height / img.shape[0]\n return cv2.resize(img, (int(ratio * img.shape[1]), height))","def resize_image(image, new_size):\n height, width = image.shape[:2]\n quad_size = min(height, width)\n\n if len(image.shape) == 3:\n cropped_image = image[:quad_size, :quad_size, :]\n else:\n cropped_image = image[:quad_size, :quad_size]\n\n resized_image = cv2.resize(cropped_image, (new_size, new_size))\n\n return resized_image","def resize(fname, width, height):\n image = cv2.imread(fname) # read priginal image\n cv2.imshow('Original Image', image) # show original image\n cv2.waitKey(0) # stop\n\n org_height, org_width = image.shape[0:2] # original width and height\n\n # print width and height\n print(\"width\", org_width)\n print(\"height\", org_height)\n\n # check image height and width and resize to new size\n if org_width >= org_height:\n new_image = cv2.resize(image, (width, height))\n else:\n new_image = cv2.resize(image, (height, width))\n\n return fname, new_image","def resize_image():\r\n print(\"--- resizing the image ---\")\r\n if args.image:\r\n img = cv2.imread(args.image)\r\n img = cv2.resize(img, (32, 32))\r\n img = np.array(img, dtype=np.uint8)\r\n img = img.reshape(32, 32, 3) / 255\r\n img = np.expand_dims(img, axis=0)\r\n print(\"--- done resizing the image ---\")\r\n return img\r\n else:\r\n print(\"Please enter a path of an image to check for it's label\")","def resize_image(img, image_width=128):\n # compute scale to resize the image\n scale = image_width / img.shape[1]\n\n # resize the image with the computed scale\n img = cv2.resize(img, None, fx=scale, fy=scale)\n\n return img","def resize_img(img, fx=.5, fy=.5, interpolation=cv2.INTER_LINEAR):\n return cv2.resize(img, None, fx=fx, fy=fy, interpolation=interpolation)","def transform_image(img, new_shape):\n img = img[0:720, 0:720]\n img = cv2.resize(img, (new_shape, new_shape)) / 255\n img = np.expand_dims(img, axis=0) # 3D to 4D\n return img","def rescale_image(image, scale=0.50):\r\n \r\n wi = int(image.shape[1]*scale)\r\n hei = int(image.shape[0]*scale)\r\n dimension = (wi, hei)\r\n return cv.resize(image, dimension, interpolation = cv.INTER_AREA)","def scale_image(img, factor=1):\n\treturn cv2.resize(img,(int(img.shape[1]*factor), int(img.shape[0]*factor)))","def resize(frame: Frame):\n\n frame.img = cv2.resize(frame.img, (720, 480))\n frame.orginal_img = cv2.resize(frame.orginal_img, (720, 480))\n\n return frame","def resize(img, size, method=\"bilinear\"):\n if method == Image.BILINEAR or method == \"bilinear\":\n method = cv2.INTER_AREA\n elif method == Image.CUBIC or method == \"cubic\":\n method = cv2.INTER_CUBIC\n elif method == Image.NEAREST or method == \"nearest\":\n method = cv2.INTER_NEAREST\n else:\n raise RuntimeError(\"wrong method {}\".format(method))\n if not isinstance(size, (tuple, list)):\n size = (size, size)\n if isinstance(size ,list):\n size = tuple(size)\n im = np.array(img)\n im = cv2.resize(im, size, interpolation=method)\n return Image.fromarray(im)","def resize_image(image, side):\n cv2.imshow(\"Original\", image)\n small = cv2.resize(image, (side,side), interpolation = cv2.INTER_AREA)\n return small","def scale_image(img, factor=1):\n return cv2.resize(img, (int(img.shape[1] * factor), int(img.shape[0] * factor)))","def scale_image(img_path, ratio):\n img = cv2.imread(img_path)\n (h, w) = img.shape[:2]\n h = int(h * ratio)\n w = int(w * ratio)\n img = cv2.resize(img, (w, h))\n cv2.imwrite(img_path, img)","def prepareImg(img, height):\n assert img.ndim in (2, 3)\n if img.ndim == 3:\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n h = img.shape[0]\n factor = height / h\n return cv2.resize(img, dsize=None, fx=factor, fy=factor)","def resize_img(input_img, scale=1.1):\n if scale == 1.0:\n return input_img\n rows, cols, ch = input_img.shape\n d = rows * (scale - 1) # overall image size change from rows, cols, to rows - 2d, cols - 2d\n pts1 = np.float32([[d, d], [rows - 1 - d, d], [d, cols - 1 - d], [rows - 1 - d, cols - 1 - d]])\n pts2 = np.float32([[0, 0], [rows - 1, 0], [0, cols - 1], [rows - 1, cols - 1]])\n M = cv2.getPerspectiveTransform(pts1, pts2)\n dst = cv2.warpPerspective(input_img, M, (cols, rows), borderMode=1)\n return dst","def resize_image(img, size):\n width = int(img.shape[1])\n height = int(img.shape[0])\n new_width = 0\n crop = 0\n\n if width < height:\n new_width = size\n new_height = int((size * height) / width)\n crop = new_height - size\n img = cv2.resize(img, (new_width, new_height), 0, 0, cv2.INTER_CUBIC)\n half_crop = int(crop / 2)\n img = img[crop / 2:size + half_crop, :]\n else:\n new_height = size\n new_width = int((size * width) / height)\n crop = new_width - size\n img = cv2.resize(img, (new_width, new_height), 0, 0, cv2.INTER_CUBIC)\n half_crop = int(crop / 2)\n img = img[:, half_crop:size + half_crop]\n return img","def scale_down(image:np.array)->np.array:\n src = image\n scale_percent = 25\n width = int(src.shape[1] * scale_percent / 100)\n height = int(src.shape[0] * scale_percent / 100)\n dsize = (width, height)\n output = cv2.resize(src, dsize)\n return output","def resize_image(image, resizeFactor):\n\n return cv.resize(image, (0,0), fx=resizeFactor, fy=resizeFactor)","def process(self):\n self.output_image = cv.resize(\n self.input_image,\n (self.WIDTH, self.HEIHGT),\n )\n return self.output_image","def np_resize(img, input_shape):\n height, width = input_shape\n return cv2.resize(img, (width, height))","def np_resize(img, input_shape):\n height, width = input_shape\n return cv2.resize(img, (width, height))","def opencv_resize(image_path, width=None, height=None, inter=cv2.INTER_CUBIC, mode=0):\n # initialize the dimensions of the cv2_image to be resized and\n # grab the cv2_image size\n dim = None\n cv2_image = cv2.imread(image_path, mode)\n (h, w) = cv2_image.shape[:2]\n\n # if both the width and height are None, then return the\n # original cv2_image\n if width is None and height is None:\n return cv2_image\n\n # check to see if the width is None\n if width is None:\n # calculate the ratio of the height and construct the\n # dimensions\n r = height / float(h)\n dim = (int(w * r), height)\n\n # otherwise, the height is None\n else:\n # calculate the ratio of the width and construct the\n # dimensions\n r = width / float(w)\n dim = (width, int(h * r))\n\n # resize the cv2_image\n resized = cv2.resize(cv2_image, dim, interpolation=inter)\n\n # return the resized cv2_image\n return resized","def resize_if_big(im_cv):\n MAX_IMG_SIZE = 900 * 1024\n height, width, channels = im_cv.shape\n img_size = width * height * channels\n\n if channels != 3:\n print(\"image must be bgr24\")\n sys.exit(1)\n\n if img_size > MAX_IMG_SIZE:\n scale = math.sqrt(MAX_IMG_SIZE / img_size)\n im_cv = cv2.resize(im_cv, (0, 0), fx=scale, fy=scale)\n height, width, channels = im_cv.shape\n img_size_kb = int(width * height * channels/1024)\n print(f\"Scaled down to {width}x{height} ({img_size_kb} KB) to fit max size\")\n return im_cv","def resize(img, x_scale, y_scale, optimize=True):\n interpolation = cv.INTER_LINEAR\n\n # pick an optimized scaler if asked to\n if optimize:\n if x_scale > 1 and y_scale > 1:\n interpolation = cv.INTER_CUBIC\n else:\n interpolation = cv.INTER_AREA\n\n return cv.resize(\n img,\n None,\n fx=x_scale,\n fy=y_scale,\n interpolation=interpolation,\n )","def preprocessing(image, w, h):\n image = cv2.resize(image, (w, h))\n image = np.transpose(image, (2, 0, 1))\n image = image.reshape(1, 3, h, w)\n \n return image","def retinanet_resize_image(img, min_side=800, max_side=1333):\n # compute scale to resize the image\n scale = retinanet_compute_resize_scale(img.shape, min_side=min_side, max_side=max_side)\n # scale = round(scale, 4)\n # print(\"scale: \", scale)\n\n # resize the image with the computed scale\n img = cv2.resize(img, None, fx=scale, fy=scale)\n\n return img, scale","def preprocess(img: 'np.ndarray') -> 'np.ndarray':\n return cv2.resize(img, (45, 45), interpolation=cv2.INTER_AREA)[:,:,:3]","def imgProcessing(self):\n if (self.image_width > 320):\n self.cv_image = imutils.resize(self.cv_image, width = 320)\n else:\n pass\n\n \"\"\" optional -- image-mirrored \"\"\"\n # self.cv_image = cv2.flip(self.cv_image, 1)","def resizing(image, image_2, desire_width):\n\n height, width = image.shape[0:2]\n\n aspect_ratio = (width / height)\n\n new_width = desire_width\n\n new_height = int(round(new_width / aspect_ratio))\n\n standard_src = cv2.resize(image, (new_width, new_height))\n\n image_tocut = cv2.resize(image_2,(new_width, new_height))\n\n return standard_src, image_tocut","def img_resize(img, img_height):\n\n\timg_width = int(img_height*img.shape[1]/img.shape[0])\n\n\timg_pil = Image.fromarray(img) # convert array back to image\n\n\timg_pil_resize = img_pil.resize((img_width, img_height), Image.LANCZOS) # resize\n\n\treturn np.array(img_pil_resize)","def rescale_image(image: np.ndarray, scale: float) -> np.ndarray:\n (height, width) = image.shape[:2]\n new_dims = (int(width * scale), int(height * scale))\n return cv2.resize(image, new_dims, interpolation=cv2.INTER_CUBIC)","def process_image(image):\n image = resize(image)\n return image","def resize(image, size):\n return np.array(Image.fromarray(image).resize(size))","def image_resize(img, min_size=600, max_size=1000):\n C, H, W = img.shape\n scale1 = min_size / min(H, W)\n scale2 = max_size / max(H, W)\n scale = min(scale1, scale2)\n img = img / 255\n img = transform.resize(img, (C, H * scale, W * scale),\n mode='reflect', anti_aliasing=False)\n # img = pytorch_normalize(img)\n # img = caffe_normalize(img)\n return img","def img(ori_img, img_wid, img_hei):\n img_arr = cv2.imread(ori_img, cv2.IMREAD_GRAYSCALE)\n img_arr = cv2.resize(img_arr, (img_wid, img_hei))\n return img_arr","def read_image_and_resize(image_path: str,\n new_WH: Tuple[int, int]=(512, 512),\n save_dir: str=\"resize\") -> str:\n assert os.path.exists(save_dir) is True\n new_path = os.path.join(save_dir, os.path.basename(image_path))\n image = cv2.imread(image_path)\n image = cv2.resize(image, new_WH, interpolation=cv2.INTER_AREA)\n cv2.imwrite(new_path, image)\n\n return image_path","def np_resize(img,input_shape,graystyle=False):\n height,width = input_shape\n resized_img = cv2.resize(img,(width,height))\n\n if graystyle:\n resized_img = resized_img[...,None]\n return resized_img","def resize(path_to_image, width, height):\n\n fd_img = open(path_to_image, 'rb')\n img = Image.open(fd_img)\n img = resizeimage.resize_cover(img, [int(width), int(height)])\n img.save(path_to_image, img.format)\n fd_img.close()","def resize_img(img, max_side=1000):\n height, width = img.shape\n # if the image is small enough as is, return it unchanged\n if height <= 1000 and width <= 1000:\n return img\n dim = tuple()\n if height > width:\n scale_ratio = max_side / height\n dim = (int(width * scale_ratio), max_side)\n else:\n scale_ratio = max_side / width\n dim = (max_side, int(height * scale_ratio))\n return cv2.resize(img, dim, interpolation=cv2.INTER_AREA)","def downscale_image(img, bottom, x, y):\n width, height = tuple(img.shape[1::-1])\n img = img[int(round((1 - bottom) * (height - 1))):(height - 1), 1:(width - 1)]\n img = cv2.resize(img, (x, y))\n #img = cv2.Canny(img, 100, 200)\n ret, img = cv2.threshold(img, img.mean(), 255, cv2.THRESH_BINARY)\n return img","def resize(img, size, interpolation=Image.BILINEAR):\n\n if not _is_numpy_image(img):\n raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\n if not (isinstance(size, int) or (isinstance(size, collections.Iterable) and len(size) == 2)):\n raise TypeError('Got inappropriate size arg: {}'.format(size))\n\n if isinstance(size, int):\n size = (size, size)\n \n if img.dtype == np.int32:\n resized = img.astype(np.uint16)\n resized = cv2.resize(resized, size , interpolation)\n else:\n resized = cv2.resize(img, size , interpolation)\n resized = resized.astype(img.dtype)\n return resized","def resize(self, height=None, width=None):\n if width is not None and height is not None:\n self._img = cv2.resize(self._img, dsize=(width, height))\n return\n if width is not None:\n scale = float(width) / self._img.shape[1]\n elif height is not None:\n scale = float(height) / self._img.shape[0]\n else:\n raise ValueError('At least width or height should be provided.')\n self._img = cv2.resize(\n self._img,\n dsize=(0, 0),\n fx=scale,\n fy=scale,\n interpolation=cv2.INTER_LINEAR)","def resize_image(image_data, resize_factor = 0.5):\n \n # calculate new shape:\n width_new = int(resize_factor*image_data.shape[1]);\n height_new = int(resize_factor*image_data.shape[0]);\n \n # return result:\n return _cv2.resize(image_data,\n (width_new, height_new),\n interpolation = _cv2.INTER_AREA);","def resize(file_path, width, height):\n folder, file_name, ext = parse_file_path(file_path)\n url = addr + '/img/resize'\n\n img = cv2.imread(file_path)\n _, img_encoded = cv2.imencode('.jpg', img)\n payload = img_encoded.tostring()\n \n response = requests.post(url, data=payload, params = {'w':width, 'h':height})\n if response.status_code != 200:\n print(json.load(response.content))\n return None\n \n img_array = uncompress_nparr(response.content)\n file_path = os.path.join(folder, file_name, + '_' + random_string() + '-resized' + ext)\n cv2.imwrite(file_path, img_array)\n return file_path","def _resize_img(self, results):\n for key in results.get('img_fields', ['img']):\n if self.keep_ratio:\n img, scale_factor = mmcv.imrescale(\n results[key],\n results['scale'],\n return_scale=True,\n interpolation=self.interpolation,\n backend=self.backend)\n # the w_scale and h_scale has minor difference\n # a real fix should be done in the mmcv.imrescale in the future\n new_h, new_w = img.shape[:2]\n h, w = results[key].shape[:2]\n w_scale = new_w / w\n h_scale = new_h / h\n else:\n img, w_scale, h_scale = mmcv.imresize(\n results[key],\n results['scale'],\n return_scale=True,\n interpolation=self.interpolation,\n backend=self.backend)\n results[key] = img\n\n scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],\n dtype=np.float32)\n results['img_shape'] = img.shape\n # in case that there is no padding\n results['pad_shape'] = img.shape\n results['scale_factor'] = scale_factor\n results['keep_ratio'] = self.keep_ratio","def resize_image(img: npt.ArrayLike, target_size: tuple(int, int)) -> npt.ArrayLike:\n\n ht, wt = target_size\n h, w = img.shape\n # scaling coefficient\n sc = min(wt / w, ht / h)\n tx = (wt - w * sc) / 2\n ty = (ht - h * sc) / 2\n \n # M = [[x_scale, x_shear, X_up_left], \n # [y_shear, y_scale, Y_up_left]]\n M = np.float32([[sc, 0, tx], [0, sc, ty]])\n img = cv2.warpAffine(img, M, dsize=(wt, ht), borderValue=0)\n\n return img / 255.","def resize_image(image_path: str, image_resolution: float):\n\timage = read_image(image_path)\n\tcurrent_height, current_width = image.shape[0:-1]\n\tratio = image_resolution / base_resolution\n\tdimensions = (\n\t\tmath.ceil(current_width * ratio), math.ceil(current_height * ratio))\n\treturn cv.resize(image, dimensions, interpolation=cv.INTER_AREA)","def transform( img, shape, keep_aspect = False, verbose = 0 ):\n for i in range( 3 ):\n img[:, :, i] = cv2.equalizeHist(img[:, :, i])\n img2 = resize(img, shape, keep_aspect, verbose = verbose )\n return img2","def scale_img(img, scale=1.0):\n dim = (int(img.shape[1]*scale), int(img.shape[0]*scale))\n return cv2.resize(img.copy(), dim, interpolation=cv2.INTER_AREA)","def preprocessImage(img):\n shape = img.shape\n img = img[math.floor(shape[0]/4) : shape[0] - 25, 0:shape[1]]\n img = cv2.resize(img, (img_columns, img_rows), interpolation = cv2.INTER_AREA)\n return img","def resizeImage(IMG,IMAGE_SIZE):\n\n RESCALED_IMAGE = skimage.transform.resize(IMG,[IMG.shape[0],IMAGE_SIZE,IMAGE_SIZE])\n return RESCALED_IMAGE","def set_size(self, size=None):\n if not size:\n size = self.output_size\n self.img = cv2.resize(self.img, size)\n self.update_image()\n self.update_size()","def resize(x, output_shape):\n if not _available:\n raise ValueError('cv2 is not installed on your environment, '\n 'so nothing will be plotted at this time. '\n 'Please install OpenCV.\\n\\n Under Anaconda '\n ' environment, you can install it by '\n '$ conda install -c menpo opencv=2.4.11\\n')\n\n H, W = output_shape\n x = x.transpose(1, 2, 0)\n x = cv2.resize(x, dsize=(W, H))\n x = x.transpose(2, 0, 1)\n return x","def _np_resize_image(image, size, dtype='int'):\n if dtype == 'int':\n _size = (size[1], size[0]) # (H,W) to (W,H)\n return cv2.resize(image.astype('uint8'),\n _size,\n interpolation=cv2.INTER_LINEAR)\n elif dtype == 'float':\n return skresize(image,\n size,\n order=0,\n mode='constant',\n preserve_range=True)\n else:\n raise NotImplementedError(f\"'{dtype}' is not a valid dtype.\")","def prepare(img,\n resize=False, new_size=(64, 64),\n apply_contrast=False, contrast_channels=(0, 1, 2)\n ):\n new_img = crop(img)\n\n if resize:\n new_img = cv2.resize(new_img, new_size)\n\n if apply_contrast:\n new_img = increase_contrast(new_img, channels=contrast_channels)\n\n return new_img","def resize(img):\n size = (500, 500)\n img.thumbnail(size)\n return img","def resize_image(img, final_height, final_width):\n resized_img = tf.image.resize(tf.image.convert_image_dtype(img, tf.float32), (final_height, final_width))\n return tf.image.convert_image_dtype(resized_img, tf.uint8)","def resize_image(img):\n ratio = float(img.size[1]) / float(img.size[0])\n\n if ratio > 1.73:\n h, w = 320, 160 # 512, 256\n elif ratio < 1.0 / 1.73:\n h, w = 160, 320 # 256, 512\n elif ratio > 1.41:\n h, w = 384, 256\n elif ratio < 1. / 1.41:\n h, w = 256, 384\n elif ratio > 1.15:\n h, w = 320, 240 # 512, 384\n elif ratio < 1. / 1.15:\n h, w = 240, 320 # 384, 512\n else:\n h, w = 320, 320 # 384, 384\n\n h = int(h)\n w = int(w)\n img = TF.resize(img, size=[h, w], interpolation=Image.BILINEAR)\n return img","def rescaleFrame(frame, scale=.75):\n\n\twidth = int(frame.shape[1] * scale)\n\theight = int(frame.shape[0] * scale)\n\n\tdimensions = (width, height)\n\t\n\treturn cv.resize(frame, dimensions, interpolation=cv.INTER_AREA)","def resize(im, target_size, max_size):\n im_shape = im.shape\n im_size_min = np.min(im_shape[0:2])\n im_size_max = np.max(im_shape[0:2])\n im_scale = float(target_size) / float(im_size_min)\n # prevent bigger axis from being more than max_size:\n if np.round(im_scale * im_size_max) > max_size:\n im_scale = float(max_size) / float(im_size_max)\n im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)\n return im, im_scale","def image_resize(image):\n print(\"image-resizing2\")\n\n i=0\n height,width = image.shape[:2]\n shape = [height,width]\n if len(image_shape) == 0:\n #print(\"Intial\")\n image_shape.append(shape)\n resized = cv2.resize(image,(int(width*0.2),int(height*0.2)),interpolation=cv2.INTER_CUBIC)\n else:\n for old_shape in image_shape:\n #print(\"second\")\n if old_shape == shape:\n i=0\n break\n else:\n i+=1\n if(i > 0):\n #print(\"third\")\n image_shape.append(shape)\n resized = cv2.resize(image, (int(width * 0.2), int(height * 0.2)), interpolation=cv2.INTER_CUBIC)\n return resized,shape","def resize( img, shape, keep_aspect, verbose = 0 ):\n if keep_aspect == True:\n scale = min( np.array( shape, dtype = float ) / np.array( img.shape[0:2] ) )\n shape2 = tuple( ( scale * np.array( img.shape[0:2] ) ).astype( int ) )\n img2 = np.zeros( (shape[0],shape[1],3), dtype = img.dtype )\n for i in range( img2.shape[2] ):\n img2[:,:,i] = np.mean( np.mean( img[:,:,i] ) )\n img2[0:shape2[0],0:shape2[1],0:3] = cv2.resize( img, shape2[::-1], interpolation = cv2.INTER_CUBIC )\n else:\n img2 = cv2.resize(img, shape, interpolation = cv2.INTER_CUBIC)\n shape2 = shape\n if verbose > 0:\n print( \"image.shape %s resized to %s (resize_shape = %s, desired=%s)\" % ( \n list( img.shape ), list( img2.shape ), list( shape2 ), list( shape ) ) )\n\n return img2","def shape_new_img(image_path):\n desired_size = 64\n img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\n new_img_array = cv2.resize(img, (desired_size, desired_size))\n finalarray = new_img_array.reshape(1, desired_size, desired_size, 1)\n\n return finalarray","def resize(img, size):\n img = tf.expand_dims(img, 0)\n return tf.image.resize_bilinear(img, size)[0,:,:,:]","def resize(img, size, interpolation=cv2.INTER_LINEAR):\n if not _is_numpy_image(img):\n raise TypeError('img should be nparrary Image. Got {}'.format(type(img)))\n if not (isinstance(size, int) or (isinstance(size, collections.Iterable) and len(size) == 2)):\n raise TypeError('Got inappropriate size arg: {}'.format(size))\n\n if isinstance(size, int):\n h, w = img.shape[:2]\n if (w <= h and w == size) or (h <= w and h == size):\n return img\n if w < h:\n ow = size\n oh = int(size * h / w)\n return cv2.resize(img, (ow, oh), interpolation)\n else:\n oh = size\n ow = int(size * w / h)\n return cv2.resize(img, (ow, oh), interpolation)\n else:\n return cv2.resize(img, tuple(size[::-1]), interpolation)","def resizeImage(image, newDimension):\r\n image = validateImage(image)\r\n if image is None:\r\n print(\"ERROR - resizeImage: Image is missing.\")\r\n return None\r\n\r\n if not isinstance(newDimension, tuple) or len(newDimension) != image.ndim:\r\n print(\"ERROR - resizeImage: Specified dimension is illegal. Dimension=\", len(newDimension), \", ImageDimension=\",\r\n image.ndim)\r\n return None\r\n\r\n return cv2.resize(image, newDimension)","def preprocess(path, img_w, img_h):\n #print(path)\n img = cv2.imread(path)\n #print(img.shape)\n #resizing the image to particular size (64, 128, 3)\n img = fix_size(img, img_w, img_h)\n #print(img.shape)\n \n #assigining values less than zero to zer0 and greater than zero to 1\n img = np.clip(img, 0, 255)\n\n #changing the interger to more useful and complex integer\n img = np.uint8(img)\n\n #convert an image to one color space to another\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n \n #chaging the values datatype to float\n img = img.astype(np.float32)\n\n #normalization\n img /= 255\n return img","def showResized(name, image, scale):\n image = resizeImage(image, scale)\n cv.ShowImage(name, image)","def resize_image(image_path):\n image = Image.open(image_path)\n\n imagefit = ImageOps.fit(image, (612, 612), Image.ANTIALIAS)\n imagefit.save(image_path, 'JPEG', quality=100)","def image_resize(image: Image, size: (int, int)) -> array:\n image = Image.fromarray(uint8(image))\n\n return array(image.resize(size))","def img_zoom(img, fx, fy, interp=cv2.INTER_AREA):\n res = cv2.resize(img, None, fx=fx, fy=fy,\n interpolation=interp)\n return res","def resize(img, ratio=100, size=None, interpolation=None):\n\n def _interpolation_choice(interpolation):\n if interpolation is None: # Set a default\n if size is not None:\n if (ratio >= 100) or (size[0] >= img.shape[0]) or (size[1] >= img.shape[1]):\n interpolation = cv2.INTER_AREA\n else:\n interpolation = cv2.INTER_LINEAR\n else:\n if ratio >= 100:\n interpolation = cv2.INTER_AREA\n else:\n interpolation = cv2.INTER_LINEAR\n\n elif interpolation in [\"nearest\", cv2.INTER_NEAREST]:\n interpolation = cv2.INTER_NEAREST\n elif interpolation in [\"linear\", cv2.INTER_LINEAR]:\n interpolation = cv2.INTER_LINEAR\n elif interpolation in [\"area\", cv2.INTER_AREA]:\n interpolation = cv2.INTER_AREA\n else:\n interpolation = cv2.INTER_CUBIC\n \n return interpolation\n\n # Checks over ratio\n intdetector(ratio)\n if ratio <= 0:\n raise ValueError(\"Expected ratio parameter to be over zero\")\n\n # Checks over size if necessary\n if size is not None:\n intdetector(size[0])\n intdetector(size[1])\n if size[0] == img.shape[0] and size[1] == img.shape[1]:\n return img\n if size[0] < 0 or size[1] < 0:\n raise ValueError(\"Expected size parameter to be a tuple with values over 0\")\n\n interpolation = _interpolation_choice(interpolation)\n\n if ratio != 100: # Ratio has the priority if inputted\n size = ( int(img.shape[1] * ratio / 100), int(img.shape[0] * ratio / 100) )\n return cv2.resize(img, size, interpolation = interpolation)\n if size is not None: # If ratio has not been modified, let's check size if inputted\n return cv2.resize(img, size, interpolation = interpolation)\n else:\n return img","def read_image(src):\n im = cv2.imread(src, cv2.IMREAD_COLOR)\n im = cv2.resize(im, (COLS, ROWS), interpolation=cv2.INTER_CUBIC)\n return im","def imresize(img, size):\n if hasattr(size, \"__len__\"):\n num_rows, num_cols = size\n assert (num_rows > 0) or (num_cols > 0)\n if num_rows < 0:\n num_rows = num_cols * img.shape[0] / img.shape[1]\n if num_cols < 0:\n num_cols = num_rows * img.shape[1] / img.shape[0]\n else:\n num_rows = int(round(img.shape[0] * size))\n num_cols = int(round(img.shape[1] * size))\n return skimage.transform.resize(img, (num_rows, num_cols))","def preprocess_image(image, model_image_size):\n #resized_image = cv2.resize(image, tuple(reversed(model_image_size)), cv2.INTER_AREA)\n resized_image = letterbox_resize(image, tuple(reversed(model_image_size)))\n image_data = np.asarray(resized_image).astype('float32')\n image_data = normalize_image(image_data)\n image_data = np.expand_dims(image_data, 0) # Add batch dimension.\n return image_data","def resize(img,width):\n \n wpercent = float(width / float(img.size[0]))\n hsize = int((float(img.size[1])*float(wpercent)))\n img = img.resize((width ,hsize), Image.ANTIALIAS)\n\n return img","def resize(img,width):\n \n wpercent = float(width / float(img.size[0]))\n hsize = int((float(img.size[1])*float(wpercent)))\n img = img.resize((width ,hsize), Image.ANTIALIAS)\n\n return img","def cs4243_resize(image, new_width, new_height):\n new_image = np.zeros((new_height, new_width, 3), dtype='uint8')\n if len(image.shape)==2:\n new_image = np.zeros((new_height, new_width), dtype='uint8')\n ###Your code here###\n \n # if new_width < 0 or new_height < 0, np.zeros() will throw a ValueError.\n \n # if new_width == 0 or new_height == 0, we won't need to do any calculation.\n if new_width == 0 or new_height == 0:\n return new_image\n \n # resizing algorithm taken from\n # https://tech-algorithm.com/articles/nearest-neighbor-image-scaling/\n height, width = image.shape[0], image.shape[1]\n w_ratio = int(((width << 16) / new_width) + 1)\n h_ratio = int(((height << 16) / new_height) + 1)\n \n for h in range(new_height):\n for w in range(new_width):\n pw = int((w*w_ratio) >> 16)\n ph = int((h*h_ratio) >> 16)\n new_image[h,w] = image[ph, pw]\n ###\n return new_image","def resize_img(self,scale=1):\n reduced = self.image.reduce((scale,scale))\n reduced.save(\"../edited/{}\".format(self.image.filename))\n\n reduced = Image.open(\"../edited/{}\".format(self.image.filename))\n return reduced","def resize_image(image, size):\n return skimage.transform.resize(image, size, mode='reflect', preserve_range=True).astype(image.dtype)","def resize_image(image_path: str):\n image: Image.Image = Image.open(image_path)\n w = image.width\n h = image.height\n scale_factor = IMAGE_WIDTH_DEFAULT / w\n image.resize((int(w * scale_factor), int(h * scale_factor))).save(image_path)","def process_image(img_file):\n img = cv2.imread(img_file)\n img = cv2.resize(img, IMAGE_DIM).transpose(\n (2, 0, 1)).astype('float32') / 255.0\n return img","def resizeImage(img, scale=None, dims=None):\n if scale is not None:\n retImg = cv.CreateMat(int(img.rows * scale), int(img.cols * scale), img.type)\n elif dims is not None:\n retImg = cv.CreateMat(dims[1], dims[0], img.type)\n else:\n retImg = cv.CloneMat(img)\n cv.Resize(img, retImg)\n return retImg","def rescale_image(self, height: int, width: int, make_copy: bool = True):\n if make_copy:\n obj = copy.deepcopy(self)\n else:\n obj = self\n\n if obj.bgr is not None:\n obj.bgr = cv2.resize(obj.bgr, (width, height))\n if obj._hsv is not None:\n obj._hsv = cv2.resize(obj._hsv, (width, height))\n if obj.borders is not None:\n obj.borders = cv2.resize(obj.borders, (width, height))\n return obj if make_copy else None"],"string":"[\n \"def resize(image):\\r\\n return cv2.resize(image, (200, 66), interpolation=cv2.INTER_AREA)\",\n \"def resize_image(img, width, height):\\n\\n return cv2.resize(img, (width, height))\",\n \"def resize_image(image_path):\\n img = cv2.imread(image_path);\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB);\\n img = cv2.resize(img, (IMAGE_SIZE,IMAGE_SIZE), interpolation=cv2.INTER_AREA);\\n return img;\",\n \"def resize(img, size):\\n img = cv2.resize(img, tuple(size[::-1]))\\n return img\",\n \"def __resize_image(self, img):\\n return cv2.resize(img, self.g.img_size, \\n interpolation = cv2.INTER_CUBIC)\",\n \"def resizeImage(image, newSize):\\n\\n # scale image\\n scaledImage = cv2.resize(image, newSize)\\n return scaledImage\",\n \"def resize(image):\\n return cv2.resize(image, (320, 160), interpolation=cv2.INTER_AREA)\",\n \"def resize(image):\\n\\treturn cv2.resize(image, \\n\\t\\t\\t\\t\\t (FACE_WIDTH, FACE_HEIGHT), \\n\\t\\t\\t\\t\\t interpolation=cv2.INTER_LANCZOS4)\",\n \"def resizeImages(img_path,size=(50,50)):\\n image = cv2.imread(img_path)\\n resized = cv2.resize(image, size, interpolation=cv2.INTER_CUBIC)\\n img=np.array([resized.flatten()])\\n #print('resized image')\\n return img\",\n \"def resize_image(image, target_size):\\n image = cv2.resize(image, target_size)\\n return image\",\n \"def resize_img(img, width, height):\\n return cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA)\",\n \"def resize_for_interface(cv_img):\\n\\n height, width, channels = cv_img.shape\\n width_ratio = width / Images.IMAGES_WIDTH\\n height_ratio = height / Images.IMAGES_HEIGHT\\n\\n ratio = max(width_ratio, height_ratio)\\n\\n if ratio > 1:\\n new_size = (int(width / ratio), int(height / ratio))\\n return cv2.resize(cv_img, new_size)\\n else:\\n # No need to resize\\n return cv_img\",\n \"def resize_128(img): \\n return cv2.resize(img,(128,128))\",\n \"def resize(img, height=800):\\n ratio = height / img.shape[0]\\n return cv2.resize(img, (int(ratio * img.shape[1]), height))\",\n \"def resize(self, new_size):\\n resized_img = opencv.resize(self.img, new_size)\\n return Image(resized_img)\",\n \"def process_image(fl):\\n #print(\\\"processing of images\\\")\\n print(fl)\\n img = cv2.imread(fl, cv2.IMREAD_COLOR)\\n resized_img = cv2.resize(img, (146, 243), interpolation=cv2.INTER_CUBIC)\\n return resized_img\",\n \"def resize(img, height=800):\\n if img.shape[0] > height:\\n ratio = height / img.shape[0]\\n return cv2.resize(img, (int(ratio * img.shape[1]), height))\",\n \"def resize_image(image, new_size):\\n height, width = image.shape[:2]\\n quad_size = min(height, width)\\n\\n if len(image.shape) == 3:\\n cropped_image = image[:quad_size, :quad_size, :]\\n else:\\n cropped_image = image[:quad_size, :quad_size]\\n\\n resized_image = cv2.resize(cropped_image, (new_size, new_size))\\n\\n return resized_image\",\n \"def resize(fname, width, height):\\n image = cv2.imread(fname) # read priginal image\\n cv2.imshow('Original Image', image) # show original image\\n cv2.waitKey(0) # stop\\n\\n org_height, org_width = image.shape[0:2] # original width and height\\n\\n # print width and height\\n print(\\\"width\\\", org_width)\\n print(\\\"height\\\", org_height)\\n\\n # check image height and width and resize to new size\\n if org_width >= org_height:\\n new_image = cv2.resize(image, (width, height))\\n else:\\n new_image = cv2.resize(image, (height, width))\\n\\n return fname, new_image\",\n \"def resize_image():\\r\\n print(\\\"--- resizing the image ---\\\")\\r\\n if args.image:\\r\\n img = cv2.imread(args.image)\\r\\n img = cv2.resize(img, (32, 32))\\r\\n img = np.array(img, dtype=np.uint8)\\r\\n img = img.reshape(32, 32, 3) / 255\\r\\n img = np.expand_dims(img, axis=0)\\r\\n print(\\\"--- done resizing the image ---\\\")\\r\\n return img\\r\\n else:\\r\\n print(\\\"Please enter a path of an image to check for it's label\\\")\",\n \"def resize_image(img, image_width=128):\\n # compute scale to resize the image\\n scale = image_width / img.shape[1]\\n\\n # resize the image with the computed scale\\n img = cv2.resize(img, None, fx=scale, fy=scale)\\n\\n return img\",\n \"def resize_img(img, fx=.5, fy=.5, interpolation=cv2.INTER_LINEAR):\\n return cv2.resize(img, None, fx=fx, fy=fy, interpolation=interpolation)\",\n \"def transform_image(img, new_shape):\\n img = img[0:720, 0:720]\\n img = cv2.resize(img, (new_shape, new_shape)) / 255\\n img = np.expand_dims(img, axis=0) # 3D to 4D\\n return img\",\n \"def rescale_image(image, scale=0.50):\\r\\n \\r\\n wi = int(image.shape[1]*scale)\\r\\n hei = int(image.shape[0]*scale)\\r\\n dimension = (wi, hei)\\r\\n return cv.resize(image, dimension, interpolation = cv.INTER_AREA)\",\n \"def scale_image(img, factor=1):\\n\\treturn cv2.resize(img,(int(img.shape[1]*factor), int(img.shape[0]*factor)))\",\n \"def resize(frame: Frame):\\n\\n frame.img = cv2.resize(frame.img, (720, 480))\\n frame.orginal_img = cv2.resize(frame.orginal_img, (720, 480))\\n\\n return frame\",\n \"def resize(img, size, method=\\\"bilinear\\\"):\\n if method == Image.BILINEAR or method == \\\"bilinear\\\":\\n method = cv2.INTER_AREA\\n elif method == Image.CUBIC or method == \\\"cubic\\\":\\n method = cv2.INTER_CUBIC\\n elif method == Image.NEAREST or method == \\\"nearest\\\":\\n method = cv2.INTER_NEAREST\\n else:\\n raise RuntimeError(\\\"wrong method {}\\\".format(method))\\n if not isinstance(size, (tuple, list)):\\n size = (size, size)\\n if isinstance(size ,list):\\n size = tuple(size)\\n im = np.array(img)\\n im = cv2.resize(im, size, interpolation=method)\\n return Image.fromarray(im)\",\n \"def resize_image(image, side):\\n cv2.imshow(\\\"Original\\\", image)\\n small = cv2.resize(image, (side,side), interpolation = cv2.INTER_AREA)\\n return small\",\n \"def scale_image(img, factor=1):\\n return cv2.resize(img, (int(img.shape[1] * factor), int(img.shape[0] * factor)))\",\n \"def scale_image(img_path, ratio):\\n img = cv2.imread(img_path)\\n (h, w) = img.shape[:2]\\n h = int(h * ratio)\\n w = int(w * ratio)\\n img = cv2.resize(img, (w, h))\\n cv2.imwrite(img_path, img)\",\n \"def prepareImg(img, height):\\n assert img.ndim in (2, 3)\\n if img.ndim == 3:\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n h = img.shape[0]\\n factor = height / h\\n return cv2.resize(img, dsize=None, fx=factor, fy=factor)\",\n \"def resize_img(input_img, scale=1.1):\\n if scale == 1.0:\\n return input_img\\n rows, cols, ch = input_img.shape\\n d = rows * (scale - 1) # overall image size change from rows, cols, to rows - 2d, cols - 2d\\n pts1 = np.float32([[d, d], [rows - 1 - d, d], [d, cols - 1 - d], [rows - 1 - d, cols - 1 - d]])\\n pts2 = np.float32([[0, 0], [rows - 1, 0], [0, cols - 1], [rows - 1, cols - 1]])\\n M = cv2.getPerspectiveTransform(pts1, pts2)\\n dst = cv2.warpPerspective(input_img, M, (cols, rows), borderMode=1)\\n return dst\",\n \"def resize_image(img, size):\\n width = int(img.shape[1])\\n height = int(img.shape[0])\\n new_width = 0\\n crop = 0\\n\\n if width < height:\\n new_width = size\\n new_height = int((size * height) / width)\\n crop = new_height - size\\n img = cv2.resize(img, (new_width, new_height), 0, 0, cv2.INTER_CUBIC)\\n half_crop = int(crop / 2)\\n img = img[crop / 2:size + half_crop, :]\\n else:\\n new_height = size\\n new_width = int((size * width) / height)\\n crop = new_width - size\\n img = cv2.resize(img, (new_width, new_height), 0, 0, cv2.INTER_CUBIC)\\n half_crop = int(crop / 2)\\n img = img[:, half_crop:size + half_crop]\\n return img\",\n \"def scale_down(image:np.array)->np.array:\\n src = image\\n scale_percent = 25\\n width = int(src.shape[1] * scale_percent / 100)\\n height = int(src.shape[0] * scale_percent / 100)\\n dsize = (width, height)\\n output = cv2.resize(src, dsize)\\n return output\",\n \"def resize_image(image, resizeFactor):\\n\\n return cv.resize(image, (0,0), fx=resizeFactor, fy=resizeFactor)\",\n \"def process(self):\\n self.output_image = cv.resize(\\n self.input_image,\\n (self.WIDTH, self.HEIHGT),\\n )\\n return self.output_image\",\n \"def np_resize(img, input_shape):\\n height, width = input_shape\\n return cv2.resize(img, (width, height))\",\n \"def np_resize(img, input_shape):\\n height, width = input_shape\\n return cv2.resize(img, (width, height))\",\n \"def opencv_resize(image_path, width=None, height=None, inter=cv2.INTER_CUBIC, mode=0):\\n # initialize the dimensions of the cv2_image to be resized and\\n # grab the cv2_image size\\n dim = None\\n cv2_image = cv2.imread(image_path, mode)\\n (h, w) = cv2_image.shape[:2]\\n\\n # if both the width and height are None, then return the\\n # original cv2_image\\n if width is None and height is None:\\n return cv2_image\\n\\n # check to see if the width is None\\n if width is None:\\n # calculate the ratio of the height and construct the\\n # dimensions\\n r = height / float(h)\\n dim = (int(w * r), height)\\n\\n # otherwise, the height is None\\n else:\\n # calculate the ratio of the width and construct the\\n # dimensions\\n r = width / float(w)\\n dim = (width, int(h * r))\\n\\n # resize the cv2_image\\n resized = cv2.resize(cv2_image, dim, interpolation=inter)\\n\\n # return the resized cv2_image\\n return resized\",\n \"def resize_if_big(im_cv):\\n MAX_IMG_SIZE = 900 * 1024\\n height, width, channels = im_cv.shape\\n img_size = width * height * channels\\n\\n if channels != 3:\\n print(\\\"image must be bgr24\\\")\\n sys.exit(1)\\n\\n if img_size > MAX_IMG_SIZE:\\n scale = math.sqrt(MAX_IMG_SIZE / img_size)\\n im_cv = cv2.resize(im_cv, (0, 0), fx=scale, fy=scale)\\n height, width, channels = im_cv.shape\\n img_size_kb = int(width * height * channels/1024)\\n print(f\\\"Scaled down to {width}x{height} ({img_size_kb} KB) to fit max size\\\")\\n return im_cv\",\n \"def resize(img, x_scale, y_scale, optimize=True):\\n interpolation = cv.INTER_LINEAR\\n\\n # pick an optimized scaler if asked to\\n if optimize:\\n if x_scale > 1 and y_scale > 1:\\n interpolation = cv.INTER_CUBIC\\n else:\\n interpolation = cv.INTER_AREA\\n\\n return cv.resize(\\n img,\\n None,\\n fx=x_scale,\\n fy=y_scale,\\n interpolation=interpolation,\\n )\",\n \"def preprocessing(image, w, h):\\n image = cv2.resize(image, (w, h))\\n image = np.transpose(image, (2, 0, 1))\\n image = image.reshape(1, 3, h, w)\\n \\n return image\",\n \"def retinanet_resize_image(img, min_side=800, max_side=1333):\\n # compute scale to resize the image\\n scale = retinanet_compute_resize_scale(img.shape, min_side=min_side, max_side=max_side)\\n # scale = round(scale, 4)\\n # print(\\\"scale: \\\", scale)\\n\\n # resize the image with the computed scale\\n img = cv2.resize(img, None, fx=scale, fy=scale)\\n\\n return img, scale\",\n \"def preprocess(img: 'np.ndarray') -> 'np.ndarray':\\n return cv2.resize(img, (45, 45), interpolation=cv2.INTER_AREA)[:,:,:3]\",\n \"def imgProcessing(self):\\n if (self.image_width > 320):\\n self.cv_image = imutils.resize(self.cv_image, width = 320)\\n else:\\n pass\\n\\n \\\"\\\"\\\" optional -- image-mirrored \\\"\\\"\\\"\\n # self.cv_image = cv2.flip(self.cv_image, 1)\",\n \"def resizing(image, image_2, desire_width):\\n\\n height, width = image.shape[0:2]\\n\\n aspect_ratio = (width / height)\\n\\n new_width = desire_width\\n\\n new_height = int(round(new_width / aspect_ratio))\\n\\n standard_src = cv2.resize(image, (new_width, new_height))\\n\\n image_tocut = cv2.resize(image_2,(new_width, new_height))\\n\\n return standard_src, image_tocut\",\n \"def img_resize(img, img_height):\\n\\n\\timg_width = int(img_height*img.shape[1]/img.shape[0])\\n\\n\\timg_pil = Image.fromarray(img) # convert array back to image\\n\\n\\timg_pil_resize = img_pil.resize((img_width, img_height), Image.LANCZOS) # resize\\n\\n\\treturn np.array(img_pil_resize)\",\n \"def rescale_image(image: np.ndarray, scale: float) -> np.ndarray:\\n (height, width) = image.shape[:2]\\n new_dims = (int(width * scale), int(height * scale))\\n return cv2.resize(image, new_dims, interpolation=cv2.INTER_CUBIC)\",\n \"def process_image(image):\\n image = resize(image)\\n return image\",\n \"def resize(image, size):\\n return np.array(Image.fromarray(image).resize(size))\",\n \"def image_resize(img, min_size=600, max_size=1000):\\n C, H, W = img.shape\\n scale1 = min_size / min(H, W)\\n scale2 = max_size / max(H, W)\\n scale = min(scale1, scale2)\\n img = img / 255\\n img = transform.resize(img, (C, H * scale, W * scale),\\n mode='reflect', anti_aliasing=False)\\n # img = pytorch_normalize(img)\\n # img = caffe_normalize(img)\\n return img\",\n \"def img(ori_img, img_wid, img_hei):\\n img_arr = cv2.imread(ori_img, cv2.IMREAD_GRAYSCALE)\\n img_arr = cv2.resize(img_arr, (img_wid, img_hei))\\n return img_arr\",\n \"def read_image_and_resize(image_path: str,\\n new_WH: Tuple[int, int]=(512, 512),\\n save_dir: str=\\\"resize\\\") -> str:\\n assert os.path.exists(save_dir) is True\\n new_path = os.path.join(save_dir, os.path.basename(image_path))\\n image = cv2.imread(image_path)\\n image = cv2.resize(image, new_WH, interpolation=cv2.INTER_AREA)\\n cv2.imwrite(new_path, image)\\n\\n return image_path\",\n \"def np_resize(img,input_shape,graystyle=False):\\n height,width = input_shape\\n resized_img = cv2.resize(img,(width,height))\\n\\n if graystyle:\\n resized_img = resized_img[...,None]\\n return resized_img\",\n \"def resize(path_to_image, width, height):\\n\\n fd_img = open(path_to_image, 'rb')\\n img = Image.open(fd_img)\\n img = resizeimage.resize_cover(img, [int(width), int(height)])\\n img.save(path_to_image, img.format)\\n fd_img.close()\",\n \"def resize_img(img, max_side=1000):\\n height, width = img.shape\\n # if the image is small enough as is, return it unchanged\\n if height <= 1000 and width <= 1000:\\n return img\\n dim = tuple()\\n if height > width:\\n scale_ratio = max_side / height\\n dim = (int(width * scale_ratio), max_side)\\n else:\\n scale_ratio = max_side / width\\n dim = (max_side, int(height * scale_ratio))\\n return cv2.resize(img, dim, interpolation=cv2.INTER_AREA)\",\n \"def downscale_image(img, bottom, x, y):\\n width, height = tuple(img.shape[1::-1])\\n img = img[int(round((1 - bottom) * (height - 1))):(height - 1), 1:(width - 1)]\\n img = cv2.resize(img, (x, y))\\n #img = cv2.Canny(img, 100, 200)\\n ret, img = cv2.threshold(img, img.mean(), 255, cv2.THRESH_BINARY)\\n return img\",\n \"def resize(img, size, interpolation=Image.BILINEAR):\\n\\n if not _is_numpy_image(img):\\n raise TypeError('img should be PIL Image. Got {}'.format(type(img)))\\n if not (isinstance(size, int) or (isinstance(size, collections.Iterable) and len(size) == 2)):\\n raise TypeError('Got inappropriate size arg: {}'.format(size))\\n\\n if isinstance(size, int):\\n size = (size, size)\\n \\n if img.dtype == np.int32:\\n resized = img.astype(np.uint16)\\n resized = cv2.resize(resized, size , interpolation)\\n else:\\n resized = cv2.resize(img, size , interpolation)\\n resized = resized.astype(img.dtype)\\n return resized\",\n \"def resize(self, height=None, width=None):\\n if width is not None and height is not None:\\n self._img = cv2.resize(self._img, dsize=(width, height))\\n return\\n if width is not None:\\n scale = float(width) / self._img.shape[1]\\n elif height is not None:\\n scale = float(height) / self._img.shape[0]\\n else:\\n raise ValueError('At least width or height should be provided.')\\n self._img = cv2.resize(\\n self._img,\\n dsize=(0, 0),\\n fx=scale,\\n fy=scale,\\n interpolation=cv2.INTER_LINEAR)\",\n \"def resize_image(image_data, resize_factor = 0.5):\\n \\n # calculate new shape:\\n width_new = int(resize_factor*image_data.shape[1]);\\n height_new = int(resize_factor*image_data.shape[0]);\\n \\n # return result:\\n return _cv2.resize(image_data,\\n (width_new, height_new),\\n interpolation = _cv2.INTER_AREA);\",\n \"def resize(file_path, width, height):\\n folder, file_name, ext = parse_file_path(file_path)\\n url = addr + '/img/resize'\\n\\n img = cv2.imread(file_path)\\n _, img_encoded = cv2.imencode('.jpg', img)\\n payload = img_encoded.tostring()\\n \\n response = requests.post(url, data=payload, params = {'w':width, 'h':height})\\n if response.status_code != 200:\\n print(json.load(response.content))\\n return None\\n \\n img_array = uncompress_nparr(response.content)\\n file_path = os.path.join(folder, file_name, + '_' + random_string() + '-resized' + ext)\\n cv2.imwrite(file_path, img_array)\\n return file_path\",\n \"def _resize_img(self, results):\\n for key in results.get('img_fields', ['img']):\\n if self.keep_ratio:\\n img, scale_factor = mmcv.imrescale(\\n results[key],\\n results['scale'],\\n return_scale=True,\\n interpolation=self.interpolation,\\n backend=self.backend)\\n # the w_scale and h_scale has minor difference\\n # a real fix should be done in the mmcv.imrescale in the future\\n new_h, new_w = img.shape[:2]\\n h, w = results[key].shape[:2]\\n w_scale = new_w / w\\n h_scale = new_h / h\\n else:\\n img, w_scale, h_scale = mmcv.imresize(\\n results[key],\\n results['scale'],\\n return_scale=True,\\n interpolation=self.interpolation,\\n backend=self.backend)\\n results[key] = img\\n\\n scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],\\n dtype=np.float32)\\n results['img_shape'] = img.shape\\n # in case that there is no padding\\n results['pad_shape'] = img.shape\\n results['scale_factor'] = scale_factor\\n results['keep_ratio'] = self.keep_ratio\",\n \"def resize_image(img: npt.ArrayLike, target_size: tuple(int, int)) -> npt.ArrayLike:\\n\\n ht, wt = target_size\\n h, w = img.shape\\n # scaling coefficient\\n sc = min(wt / w, ht / h)\\n tx = (wt - w * sc) / 2\\n ty = (ht - h * sc) / 2\\n \\n # M = [[x_scale, x_shear, X_up_left], \\n # [y_shear, y_scale, Y_up_left]]\\n M = np.float32([[sc, 0, tx], [0, sc, ty]])\\n img = cv2.warpAffine(img, M, dsize=(wt, ht), borderValue=0)\\n\\n return img / 255.\",\n \"def resize_image(image_path: str, image_resolution: float):\\n\\timage = read_image(image_path)\\n\\tcurrent_height, current_width = image.shape[0:-1]\\n\\tratio = image_resolution / base_resolution\\n\\tdimensions = (\\n\\t\\tmath.ceil(current_width * ratio), math.ceil(current_height * ratio))\\n\\treturn cv.resize(image, dimensions, interpolation=cv.INTER_AREA)\",\n \"def transform( img, shape, keep_aspect = False, verbose = 0 ):\\n for i in range( 3 ):\\n img[:, :, i] = cv2.equalizeHist(img[:, :, i])\\n img2 = resize(img, shape, keep_aspect, verbose = verbose )\\n return img2\",\n \"def scale_img(img, scale=1.0):\\n dim = (int(img.shape[1]*scale), int(img.shape[0]*scale))\\n return cv2.resize(img.copy(), dim, interpolation=cv2.INTER_AREA)\",\n \"def preprocessImage(img):\\n shape = img.shape\\n img = img[math.floor(shape[0]/4) : shape[0] - 25, 0:shape[1]]\\n img = cv2.resize(img, (img_columns, img_rows), interpolation = cv2.INTER_AREA)\\n return img\",\n \"def resizeImage(IMG,IMAGE_SIZE):\\n\\n RESCALED_IMAGE = skimage.transform.resize(IMG,[IMG.shape[0],IMAGE_SIZE,IMAGE_SIZE])\\n return RESCALED_IMAGE\",\n \"def set_size(self, size=None):\\n if not size:\\n size = self.output_size\\n self.img = cv2.resize(self.img, size)\\n self.update_image()\\n self.update_size()\",\n \"def resize(x, output_shape):\\n if not _available:\\n raise ValueError('cv2 is not installed on your environment, '\\n 'so nothing will be plotted at this time. '\\n 'Please install OpenCV.\\\\n\\\\n Under Anaconda '\\n ' environment, you can install it by '\\n '$ conda install -c menpo opencv=2.4.11\\\\n')\\n\\n H, W = output_shape\\n x = x.transpose(1, 2, 0)\\n x = cv2.resize(x, dsize=(W, H))\\n x = x.transpose(2, 0, 1)\\n return x\",\n \"def _np_resize_image(image, size, dtype='int'):\\n if dtype == 'int':\\n _size = (size[1], size[0]) # (H,W) to (W,H)\\n return cv2.resize(image.astype('uint8'),\\n _size,\\n interpolation=cv2.INTER_LINEAR)\\n elif dtype == 'float':\\n return skresize(image,\\n size,\\n order=0,\\n mode='constant',\\n preserve_range=True)\\n else:\\n raise NotImplementedError(f\\\"'{dtype}' is not a valid dtype.\\\")\",\n \"def prepare(img,\\n resize=False, new_size=(64, 64),\\n apply_contrast=False, contrast_channels=(0, 1, 2)\\n ):\\n new_img = crop(img)\\n\\n if resize:\\n new_img = cv2.resize(new_img, new_size)\\n\\n if apply_contrast:\\n new_img = increase_contrast(new_img, channels=contrast_channels)\\n\\n return new_img\",\n \"def resize(img):\\n size = (500, 500)\\n img.thumbnail(size)\\n return img\",\n \"def resize_image(img, final_height, final_width):\\n resized_img = tf.image.resize(tf.image.convert_image_dtype(img, tf.float32), (final_height, final_width))\\n return tf.image.convert_image_dtype(resized_img, tf.uint8)\",\n \"def resize_image(img):\\n ratio = float(img.size[1]) / float(img.size[0])\\n\\n if ratio > 1.73:\\n h, w = 320, 160 # 512, 256\\n elif ratio < 1.0 / 1.73:\\n h, w = 160, 320 # 256, 512\\n elif ratio > 1.41:\\n h, w = 384, 256\\n elif ratio < 1. / 1.41:\\n h, w = 256, 384\\n elif ratio > 1.15:\\n h, w = 320, 240 # 512, 384\\n elif ratio < 1. / 1.15:\\n h, w = 240, 320 # 384, 512\\n else:\\n h, w = 320, 320 # 384, 384\\n\\n h = int(h)\\n w = int(w)\\n img = TF.resize(img, size=[h, w], interpolation=Image.BILINEAR)\\n return img\",\n \"def rescaleFrame(frame, scale=.75):\\n\\n\\twidth = int(frame.shape[1] * scale)\\n\\theight = int(frame.shape[0] * scale)\\n\\n\\tdimensions = (width, height)\\n\\t\\n\\treturn cv.resize(frame, dimensions, interpolation=cv.INTER_AREA)\",\n \"def resize(im, target_size, max_size):\\n im_shape = im.shape\\n im_size_min = np.min(im_shape[0:2])\\n im_size_max = np.max(im_shape[0:2])\\n im_scale = float(target_size) / float(im_size_min)\\n # prevent bigger axis from being more than max_size:\\n if np.round(im_scale * im_size_max) > max_size:\\n im_scale = float(max_size) / float(im_size_max)\\n im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)\\n return im, im_scale\",\n \"def image_resize(image):\\n print(\\\"image-resizing2\\\")\\n\\n i=0\\n height,width = image.shape[:2]\\n shape = [height,width]\\n if len(image_shape) == 0:\\n #print(\\\"Intial\\\")\\n image_shape.append(shape)\\n resized = cv2.resize(image,(int(width*0.2),int(height*0.2)),interpolation=cv2.INTER_CUBIC)\\n else:\\n for old_shape in image_shape:\\n #print(\\\"second\\\")\\n if old_shape == shape:\\n i=0\\n break\\n else:\\n i+=1\\n if(i > 0):\\n #print(\\\"third\\\")\\n image_shape.append(shape)\\n resized = cv2.resize(image, (int(width * 0.2), int(height * 0.2)), interpolation=cv2.INTER_CUBIC)\\n return resized,shape\",\n \"def resize( img, shape, keep_aspect, verbose = 0 ):\\n if keep_aspect == True:\\n scale = min( np.array( shape, dtype = float ) / np.array( img.shape[0:2] ) )\\n shape2 = tuple( ( scale * np.array( img.shape[0:2] ) ).astype( int ) )\\n img2 = np.zeros( (shape[0],shape[1],3), dtype = img.dtype )\\n for i in range( img2.shape[2] ):\\n img2[:,:,i] = np.mean( np.mean( img[:,:,i] ) )\\n img2[0:shape2[0],0:shape2[1],0:3] = cv2.resize( img, shape2[::-1], interpolation = cv2.INTER_CUBIC )\\n else:\\n img2 = cv2.resize(img, shape, interpolation = cv2.INTER_CUBIC)\\n shape2 = shape\\n if verbose > 0:\\n print( \\\"image.shape %s resized to %s (resize_shape = %s, desired=%s)\\\" % ( \\n list( img.shape ), list( img2.shape ), list( shape2 ), list( shape ) ) )\\n\\n return img2\",\n \"def shape_new_img(image_path):\\n desired_size = 64\\n img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\\n new_img_array = cv2.resize(img, (desired_size, desired_size))\\n finalarray = new_img_array.reshape(1, desired_size, desired_size, 1)\\n\\n return finalarray\",\n \"def resize(img, size):\\n img = tf.expand_dims(img, 0)\\n return tf.image.resize_bilinear(img, size)[0,:,:,:]\",\n \"def resize(img, size, interpolation=cv2.INTER_LINEAR):\\n if not _is_numpy_image(img):\\n raise TypeError('img should be nparrary Image. Got {}'.format(type(img)))\\n if not (isinstance(size, int) or (isinstance(size, collections.Iterable) and len(size) == 2)):\\n raise TypeError('Got inappropriate size arg: {}'.format(size))\\n\\n if isinstance(size, int):\\n h, w = img.shape[:2]\\n if (w <= h and w == size) or (h <= w and h == size):\\n return img\\n if w < h:\\n ow = size\\n oh = int(size * h / w)\\n return cv2.resize(img, (ow, oh), interpolation)\\n else:\\n oh = size\\n ow = int(size * w / h)\\n return cv2.resize(img, (ow, oh), interpolation)\\n else:\\n return cv2.resize(img, tuple(size[::-1]), interpolation)\",\n \"def resizeImage(image, newDimension):\\r\\n image = validateImage(image)\\r\\n if image is None:\\r\\n print(\\\"ERROR - resizeImage: Image is missing.\\\")\\r\\n return None\\r\\n\\r\\n if not isinstance(newDimension, tuple) or len(newDimension) != image.ndim:\\r\\n print(\\\"ERROR - resizeImage: Specified dimension is illegal. Dimension=\\\", len(newDimension), \\\", ImageDimension=\\\",\\r\\n image.ndim)\\r\\n return None\\r\\n\\r\\n return cv2.resize(image, newDimension)\",\n \"def preprocess(path, img_w, img_h):\\n #print(path)\\n img = cv2.imread(path)\\n #print(img.shape)\\n #resizing the image to particular size (64, 128, 3)\\n img = fix_size(img, img_w, img_h)\\n #print(img.shape)\\n \\n #assigining values less than zero to zer0 and greater than zero to 1\\n img = np.clip(img, 0, 255)\\n\\n #changing the interger to more useful and complex integer\\n img = np.uint8(img)\\n\\n #convert an image to one color space to another\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n \\n #chaging the values datatype to float\\n img = img.astype(np.float32)\\n\\n #normalization\\n img /= 255\\n return img\",\n \"def showResized(name, image, scale):\\n image = resizeImage(image, scale)\\n cv.ShowImage(name, image)\",\n \"def resize_image(image_path):\\n image = Image.open(image_path)\\n\\n imagefit = ImageOps.fit(image, (612, 612), Image.ANTIALIAS)\\n imagefit.save(image_path, 'JPEG', quality=100)\",\n \"def image_resize(image: Image, size: (int, int)) -> array:\\n image = Image.fromarray(uint8(image))\\n\\n return array(image.resize(size))\",\n \"def img_zoom(img, fx, fy, interp=cv2.INTER_AREA):\\n res = cv2.resize(img, None, fx=fx, fy=fy,\\n interpolation=interp)\\n return res\",\n \"def resize(img, ratio=100, size=None, interpolation=None):\\n\\n def _interpolation_choice(interpolation):\\n if interpolation is None: # Set a default\\n if size is not None:\\n if (ratio >= 100) or (size[0] >= img.shape[0]) or (size[1] >= img.shape[1]):\\n interpolation = cv2.INTER_AREA\\n else:\\n interpolation = cv2.INTER_LINEAR\\n else:\\n if ratio >= 100:\\n interpolation = cv2.INTER_AREA\\n else:\\n interpolation = cv2.INTER_LINEAR\\n\\n elif interpolation in [\\\"nearest\\\", cv2.INTER_NEAREST]:\\n interpolation = cv2.INTER_NEAREST\\n elif interpolation in [\\\"linear\\\", cv2.INTER_LINEAR]:\\n interpolation = cv2.INTER_LINEAR\\n elif interpolation in [\\\"area\\\", cv2.INTER_AREA]:\\n interpolation = cv2.INTER_AREA\\n else:\\n interpolation = cv2.INTER_CUBIC\\n \\n return interpolation\\n\\n # Checks over ratio\\n intdetector(ratio)\\n if ratio <= 0:\\n raise ValueError(\\\"Expected ratio parameter to be over zero\\\")\\n\\n # Checks over size if necessary\\n if size is not None:\\n intdetector(size[0])\\n intdetector(size[1])\\n if size[0] == img.shape[0] and size[1] == img.shape[1]:\\n return img\\n if size[0] < 0 or size[1] < 0:\\n raise ValueError(\\\"Expected size parameter to be a tuple with values over 0\\\")\\n\\n interpolation = _interpolation_choice(interpolation)\\n\\n if ratio != 100: # Ratio has the priority if inputted\\n size = ( int(img.shape[1] * ratio / 100), int(img.shape[0] * ratio / 100) )\\n return cv2.resize(img, size, interpolation = interpolation)\\n if size is not None: # If ratio has not been modified, let's check size if inputted\\n return cv2.resize(img, size, interpolation = interpolation)\\n else:\\n return img\",\n \"def read_image(src):\\n im = cv2.imread(src, cv2.IMREAD_COLOR)\\n im = cv2.resize(im, (COLS, ROWS), interpolation=cv2.INTER_CUBIC)\\n return im\",\n \"def imresize(img, size):\\n if hasattr(size, \\\"__len__\\\"):\\n num_rows, num_cols = size\\n assert (num_rows > 0) or (num_cols > 0)\\n if num_rows < 0:\\n num_rows = num_cols * img.shape[0] / img.shape[1]\\n if num_cols < 0:\\n num_cols = num_rows * img.shape[1] / img.shape[0]\\n else:\\n num_rows = int(round(img.shape[0] * size))\\n num_cols = int(round(img.shape[1] * size))\\n return skimage.transform.resize(img, (num_rows, num_cols))\",\n \"def preprocess_image(image, model_image_size):\\n #resized_image = cv2.resize(image, tuple(reversed(model_image_size)), cv2.INTER_AREA)\\n resized_image = letterbox_resize(image, tuple(reversed(model_image_size)))\\n image_data = np.asarray(resized_image).astype('float32')\\n image_data = normalize_image(image_data)\\n image_data = np.expand_dims(image_data, 0) # Add batch dimension.\\n return image_data\",\n \"def resize(img,width):\\n \\n wpercent = float(width / float(img.size[0]))\\n hsize = int((float(img.size[1])*float(wpercent)))\\n img = img.resize((width ,hsize), Image.ANTIALIAS)\\n\\n return img\",\n \"def resize(img,width):\\n \\n wpercent = float(width / float(img.size[0]))\\n hsize = int((float(img.size[1])*float(wpercent)))\\n img = img.resize((width ,hsize), Image.ANTIALIAS)\\n\\n return img\",\n \"def cs4243_resize(image, new_width, new_height):\\n new_image = np.zeros((new_height, new_width, 3), dtype='uint8')\\n if len(image.shape)==2:\\n new_image = np.zeros((new_height, new_width), dtype='uint8')\\n ###Your code here###\\n \\n # if new_width < 0 or new_height < 0, np.zeros() will throw a ValueError.\\n \\n # if new_width == 0 or new_height == 0, we won't need to do any calculation.\\n if new_width == 0 or new_height == 0:\\n return new_image\\n \\n # resizing algorithm taken from\\n # https://tech-algorithm.com/articles/nearest-neighbor-image-scaling/\\n height, width = image.shape[0], image.shape[1]\\n w_ratio = int(((width << 16) / new_width) + 1)\\n h_ratio = int(((height << 16) / new_height) + 1)\\n \\n for h in range(new_height):\\n for w in range(new_width):\\n pw = int((w*w_ratio) >> 16)\\n ph = int((h*h_ratio) >> 16)\\n new_image[h,w] = image[ph, pw]\\n ###\\n return new_image\",\n \"def resize_img(self,scale=1):\\n reduced = self.image.reduce((scale,scale))\\n reduced.save(\\\"../edited/{}\\\".format(self.image.filename))\\n\\n reduced = Image.open(\\\"../edited/{}\\\".format(self.image.filename))\\n return reduced\",\n \"def resize_image(image, size):\\n return skimage.transform.resize(image, size, mode='reflect', preserve_range=True).astype(image.dtype)\",\n \"def resize_image(image_path: str):\\n image: Image.Image = Image.open(image_path)\\n w = image.width\\n h = image.height\\n scale_factor = IMAGE_WIDTH_DEFAULT / w\\n image.resize((int(w * scale_factor), int(h * scale_factor))).save(image_path)\",\n \"def process_image(img_file):\\n img = cv2.imread(img_file)\\n img = cv2.resize(img, IMAGE_DIM).transpose(\\n (2, 0, 1)).astype('float32') / 255.0\\n return img\",\n \"def resizeImage(img, scale=None, dims=None):\\n if scale is not None:\\n retImg = cv.CreateMat(int(img.rows * scale), int(img.cols * scale), img.type)\\n elif dims is not None:\\n retImg = cv.CreateMat(dims[1], dims[0], img.type)\\n else:\\n retImg = cv.CloneMat(img)\\n cv.Resize(img, retImg)\\n return retImg\",\n \"def rescale_image(self, height: int, width: int, make_copy: bool = True):\\n if make_copy:\\n obj = copy.deepcopy(self)\\n else:\\n obj = self\\n\\n if obj.bgr is not None:\\n obj.bgr = cv2.resize(obj.bgr, (width, height))\\n if obj._hsv is not None:\\n obj._hsv = cv2.resize(obj._hsv, (width, height))\\n if obj.borders is not None:\\n obj.borders = cv2.resize(obj.borders, (width, height))\\n return obj if make_copy else None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8261548","0.8075126","0.8029768","0.8016128","0.7924036","0.7875393","0.78491545","0.7844469","0.7772517","0.77287513","0.77221835","0.7603124","0.7569391","0.75212836","0.7410956","0.73702043","0.73482066","0.73242635","0.73195106","0.7284048","0.7276968","0.72742146","0.72636807","0.7249336","0.7200859","0.71741223","0.71710587","0.7170571","0.71480685","0.7143349","0.71008176","0.7095251","0.70805305","0.70794725","0.70447725","0.69999826","0.69897145","0.69897145","0.6973595","0.69379044","0.6933837","0.69327897","0.69220287","0.6918021","0.6913469","0.6890202","0.6870875","0.6868587","0.68651307","0.68448746","0.68182325","0.6806129","0.67999744","0.67961687","0.6786439","0.67825747","0.67698014","0.67406625","0.6717081","0.6710383","0.6703199","0.66886145","0.6682474","0.6671676","0.66677773","0.66598207","0.66565967","0.66498923","0.6642674","0.66412985","0.66404516","0.663647","0.66361016","0.66252613","0.6623877","0.6619517","0.6608418","0.66076946","0.66050196","0.6583457","0.65753865","0.6572167","0.65640926","0.65512455","0.65372837","0.653094","0.65291107","0.65220433","0.6507641","0.6500496","0.649429","0.64940476","0.6479183","0.6479183","0.6472775","0.646193","0.6444469","0.6442463","0.6436797","0.64345455","0.6426077"],"string":"[\n \"0.8261548\",\n \"0.8075126\",\n \"0.8029768\",\n \"0.8016128\",\n \"0.7924036\",\n \"0.7875393\",\n \"0.78491545\",\n \"0.7844469\",\n \"0.7772517\",\n \"0.77287513\",\n \"0.77221835\",\n \"0.7603124\",\n \"0.7569391\",\n \"0.75212836\",\n \"0.7410956\",\n \"0.73702043\",\n \"0.73482066\",\n \"0.73242635\",\n \"0.73195106\",\n \"0.7284048\",\n \"0.7276968\",\n \"0.72742146\",\n \"0.72636807\",\n \"0.7249336\",\n \"0.7200859\",\n \"0.71741223\",\n \"0.71710587\",\n \"0.7170571\",\n \"0.71480685\",\n \"0.7143349\",\n \"0.71008176\",\n \"0.7095251\",\n \"0.70805305\",\n \"0.70794725\",\n \"0.70447725\",\n \"0.69999826\",\n \"0.69897145\",\n \"0.69897145\",\n \"0.6973595\",\n \"0.69379044\",\n \"0.6933837\",\n \"0.69327897\",\n \"0.69220287\",\n \"0.6918021\",\n \"0.6913469\",\n \"0.6890202\",\n \"0.6870875\",\n \"0.6868587\",\n \"0.68651307\",\n \"0.68448746\",\n \"0.68182325\",\n \"0.6806129\",\n \"0.67999744\",\n \"0.67961687\",\n \"0.6786439\",\n \"0.67825747\",\n \"0.67698014\",\n \"0.67406625\",\n \"0.6717081\",\n \"0.6710383\",\n \"0.6703199\",\n \"0.66886145\",\n \"0.6682474\",\n \"0.6671676\",\n \"0.66677773\",\n \"0.66598207\",\n \"0.66565967\",\n \"0.66498923\",\n \"0.6642674\",\n \"0.66412985\",\n \"0.66404516\",\n \"0.663647\",\n \"0.66361016\",\n \"0.66252613\",\n \"0.6623877\",\n \"0.6619517\",\n \"0.6608418\",\n \"0.66076946\",\n \"0.66050196\",\n \"0.6583457\",\n \"0.65753865\",\n \"0.6572167\",\n \"0.65640926\",\n \"0.65512455\",\n \"0.65372837\",\n \"0.653094\",\n \"0.65291107\",\n \"0.65220433\",\n \"0.6507641\",\n \"0.6500496\",\n \"0.649429\",\n \"0.64940476\",\n \"0.6479183\",\n \"0.6479183\",\n \"0.6472775\",\n \"0.646193\",\n \"0.6444469\",\n \"0.6442463\",\n \"0.6436797\",\n \"0.64345455\",\n \"0.6426077\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88996,"cells":{"query":{"kind":"string","value":"resize input to fit into the memory"},"document":{"kind":"string","value":"def scale_mvs_input(images, cams, depth_image=None, scale=1):\n for view in range(FLAGS.view_num):\n images[view] = scale_image(images[view], scale=scale)\n cams[view] = scale_camera(cams[view], scale=scale)\n\n if depth_image is None:\n return images, cams\n else:\n depth_image = scale_image(depth_image, scale=scale, interpolation='nearest')\n return images, cams, depth_image"},"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 resize(self):\n pass","def _resize(self, new_capacity):\n temp_array = self.make_array(new_capacity)\n for i in range(self.n):\n temp_array[i] = self.original_array[i]\n self.original_array = temp_array\n self.capacity = new_capacity","def resize(self, old, new):","def _resize(self, cap):\n old = self._data\n self._data = [None] * cap\n walk = self._front\n for i in range(self._size):\n self._data[i] = old[walk]\n walk = (walk + 1) % len(old)\n self._front = 0","def _resize(self, capacity):\n B = self._make_array(capacity)\n for i in range(self._size):\n B[i] = self._data[i]\n self._data = B\n self._capacity = capacity","def _shrink_arr(self):\n self._resize_arr(self._capacity // self._growth_factor)","def _shrink(self):\n raise NotImplementedError(\"Should have implemented this.\")","def resize_memory(self, new_size=None):\n\n self.container.capacity = new_size","def shrink(self):\r\n\r\n old = self._data\r\n self._capacity = self._capacity // 2\r\n self._data = [0] * self._capacity\r\n\r\n if len(old) >= 1:\r\n for i in range(self._size):\r\n\r\n self._data[i] = old[i]","def resize_function(input):\n\n from keras.backend import tf as ktf\n return ktf.image.resize_images(input, (64, 64))","def __resize(self, new_capacity):\r\n B = self.make_array(new_capacity) # create new array\r\n for k in range(self.n):\r\n B[k] = self.A[k]\r\n\r\n self.A = B\r\n self.capacity = new_capacity","def resize_memory(self, new_size=None):\n\n self.capacity = new_size\n\n # self.push() takes care of decreasing the memory.\n # # Oldest experiences are discarded. For Ever.\n # # TODO: Check for a more efficient way of cleaning the memory.\n # while len(self.memory) > self.capacity:\n # _ = self.pop()","def _shrink(self):\n self.capacity = round(self.capacity / self.factor)\n temp = [None] * self.capacity\n for i in range(self.capacity):\n temp[i] = self.store[i]\n self.store = temp","def reshape(input):\n\n input = input / 255\n input = trans.resize(input, (args.size, args.size))\n input = np.reshape(input, input.shape + (1,))\n input = np.reshape(input, (1,) + input.shape)\n return input","def _resize(self, new_cap):\n new_array = ba(new_cap)\n\n for i in range(self.count):\n new_array[i] = self.the_array[i]\n\n self.the_array = new_array\n self.capacity = new_cap","def _resize(self, cap): # nonpublic utitity\n B = self._make_array(cap) # new (bigger) array\n for k in range(self._size): # for each existing value\n B[k] = self._Array[k]\n self._Array = B # use the bigger array\n self._capacity = cap","def __resize_to_512(input_data):\n test_size = 720\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\n axis=-1))\n for contour in contours] for contours in input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\n axis=-1)) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * 512 / input_data['img'].shape[0]),\n np.cast['int32'](point[1] * 512 / input_data['img'].shape[1]))\n for point in input_data['center_point']]\n\n seq = iaa.Sequential([\n iaa.Scale({'height': 512, 'width': 512}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n return input_data","def resize(self, size):\n if len(size) != len(self._Fkernel.shape[1:-1]):\n raise RuntimeError(\"length of resize shape is incorrect.\")\n if not np.all(size >= self._Fkernel.shape[1:-1]):\n raise RuntimeError(\"resize shape is too small.\")\n kernel = self._frequency_2_real()\n kernel_pad = self._zero_pad(kernel, size)\n self._Fkernel = self._real_2_frequency(kernel_pad)\n self.basis._axes_shape = kernel_pad.shape[1:-1]","def _grow(self):\n self.capacity *= self.factor\n temp = [None] * self.capacity\n for i in range(self.size):\n temp[i] = self.store[i]\n self.store = temp","def _resize_array(self, capacity):\n old_array = self._array\n self._array = [None] * capacity\n for index in range(self._size):\n self._array[index] = old_array[index]","def _resize(self, size: Tuple[int, int], axis: int = None) -> None:\n\t\tif self.name == \"\":\n\t\t\tself.ds._file['/matrix'].resize(size, axis)\n\t\telse:\n\t\t\tself.ds._file['/layers/' + self.name].resize(size, axis)","def _assign_sizes(self):","def reshape_input(input_data, input_size, single=True, warning=False):\n with suppress(Exception):\n input_data = torch.from_numpy(input_data)\n\n if input_size is None:\n if warning is True:\n print(\"No size was given and no reshaping can occur\")\n return input_data\n\n # Reshape the data regardless of batch size\n start = len(input_data)\n\n alternate = list(input_size)\n alternate[0] = start\n alternate = tuple(alternate)\n\n try:\n if single:\n input_data = input_data.reshape(alternate)\n else:\n input_data = input_data.reshape(input_size)\n except Exception:\n if warning is True:\n print(\"Warning: Data loss is possible during resizing.\")\n if single:\n input_data = input_data.resize_(alternate)\n else:\n input_data = input_data.resize_(input_size)\n return input_data","def resize(self, width: int, height: int):\n pass","def resize_to_initial(self):\n if self.initialized:\n init_size = self._compute_initial_size()\n self.resize(init_size)","def _resize(self, maxval):\n assert maxval >= self._N\n temp = [None for i in range(maxval)] # (Item[]) new [maxval] # Item[]\n q_len = len(self._q)\n for i in range(self._N):\n temp[i] = self._q[(self._first + i) % q_len]\n self._q = temp\n self._first = 0\n self._last = self._N","def _resize(self, minused):\n newsize = self.size\n # Find the smalled value for newsize.\n while newsize <= minused and newsize > 0:\n newsize <<= 1\n newsize += 1\n oldtable = self.table\n # Create a new table newsize long.\n newtable = []\n while len(newtable) < newsize:\n newtable.append(Entry())\n # Replace the old table.\n self.table = newtable\n self.used = 0\n self.filled = 0\n # Copy the old data into the new table.\n for entry in oldtable:\n if entry.value is not None:\n self._insert_into_clean(entry)\n elif entry.key is dummy:\n entry.key = None\n self.size = newsize","def resized(self,size=1.,tol=1.e-5):\n s = self.sizes()\n s[s<tol*s.max()] = size\n return self.scale(size/s)","def set_size(self, size=None):\n if not size:\n size = self.output_size\n self.img = cv2.resize(self.img, size)\n self.update_image()\n self.update_size()","def resize_to_maximum(self):\n if self.initialized:\n max_size = self._compute_maximum_size()\n self.set_max_size(max_size)\n self.resize(max_size)","def resize(self, size):\n assert size >= 0 and size <= self._cap, \\\n \"invalid size[%d] for resize\" % (size)\n\n self._size = size","def resize(self):\n e = self.e\n if abs(self.dnp) * ( self.np-self.np_req) > 0:\n e = self.er\n self.dsize = numpy.clip((self.np_req/self.np)**(1./e), 1/self.r, self.r)\n self.size *= self.dsize","def resize(image, size):\n return np.array(Image.fromarray(image).resize(size))","def setinputsizes(self, sizes):\n pass","def resize(self):\n load_factor = self._get_load_factor()\n if load_factor < 0.2:\n self.capacity //= 2\n elif load_factor > 0.7:\n self.capacity *= 2\n else:\n print(f'Resizing unnecessary due to a load factor of {load_factor}:.2f')\n return\n temp_storage = [None] * self.capacity\n for i in range(len(self.storage)):\n node = self.storage[i]\n while node is not None:\n index = self._hash_mod(node.key)\n node_to_add = temp_storage[index]\n if node_to_add is None:\n temp_storage[index] = LinkedPair(node.key, node.value)\n else:\n while node_to_add is not None:\n if node_to_add.next is None:\n node_to_add.next = LinkedPair(node.key, node.value)\n break\n node_to_add = node_to_add.next\n node = node.next\n self.storage = temp_storage","def resize(x, output_shape):\n if not _available:\n raise ValueError('cv2 is not installed on your environment, '\n 'so nothing will be plotted at this time. '\n 'Please install OpenCV.\\n\\n Under Anaconda '\n ' environment, you can install it by '\n '$ conda install -c menpo opencv=2.4.11\\n')\n\n H, W = output_shape\n x = x.transpose(1, 2, 0)\n x = cv2.resize(x, dsize=(W, H))\n x = x.transpose(2, 0, 1)\n return x","def shrink(self):\n old = self.data # keep track of existing list\n self.capacity = self.capacity // 2\n self.data = [None] * (self.capacity) # allocate list with new capacity\n walk = self.head\n for k in range(self.size): # only consider existing elements\n self.data[k] = old[walk] # intentionally shift indices\n walk = (1 + walk) % len(old) # use old size as modulus\n self.head = 0 # front has been realigned\n self.tail = self.size","def resize(input, size):\n layer = tf.image.resize_images(input, size, method=tf.image.ResizeMethod.BICUBIC, align_corners=True,\n preserve_aspect_ratio=True)\n return layer","def resize(img, size):\n img = cv2.resize(img, tuple(size[::-1]))\n return img","def __init__(self, input_size=88):\n self._input_size = input_size","def _make_resized_data(self, odata):\n\n\n nmax = odata['file_id'].shape[1]\n new_nmax = odata['ncutout'].max()\n if new_nmax < 2:\n new_nmax = 2\n temp_obj_data = odata\n\n nobj = temp_obj_data.size\n\n new_data = meds.util.get_meds_output_struct(\n nobj,\n new_nmax,\n extra_fields=self._get_fields(new_nmax),\n )\n new_data = self._add_cat_fields(new_data, copy=False)\n\n for name in new_data.dtype.names:\n if name in temp_obj_data.dtype.names:\n\n shape = new_data[name].shape\n lshape = len(shape)\n\n if lshape > 1 and shape[1] == new_nmax:\n new_data[name][:,:] = temp_obj_data[name][:,0:new_nmax]\n else:\n new_data[name][:] = temp_obj_data[name][:]\n\n del temp_obj_data\n\n return new_data","def resized_map(self, new_size):\n\n new_map = cv2.resize(self.map.copy(), new_size)\n cur_count = np.sum(new_map)\n\n # Avoid dividing by zero\n if cur_count == 0:\n return new_map\n\n scale = self.count / cur_count\n new_map *= scale\n return new_map","def _resize_state(self):\n # self.n_estimators is the number of additional est to fit\n total_n_estimators = self.n_estimators\n if total_n_estimators < self.estimators_.shape[0]:\n raise ValueError('resize with smaller n_estimators %d < %d' %\n (total_n_estimators, self.estimators_[0]))\n\n self.estimators_.resize((total_n_estimators, self.loss_.K))\n self.train_score_.resize(total_n_estimators)\n if (self.subsample < 1 or hasattr(self, 'oob_improvement_')):\n # if do oob resize arrays or create new if not available\n if hasattr(self, 'oob_improvement_'):\n self.oob_improvement_.resize(total_n_estimators)\n else:\n self.oob_improvement_ = np.zeros((total_n_estimators,),\n dtype=np.float64)","def _grow_arr(self):\n self._resize_arr(self._capacity * self._growth_factor)","def _hpat_ensure_array_capacity(new_size, arr):\n\n k = len(arr)\n if k >= new_size:\n return arr\n\n n = k\n while n < new_size:\n n = 2 * n\n res = numpy.empty(n, arr.dtype)\n res[:k] = arr[:k]\n return res","def __resize_512p(input_data):\n rate = 1\n test_size=512\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\n if True: # input_data['img'].shape[1] < 512:\n rate = test_size / input_data['img'].shape[1]\n seq = iaa.Sequential([\n iaa.Scale({'height': \"keep-aspect-ratio\", 'width': test_size}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n else:\n if True: # input_data['img'].shape[0] < 512:\n rate = test_size / input_data['img'].shape[0]\n seq = iaa.Sequential([\n iaa.Scale({'height': test_size, 'width': \"keep-aspect-ratio\"}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\n input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\n return input_data","def resize(self, cap):\n temp_pq = [0] * (cap + 1)\n temp_qp = [-1] * (cap + 1)\n temp_keys = [None] * (cap + 1)\n for i in range(cap + 1):\n temp_pq[i] = self.__pq[i]\n temp_qp[i] = self.__qp[i]\n temp_keys[i] = self.__keys[i]\n self.__pq = temp_pq\n self.__qp = temp_qp\n self.__keys = temp_keys\n self._max_n = cap\n if self.__n > self._max_n:\n self.__n = self._max_n","def grow(self):\r\n\r\n old = self._data\r\n self._capacity = 2 * self._capacity\r\n self._data = [0] * self._capacity\r\n\r\n for i in range(self._size):\r\n\r\n self._data[i] = old[i]","def update_size(self):\n self.size = self.image.size\n self.width, self.height = self.size","def resize_img_norescale(img, size):\n w,h = size\n shape = (h,w)\n out = np.zeros(shape, dtype=img.dtype)\n i = min(img.shape[0], out.shape[0])\n j = min(img.shape[1], out.shape[1])\n out[0:i,0:j] = img[0:i, 0:j]\n return out","def Resize(self):\n\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\n self.FreshStart()","def img_preprocess(self, img, output_size=64):\n w, h = img.size\n if w > h:\n box_param = (int(w * 0.5 - h * 0.5), 0, int(w * 0.5 + h * 0.5), h)\n cropped = img.crop(box_param)\n else: # w < h\n box_param = (0, int(h * 0.5 - w * 0.5), w, int(h * 0.5 + w * 0.5))\n cropped = img.crop(box_param)\n\n resized = cropped.resize((output_size, output_size))\n resized = np.asarray(resized)\n\n return resized","def process_image(image):\n image = resize(image)\n return image","def input_size(self):\n raise NotImplementedError()","def _resize_list(self, new_size: int):\n for _ in range((new_size + 1) - len(self)):\n self.append(0)","def resize(self, *args):\n return _ida_hexrays.cinsnptrvec_t_resize(self, *args)","def rescale_list(input_list, size):\n assert len(input_list) >= size\n\n # Get the number to skip between iterations.\n skip = len(input_list) // size\n\n # Build our new output.\n output = [input_list[i] for i in range(0, len(input_list), skip)]\n\n # Cut off the last one if needed.\n return output[:size]","def shrink(self):\r\n # first we need to decide how to shrink\r\n choice = rand.choice([0, 1, 2, 3])\r\n # now do it\r\n if ((choice == 0) and (self.xspan > mparam.min_s_xspan)):\r\n # delete first row\r\n self.cells = np.delete(self.cells, (0), axis=0) \r\n elif ((choice == 1) and (self.xspan > mparam.min_s_xspan)):\r\n # delete last row\r\n self.cells = np.delete(self.cells, (-1), axis=0) \r\n elif ((choice == 2) and (self.yspan > mparam.min_s_yspan)):\r\n # delete first column\r\n self.cells = np.delete(self.cells, (0), axis=1) \r\n elif ((choice == 3) and (self.yspan > mparam.min_s_yspan)):\r\n # delete last column\r\n self.cells = np.delete(self.cells, (-1), axis=1) \r\n # now let's update xspan and yspan to the new size\r\n self.xspan = self.cells.shape[0]\r\n self.yspan = self.cells.shape[1]\r\n #\r","def rescale(self, factor):\n scaled_size = (int(self.width * factor), int(self.height * factor))\n return self.resize(scaled_size)","def resize(self, *args):\n return _ida_hexrays.qvector_ccase_t_resize(self, *args)","def resize(self, size: Tuple[int, int]):\n if self._immutable:\n raise ValueError(\"Immutable textures cannot be resized\")\n\n gl.glActiveTexture(gl.GL_TEXTURE0 + self._ctx.default_texture_unit)\n gl.glBindTexture(self._target, self._glo)\n\n self._width, self._height = size\n\n self._texture_2d(None)","def bbox_resize(bbox, in_size, out_size):\n\n bbox = bbox.copy()\n y_scale = float(out_size[0]) / in_size[0]\n x_scale = float(out_size[1]) / in_size[1]\n\n bbox[:, 0] = bbox[:, 0] * y_scale\n bbox[:, 2] = bbox[:, 2] * y_scale\n bbox[:, 1] = bbox[:, 1] * x_scale\n bbox[:, 3] = bbox[:, 3] * x_scale\n return bbox","def image_resize(image: Image, size: (int, int)) -> array:\n image = Image.fromarray(uint8(image))\n\n return array(image.resize(size))","def _resize_arr(self, new_capacity):\n if new_capacity < self._length:\n raise RuntimeError('New capacity is lower than length')\n\n # Copy values to array with new capacity\n longer_arr = self._create_array(new_capacity)\n for i in range(self._length):\n longer_arr[i] = self._arr[i]\n\n # Set the arr to the new array\n self._arr = longer_arr\n self._capacity = new_capacity","def convert_size(g, op, block):\n\n input_x = g.get_node(op.input(\"Input\")[0])\n out = _op.ndarray_size(input_x, dtype=\"int64\")\n out = _op.expand_dims(out, axis=0)\n g.add_node(op.output(\"Out\")[0], out)","def preprocess_image(self, image_path, input_size):\n img = tf.io.read_file(image_path)\n img = tf.io.decode_image(img, channels=3)\n img = tf.image.convert_image_dtype(img, tf.uint8)\n resized_img = tf.image.resize(img, input_size)\n resized_img = resized_img[tf.newaxis, :]\n return resized_img","def resize(self, size):\n self.instance.resize_volume(size)\n self.size = size","def test_resize(dummy_input):\n # Test the 2D image: H, W, C\n image, label = dummy_input(image_size=(512, 512, 3),\n label_size=(512, 512, 1))\n transform = Resize(size=(64, 64))\n _image, _label = transform(image, label, resize_orders=[3, 0])\n assert _image.shape == (64, 64, 3)\n assert _image.dtype == image.dtype\n assert _label.shape == (64, 64, 1)\n assert _label.dtype == label.dtype\n\n # Test the 3D image: H, W, D, C\n image, label = dummy_input(image_size=(512, 512, 20, 3),\n label_size=(512, 512, 20, 1))\n transform = Resize(size=(64, 64, 10))\n _image, _label = transform(image, label, resize_orders=[3, 0])\n assert _image.shape == (64, 64, 10, 3)\n assert _image.dtype == image.dtype\n assert _label.shape == (64, 64, 10, 1)\n assert _label.dtype == label.dtype","def cs4243_resize(image, new_width, new_height):\n new_image = np.zeros((new_height, new_width, 3), dtype='uint8')\n if len(image.shape)==2:\n new_image = np.zeros((new_height, new_width), dtype='uint8')\n ###Your code here###\n \n # if new_width < 0 or new_height < 0, np.zeros() will throw a ValueError.\n \n # if new_width == 0 or new_height == 0, we won't need to do any calculation.\n if new_width == 0 or new_height == 0:\n return new_image\n \n # resizing algorithm taken from\n # https://tech-algorithm.com/articles/nearest-neighbor-image-scaling/\n height, width = image.shape[0], image.shape[1]\n w_ratio = int(((width << 16) / new_width) + 1)\n h_ratio = int(((height << 16) / new_height) + 1)\n \n for h in range(new_height):\n for w in range(new_width):\n pw = int((w*w_ratio) >> 16)\n ph = int((h*h_ratio) >> 16)\n new_image[h,w] = image[ph, pw]\n ###\n return new_image","def expand_data(X, orig_shape=(256, 256)):\n\n return X.reshape((-1, *orig_shape, X.shape[-1]))","def update_maximum_size(self):\n if self.initialized:\n max_size = self._compute_maximum_size()\n self.set_max_size(max_size)","def updateSize(self, *args):\n return None","def resize(self, *args):\n return _ida_hexrays.hexwarns_t_resize(self, *args)","def _maximum_size_changed(self):\n self.update_maximum_size()","def resize(data, data_type, interpolation_method, target_height, target_width):\r\n if target_width == data.shape[1] and target_height == data.shape[0]:\r\n return data\r\n\r\n if data_type == 'stereo':\r\n # disparity map\r\n if interpolation_method == 'bilinear':\r\n result = util_cython.resize(data, target_width, target_height, 0.5)\r\n else:\r\n result = cv2.resize(data, (target_width, target_height), interpolation=cv2.INTER_NEAREST)\r\n else:\r\n # optical flow field\r\n result = np.zeros((target_height, target_width, 2))\r\n if interpolation_method == 'bilinear':\r\n result[:, :, 0] = util_cython.resize(data[:, :, 0], target_width, target_height, 0.5)\r\n result[:, :, 1] = util_cython.resize(data[:, :, 1], target_width, target_height, 0.5)\r\n else:\r\n result = cv2.resize(data, (target_width, target_height), interpolation=cv2.INTER_NEAREST)\r\n return result","def __resize_to_32x(input_data):\n rate = 1\n while min(input_data['img'].shape[:2])>736:\n test_size = 736\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\n if True: # input_data['img'].shape[1] < 512:\n rate = test_size / input_data['img'].shape[1]\n seq = iaa.Sequential([\n iaa.Scale({'height': \"keep-aspect-ratio\", 'width': test_size}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n else:\n if True: # input_data['img'].shape[0] < 512:\n rate = test_size / input_data['img'].shape[0]\n seq = iaa.Sequential([\n iaa.Scale({'height': test_size, 'width': \"keep-aspect-ratio\"}, 'cubic')\n ])\n input_data['img'] = seq.augment_image(input_data['img'])\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\n input_data['contour']]\n else:\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\n p_row = 0\n while True:\n if (input_data['img'].shape[0] + p_row) % 32 == 0:\n break\n p_row += 1\n p_col = 0\n while True:\n if (input_data['img'].shape[1] + p_col) % 32 == 0:\n break\n p_col += 1\n\n input_data['img'] = np.pad(input_data['img'], ((0, p_row), (0, p_col), (0, 0)), mode='constant')\n\n return input_data","def _shrinkCheck(self):\n if self.size > self.INIT_CAPACITY and self.size / self.capacity <= 0.25:\n self._shrink()","def resize(self, in_size, out_size):\n scaled_origin, scaled_data = resize_origin_and_bitmap(self._origin, self._data, in_size, out_size)\n return MultichannelBitmap(data=scaled_data, origin=scaled_origin)","def _shrink(values, last_dim, reduction_factor):\n\n shape = tf.shape(values)\n new_shape = [\n shape[0],\n shape[1] // reduction_factor,\n last_dim * reduction_factor\n ]\n values = tf.reshape(values, new_shape)\n return values","def body_resize(self):","def _resize(self, c):\n old = list(self.items())\n self._table = [None] * c\n self._n = 0\n for (k, v) in old:\n self[k] = v","def maxsize(self, maxsize):\n self.shape = (int(maxsize), ) + self.shape[1:]\n self.clear()","def resize_to_minimum(self):\n if self.initialized:\n min_size = self._compute_minimum_size()\n self.set_min_size(min_size)\n self.resize(min_size)","def Resize_data(data_size):\n\n data_size = data_size\n\n str_taille = 0\n\n data_size_n = data_size - str_taille\n\n taille = data_size_n//3\n\n reste = data_size_n - (taille*3)\n\n taille_sup = taille+reste\n\n return (taille_sup,taille)","def resize_bytes(fobj, old_size, new_size, offset):\n\n if new_size < old_size:\n delete_size = old_size - new_size\n delete_at = offset + new_size\n delete_bytes(fobj, delete_size, delete_at)\n elif new_size > old_size:\n insert_size = new_size - old_size\n insert_at = offset + old_size\n insert_bytes(fobj, insert_size, insert_at)","def resize(self, new_size):\n resized_img = opencv.resize(self.img, new_size)\n return Image(resized_img)","def set_size(self, w, h):\n\t\tpass","def image_resize(img, min_size=600, max_size=1000):\n C, H, W = img.shape\n scale1 = min_size / min(H, W)\n scale2 = max_size / max(H, W)\n scale = min(scale1, scale2)\n img = img / 255\n img = transform.resize(img, (C, H * scale, W * scale),\n mode='reflect', anti_aliasing=False)\n # img = pytorch_normalize(img)\n # img = caffe_normalize(img)\n return img","def dec_size(self):\r\n self.__length -= 1","def resize(img, size):\n img = tf.expand_dims(img, 0)\n return tf.image.resize_bilinear(img, size)[0,:,:,:]","def setinputsizes(self, sizes):\r\n if self._closed:\r\n raise Error('The cursor has been closed.')\r\n if self.connection._closed:\r\n raise Error('The connection to the database has been closed.')\r\n else:\r\n pass","def assigninput(self, input):\n if type(input) == str: # string type\n self.name = input\n else: # array, list, tuple\n if len(input) == 2:\n print input[0], 'input0'\n try:\n n = len(input[0])\n except:\n n = 1\n if n == 1:\n\t\t print 'INITIALIZING SPARSE ARRAY TO ZEROS'\n self.ny, self.nx = input\n input = zeros(input, int)\n ## BELOW NOT QUITE RIGHT...\n ## ACTUALLY IT JUST TAKES LONG TO BUILD THE HUGE ARRAY\n # TAKES TIME TO UNRAVEL\n # LET'S JUST MAKE IT RIGHT THE FIRST TIME:\n #input = zeros(input[0] * input[1], 'int')\n #self.data = input\n self.data = ravel(array(input)) # ravel ADDED MUCH LATER","def resize(img, min_size=512):\n width, height, _ = tf.unstack(tf.shape(img), num=3)\n if height < width:\n new_height = min_size\n new_width = int(width * new_height / height)\n else:\n new_width = min_size\n new_height = int(height * new_width / width)\n\n img = tf.image.resize(img, size=(new_width, new_height))\n return img","def handleResize(self):\n pass","def resize(self, width, height):\n if self.example:\n self.example.resize(width, height)","def resize_image_data(data, resize_shape):\n if data is None or len(resize_shape) == 0:\n return data\n\n if len(data.shape) > 1 and np.array_equal(data[0].shape, resize_shape):\n return data\n\n output_data = []\n for im in data:\n output_data.append(zoom(input=im, zoom=np.divide(resize_shape, im.shape)))\n\n return np.array(output_data)","def resizeChildren(self,newSize):\n assert newSize > len(self.children)\n self.children += [None] * (newSize - len(self.children))","def np_resize(img, input_shape):\n height, width = input_shape\n return cv2.resize(img, (width, height))","def np_resize(img, input_shape):\n height, width = input_shape\n return cv2.resize(img, (width, height))","def resize(self, dims, default=None):\n\t\twidth, height = dims\n\t\tassert isinstance(width, int)\n\t\tassert isinstance(height, int)\n\t\tassert width > 0\n\t\tassert height > 0\n\t\tself.dims = Size(width, height)\n\t\t# TODO maybe clearing is not the best idea, maybe I should keep old values wherever is possible.\n\t\tself.data = [copy.deepcopy(default) for _ in range(width * height)]","def _check_and_resize_input_tensor(self, input_data_map):\r\n is_need_reshape = False\r\n input_shape_list = []\r\n\r\n for model_input in self.model_inputs:\r\n tensor_name = model_input.name.rstrip()\r\n input_data = input_data_map.get(tensor_name, None)\r\n if input_data is None:\r\n raise ValueError(f'{tensor_name} is not in model inputs')\r\n if model_input.shape != list(input_data.shape):\r\n self.logger.warning(f'model input shape: {model_input.shape} is not equal'\r\n f'with input data shape: {input_data.shape}, model input shape'\r\n f'would be reshaped')\r\n is_need_reshape = True\r\n input_shape_list.append(list(input_data.shape))\r\n\r\n if is_need_reshape:\r\n self.model_session.resize(self.model_inputs, input_shape_list)\r\n self.model_inputs = self.model_session.get_inputs()"],"string":"[\n \"def resize(self):\\n pass\",\n \"def _resize(self, new_capacity):\\n temp_array = self.make_array(new_capacity)\\n for i in range(self.n):\\n temp_array[i] = self.original_array[i]\\n self.original_array = temp_array\\n self.capacity = new_capacity\",\n \"def resize(self, old, new):\",\n \"def _resize(self, cap):\\n old = self._data\\n self._data = [None] * cap\\n walk = self._front\\n for i in range(self._size):\\n self._data[i] = old[walk]\\n walk = (walk + 1) % len(old)\\n self._front = 0\",\n \"def _resize(self, capacity):\\n B = self._make_array(capacity)\\n for i in range(self._size):\\n B[i] = self._data[i]\\n self._data = B\\n self._capacity = capacity\",\n \"def _shrink_arr(self):\\n self._resize_arr(self._capacity // self._growth_factor)\",\n \"def _shrink(self):\\n raise NotImplementedError(\\\"Should have implemented this.\\\")\",\n \"def resize_memory(self, new_size=None):\\n\\n self.container.capacity = new_size\",\n \"def shrink(self):\\r\\n\\r\\n old = self._data\\r\\n self._capacity = self._capacity // 2\\r\\n self._data = [0] * self._capacity\\r\\n\\r\\n if len(old) >= 1:\\r\\n for i in range(self._size):\\r\\n\\r\\n self._data[i] = old[i]\",\n \"def resize_function(input):\\n\\n from keras.backend import tf as ktf\\n return ktf.image.resize_images(input, (64, 64))\",\n \"def __resize(self, new_capacity):\\r\\n B = self.make_array(new_capacity) # create new array\\r\\n for k in range(self.n):\\r\\n B[k] = self.A[k]\\r\\n\\r\\n self.A = B\\r\\n self.capacity = new_capacity\",\n \"def resize_memory(self, new_size=None):\\n\\n self.capacity = new_size\\n\\n # self.push() takes care of decreasing the memory.\\n # # Oldest experiences are discarded. For Ever.\\n # # TODO: Check for a more efficient way of cleaning the memory.\\n # while len(self.memory) > self.capacity:\\n # _ = self.pop()\",\n \"def _shrink(self):\\n self.capacity = round(self.capacity / self.factor)\\n temp = [None] * self.capacity\\n for i in range(self.capacity):\\n temp[i] = self.store[i]\\n self.store = temp\",\n \"def reshape(input):\\n\\n input = input / 255\\n input = trans.resize(input, (args.size, args.size))\\n input = np.reshape(input, input.shape + (1,))\\n input = np.reshape(input, (1,) + input.shape)\\n return input\",\n \"def _resize(self, new_cap):\\n new_array = ba(new_cap)\\n\\n for i in range(self.count):\\n new_array[i] = self.the_array[i]\\n\\n self.the_array = new_array\\n self.capacity = new_cap\",\n \"def _resize(self, cap): # nonpublic utitity\\n B = self._make_array(cap) # new (bigger) array\\n for k in range(self._size): # for each existing value\\n B[k] = self._Array[k]\\n self._Array = B # use the bigger array\\n self._capacity = cap\",\n \"def __resize_to_512(input_data):\\n test_size = 720\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\\n axis=-1))\\n for contour in contours] for contours in input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](np.stack([contour[:, :, 0] * 512 / input_data['img'].shape[0],\\n contour[:, :, 1] * 512 / input_data['img'].shape[1]],\\n axis=-1)) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * 512 / input_data['img'].shape[0]),\\n np.cast['int32'](point[1] * 512 / input_data['img'].shape[1]))\\n for point in input_data['center_point']]\\n\\n seq = iaa.Sequential([\\n iaa.Scale({'height': 512, 'width': 512}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n return input_data\",\n \"def resize(self, size):\\n if len(size) != len(self._Fkernel.shape[1:-1]):\\n raise RuntimeError(\\\"length of resize shape is incorrect.\\\")\\n if not np.all(size >= self._Fkernel.shape[1:-1]):\\n raise RuntimeError(\\\"resize shape is too small.\\\")\\n kernel = self._frequency_2_real()\\n kernel_pad = self._zero_pad(kernel, size)\\n self._Fkernel = self._real_2_frequency(kernel_pad)\\n self.basis._axes_shape = kernel_pad.shape[1:-1]\",\n \"def _grow(self):\\n self.capacity *= self.factor\\n temp = [None] * self.capacity\\n for i in range(self.size):\\n temp[i] = self.store[i]\\n self.store = temp\",\n \"def _resize_array(self, capacity):\\n old_array = self._array\\n self._array = [None] * capacity\\n for index in range(self._size):\\n self._array[index] = old_array[index]\",\n \"def _resize(self, size: Tuple[int, int], axis: int = None) -> None:\\n\\t\\tif self.name == \\\"\\\":\\n\\t\\t\\tself.ds._file['/matrix'].resize(size, axis)\\n\\t\\telse:\\n\\t\\t\\tself.ds._file['/layers/' + self.name].resize(size, axis)\",\n \"def _assign_sizes(self):\",\n \"def reshape_input(input_data, input_size, single=True, warning=False):\\n with suppress(Exception):\\n input_data = torch.from_numpy(input_data)\\n\\n if input_size is None:\\n if warning is True:\\n print(\\\"No size was given and no reshaping can occur\\\")\\n return input_data\\n\\n # Reshape the data regardless of batch size\\n start = len(input_data)\\n\\n alternate = list(input_size)\\n alternate[0] = start\\n alternate = tuple(alternate)\\n\\n try:\\n if single:\\n input_data = input_data.reshape(alternate)\\n else:\\n input_data = input_data.reshape(input_size)\\n except Exception:\\n if warning is True:\\n print(\\\"Warning: Data loss is possible during resizing.\\\")\\n if single:\\n input_data = input_data.resize_(alternate)\\n else:\\n input_data = input_data.resize_(input_size)\\n return input_data\",\n \"def resize(self, width: int, height: int):\\n pass\",\n \"def resize_to_initial(self):\\n if self.initialized:\\n init_size = self._compute_initial_size()\\n self.resize(init_size)\",\n \"def _resize(self, maxval):\\n assert maxval >= self._N\\n temp = [None for i in range(maxval)] # (Item[]) new [maxval] # Item[]\\n q_len = len(self._q)\\n for i in range(self._N):\\n temp[i] = self._q[(self._first + i) % q_len]\\n self._q = temp\\n self._first = 0\\n self._last = self._N\",\n \"def _resize(self, minused):\\n newsize = self.size\\n # Find the smalled value for newsize.\\n while newsize <= minused and newsize > 0:\\n newsize <<= 1\\n newsize += 1\\n oldtable = self.table\\n # Create a new table newsize long.\\n newtable = []\\n while len(newtable) < newsize:\\n newtable.append(Entry())\\n # Replace the old table.\\n self.table = newtable\\n self.used = 0\\n self.filled = 0\\n # Copy the old data into the new table.\\n for entry in oldtable:\\n if entry.value is not None:\\n self._insert_into_clean(entry)\\n elif entry.key is dummy:\\n entry.key = None\\n self.size = newsize\",\n \"def resized(self,size=1.,tol=1.e-5):\\n s = self.sizes()\\n s[s<tol*s.max()] = size\\n return self.scale(size/s)\",\n \"def set_size(self, size=None):\\n if not size:\\n size = self.output_size\\n self.img = cv2.resize(self.img, size)\\n self.update_image()\\n self.update_size()\",\n \"def resize_to_maximum(self):\\n if self.initialized:\\n max_size = self._compute_maximum_size()\\n self.set_max_size(max_size)\\n self.resize(max_size)\",\n \"def resize(self, size):\\n assert size >= 0 and size <= self._cap, \\\\\\n \\\"invalid size[%d] for resize\\\" % (size)\\n\\n self._size = size\",\n \"def resize(self):\\n e = self.e\\n if abs(self.dnp) * ( self.np-self.np_req) > 0:\\n e = self.er\\n self.dsize = numpy.clip((self.np_req/self.np)**(1./e), 1/self.r, self.r)\\n self.size *= self.dsize\",\n \"def resize(image, size):\\n return np.array(Image.fromarray(image).resize(size))\",\n \"def setinputsizes(self, sizes):\\n pass\",\n \"def resize(self):\\n load_factor = self._get_load_factor()\\n if load_factor < 0.2:\\n self.capacity //= 2\\n elif load_factor > 0.7:\\n self.capacity *= 2\\n else:\\n print(f'Resizing unnecessary due to a load factor of {load_factor}:.2f')\\n return\\n temp_storage = [None] * self.capacity\\n for i in range(len(self.storage)):\\n node = self.storage[i]\\n while node is not None:\\n index = self._hash_mod(node.key)\\n node_to_add = temp_storage[index]\\n if node_to_add is None:\\n temp_storage[index] = LinkedPair(node.key, node.value)\\n else:\\n while node_to_add is not None:\\n if node_to_add.next is None:\\n node_to_add.next = LinkedPair(node.key, node.value)\\n break\\n node_to_add = node_to_add.next\\n node = node.next\\n self.storage = temp_storage\",\n \"def resize(x, output_shape):\\n if not _available:\\n raise ValueError('cv2 is not installed on your environment, '\\n 'so nothing will be plotted at this time. '\\n 'Please install OpenCV.\\\\n\\\\n Under Anaconda '\\n ' environment, you can install it by '\\n '$ conda install -c menpo opencv=2.4.11\\\\n')\\n\\n H, W = output_shape\\n x = x.transpose(1, 2, 0)\\n x = cv2.resize(x, dsize=(W, H))\\n x = x.transpose(2, 0, 1)\\n return x\",\n \"def shrink(self):\\n old = self.data # keep track of existing list\\n self.capacity = self.capacity // 2\\n self.data = [None] * (self.capacity) # allocate list with new capacity\\n walk = self.head\\n for k in range(self.size): # only consider existing elements\\n self.data[k] = old[walk] # intentionally shift indices\\n walk = (1 + walk) % len(old) # use old size as modulus\\n self.head = 0 # front has been realigned\\n self.tail = self.size\",\n \"def resize(input, size):\\n layer = tf.image.resize_images(input, size, method=tf.image.ResizeMethod.BICUBIC, align_corners=True,\\n preserve_aspect_ratio=True)\\n return layer\",\n \"def resize(img, size):\\n img = cv2.resize(img, tuple(size[::-1]))\\n return img\",\n \"def __init__(self, input_size=88):\\n self._input_size = input_size\",\n \"def _make_resized_data(self, odata):\\n\\n\\n nmax = odata['file_id'].shape[1]\\n new_nmax = odata['ncutout'].max()\\n if new_nmax < 2:\\n new_nmax = 2\\n temp_obj_data = odata\\n\\n nobj = temp_obj_data.size\\n\\n new_data = meds.util.get_meds_output_struct(\\n nobj,\\n new_nmax,\\n extra_fields=self._get_fields(new_nmax),\\n )\\n new_data = self._add_cat_fields(new_data, copy=False)\\n\\n for name in new_data.dtype.names:\\n if name in temp_obj_data.dtype.names:\\n\\n shape = new_data[name].shape\\n lshape = len(shape)\\n\\n if lshape > 1 and shape[1] == new_nmax:\\n new_data[name][:,:] = temp_obj_data[name][:,0:new_nmax]\\n else:\\n new_data[name][:] = temp_obj_data[name][:]\\n\\n del temp_obj_data\\n\\n return new_data\",\n \"def resized_map(self, new_size):\\n\\n new_map = cv2.resize(self.map.copy(), new_size)\\n cur_count = np.sum(new_map)\\n\\n # Avoid dividing by zero\\n if cur_count == 0:\\n return new_map\\n\\n scale = self.count / cur_count\\n new_map *= scale\\n return new_map\",\n \"def _resize_state(self):\\n # self.n_estimators is the number of additional est to fit\\n total_n_estimators = self.n_estimators\\n if total_n_estimators < self.estimators_.shape[0]:\\n raise ValueError('resize with smaller n_estimators %d < %d' %\\n (total_n_estimators, self.estimators_[0]))\\n\\n self.estimators_.resize((total_n_estimators, self.loss_.K))\\n self.train_score_.resize(total_n_estimators)\\n if (self.subsample < 1 or hasattr(self, 'oob_improvement_')):\\n # if do oob resize arrays or create new if not available\\n if hasattr(self, 'oob_improvement_'):\\n self.oob_improvement_.resize(total_n_estimators)\\n else:\\n self.oob_improvement_ = np.zeros((total_n_estimators,),\\n dtype=np.float64)\",\n \"def _grow_arr(self):\\n self._resize_arr(self._capacity * self._growth_factor)\",\n \"def _hpat_ensure_array_capacity(new_size, arr):\\n\\n k = len(arr)\\n if k >= new_size:\\n return arr\\n\\n n = k\\n while n < new_size:\\n n = 2 * n\\n res = numpy.empty(n, arr.dtype)\\n res[:k] = arr[:k]\\n return res\",\n \"def __resize_512p(input_data):\\n rate = 1\\n test_size=512\\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\\n if True: # input_data['img'].shape[1] < 512:\\n rate = test_size / input_data['img'].shape[1]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': \\\"keep-aspect-ratio\\\", 'width': test_size}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n else:\\n if True: # input_data['img'].shape[0] < 512:\\n rate = test_size / input_data['img'].shape[0]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': test_size, 'width': \\\"keep-aspect-ratio\\\"}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\\n input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\\n return input_data\",\n \"def resize(self, cap):\\n temp_pq = [0] * (cap + 1)\\n temp_qp = [-1] * (cap + 1)\\n temp_keys = [None] * (cap + 1)\\n for i in range(cap + 1):\\n temp_pq[i] = self.__pq[i]\\n temp_qp[i] = self.__qp[i]\\n temp_keys[i] = self.__keys[i]\\n self.__pq = temp_pq\\n self.__qp = temp_qp\\n self.__keys = temp_keys\\n self._max_n = cap\\n if self.__n > self._max_n:\\n self.__n = self._max_n\",\n \"def grow(self):\\r\\n\\r\\n old = self._data\\r\\n self._capacity = 2 * self._capacity\\r\\n self._data = [0] * self._capacity\\r\\n\\r\\n for i in range(self._size):\\r\\n\\r\\n self._data[i] = old[i]\",\n \"def update_size(self):\\n self.size = self.image.size\\n self.width, self.height = self.size\",\n \"def resize_img_norescale(img, size):\\n w,h = size\\n shape = (h,w)\\n out = np.zeros(shape, dtype=img.dtype)\\n i = min(img.shape[0], out.shape[0])\\n j = min(img.shape[1], out.shape[1])\\n out[0:i,0:j] = img[0:i, 0:j]\\n return out\",\n \"def Resize(self):\\n\\n self.history_length = int( round( self.owner['time_span']/self.owner['sample_speed']))\\n self.FreshStart()\",\n \"def img_preprocess(self, img, output_size=64):\\n w, h = img.size\\n if w > h:\\n box_param = (int(w * 0.5 - h * 0.5), 0, int(w * 0.5 + h * 0.5), h)\\n cropped = img.crop(box_param)\\n else: # w < h\\n box_param = (0, int(h * 0.5 - w * 0.5), w, int(h * 0.5 + w * 0.5))\\n cropped = img.crop(box_param)\\n\\n resized = cropped.resize((output_size, output_size))\\n resized = np.asarray(resized)\\n\\n return resized\",\n \"def process_image(image):\\n image = resize(image)\\n return image\",\n \"def input_size(self):\\n raise NotImplementedError()\",\n \"def _resize_list(self, new_size: int):\\n for _ in range((new_size + 1) - len(self)):\\n self.append(0)\",\n \"def resize(self, *args):\\n return _ida_hexrays.cinsnptrvec_t_resize(self, *args)\",\n \"def rescale_list(input_list, size):\\n assert len(input_list) >= size\\n\\n # Get the number to skip between iterations.\\n skip = len(input_list) // size\\n\\n # Build our new output.\\n output = [input_list[i] for i in range(0, len(input_list), skip)]\\n\\n # Cut off the last one if needed.\\n return output[:size]\",\n \"def shrink(self):\\r\\n # first we need to decide how to shrink\\r\\n choice = rand.choice([0, 1, 2, 3])\\r\\n # now do it\\r\\n if ((choice == 0) and (self.xspan > mparam.min_s_xspan)):\\r\\n # delete first row\\r\\n self.cells = np.delete(self.cells, (0), axis=0) \\r\\n elif ((choice == 1) and (self.xspan > mparam.min_s_xspan)):\\r\\n # delete last row\\r\\n self.cells = np.delete(self.cells, (-1), axis=0) \\r\\n elif ((choice == 2) and (self.yspan > mparam.min_s_yspan)):\\r\\n # delete first column\\r\\n self.cells = np.delete(self.cells, (0), axis=1) \\r\\n elif ((choice == 3) and (self.yspan > mparam.min_s_yspan)):\\r\\n # delete last column\\r\\n self.cells = np.delete(self.cells, (-1), axis=1) \\r\\n # now let's update xspan and yspan to the new size\\r\\n self.xspan = self.cells.shape[0]\\r\\n self.yspan = self.cells.shape[1]\\r\\n #\\r\",\n \"def rescale(self, factor):\\n scaled_size = (int(self.width * factor), int(self.height * factor))\\n return self.resize(scaled_size)\",\n \"def resize(self, *args):\\n return _ida_hexrays.qvector_ccase_t_resize(self, *args)\",\n \"def resize(self, size: Tuple[int, int]):\\n if self._immutable:\\n raise ValueError(\\\"Immutable textures cannot be resized\\\")\\n\\n gl.glActiveTexture(gl.GL_TEXTURE0 + self._ctx.default_texture_unit)\\n gl.glBindTexture(self._target, self._glo)\\n\\n self._width, self._height = size\\n\\n self._texture_2d(None)\",\n \"def bbox_resize(bbox, in_size, out_size):\\n\\n bbox = bbox.copy()\\n y_scale = float(out_size[0]) / in_size[0]\\n x_scale = float(out_size[1]) / in_size[1]\\n\\n bbox[:, 0] = bbox[:, 0] * y_scale\\n bbox[:, 2] = bbox[:, 2] * y_scale\\n bbox[:, 1] = bbox[:, 1] * x_scale\\n bbox[:, 3] = bbox[:, 3] * x_scale\\n return bbox\",\n \"def image_resize(image: Image, size: (int, int)) -> array:\\n image = Image.fromarray(uint8(image))\\n\\n return array(image.resize(size))\",\n \"def _resize_arr(self, new_capacity):\\n if new_capacity < self._length:\\n raise RuntimeError('New capacity is lower than length')\\n\\n # Copy values to array with new capacity\\n longer_arr = self._create_array(new_capacity)\\n for i in range(self._length):\\n longer_arr[i] = self._arr[i]\\n\\n # Set the arr to the new array\\n self._arr = longer_arr\\n self._capacity = new_capacity\",\n \"def convert_size(g, op, block):\\n\\n input_x = g.get_node(op.input(\\\"Input\\\")[0])\\n out = _op.ndarray_size(input_x, dtype=\\\"int64\\\")\\n out = _op.expand_dims(out, axis=0)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def preprocess_image(self, image_path, input_size):\\n img = tf.io.read_file(image_path)\\n img = tf.io.decode_image(img, channels=3)\\n img = tf.image.convert_image_dtype(img, tf.uint8)\\n resized_img = tf.image.resize(img, input_size)\\n resized_img = resized_img[tf.newaxis, :]\\n return resized_img\",\n \"def resize(self, size):\\n self.instance.resize_volume(size)\\n self.size = size\",\n \"def test_resize(dummy_input):\\n # Test the 2D image: H, W, C\\n image, label = dummy_input(image_size=(512, 512, 3),\\n label_size=(512, 512, 1))\\n transform = Resize(size=(64, 64))\\n _image, _label = transform(image, label, resize_orders=[3, 0])\\n assert _image.shape == (64, 64, 3)\\n assert _image.dtype == image.dtype\\n assert _label.shape == (64, 64, 1)\\n assert _label.dtype == label.dtype\\n\\n # Test the 3D image: H, W, D, C\\n image, label = dummy_input(image_size=(512, 512, 20, 3),\\n label_size=(512, 512, 20, 1))\\n transform = Resize(size=(64, 64, 10))\\n _image, _label = transform(image, label, resize_orders=[3, 0])\\n assert _image.shape == (64, 64, 10, 3)\\n assert _image.dtype == image.dtype\\n assert _label.shape == (64, 64, 10, 1)\\n assert _label.dtype == label.dtype\",\n \"def cs4243_resize(image, new_width, new_height):\\n new_image = np.zeros((new_height, new_width, 3), dtype='uint8')\\n if len(image.shape)==2:\\n new_image = np.zeros((new_height, new_width), dtype='uint8')\\n ###Your code here###\\n \\n # if new_width < 0 or new_height < 0, np.zeros() will throw a ValueError.\\n \\n # if new_width == 0 or new_height == 0, we won't need to do any calculation.\\n if new_width == 0 or new_height == 0:\\n return new_image\\n \\n # resizing algorithm taken from\\n # https://tech-algorithm.com/articles/nearest-neighbor-image-scaling/\\n height, width = image.shape[0], image.shape[1]\\n w_ratio = int(((width << 16) / new_width) + 1)\\n h_ratio = int(((height << 16) / new_height) + 1)\\n \\n for h in range(new_height):\\n for w in range(new_width):\\n pw = int((w*w_ratio) >> 16)\\n ph = int((h*h_ratio) >> 16)\\n new_image[h,w] = image[ph, pw]\\n ###\\n return new_image\",\n \"def expand_data(X, orig_shape=(256, 256)):\\n\\n return X.reshape((-1, *orig_shape, X.shape[-1]))\",\n \"def update_maximum_size(self):\\n if self.initialized:\\n max_size = self._compute_maximum_size()\\n self.set_max_size(max_size)\",\n \"def updateSize(self, *args):\\n return None\",\n \"def resize(self, *args):\\n return _ida_hexrays.hexwarns_t_resize(self, *args)\",\n \"def _maximum_size_changed(self):\\n self.update_maximum_size()\",\n \"def resize(data, data_type, interpolation_method, target_height, target_width):\\r\\n if target_width == data.shape[1] and target_height == data.shape[0]:\\r\\n return data\\r\\n\\r\\n if data_type == 'stereo':\\r\\n # disparity map\\r\\n if interpolation_method == 'bilinear':\\r\\n result = util_cython.resize(data, target_width, target_height, 0.5)\\r\\n else:\\r\\n result = cv2.resize(data, (target_width, target_height), interpolation=cv2.INTER_NEAREST)\\r\\n else:\\r\\n # optical flow field\\r\\n result = np.zeros((target_height, target_width, 2))\\r\\n if interpolation_method == 'bilinear':\\r\\n result[:, :, 0] = util_cython.resize(data[:, :, 0], target_width, target_height, 0.5)\\r\\n result[:, :, 1] = util_cython.resize(data[:, :, 1], target_width, target_height, 0.5)\\r\\n else:\\r\\n result = cv2.resize(data, (target_width, target_height), interpolation=cv2.INTER_NEAREST)\\r\\n return result\",\n \"def __resize_to_32x(input_data):\\n rate = 1\\n while min(input_data['img'].shape[:2])>736:\\n test_size = 736\\n if input_data['img'].shape[0] > input_data['img'].shape[1]:\\n if True: # input_data['img'].shape[1] < 512:\\n rate = test_size / input_data['img'].shape[1]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': \\\"keep-aspect-ratio\\\", 'width': test_size}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n else:\\n if True: # input_data['img'].shape[0] < 512:\\n rate = test_size / input_data['img'].shape[0]\\n seq = iaa.Sequential([\\n iaa.Scale({'height': test_size, 'width': \\\"keep-aspect-ratio\\\"}, 'cubic')\\n ])\\n input_data['img'] = seq.augment_image(input_data['img'])\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'] = [[np.cast['int32'](contour * rate) for contour in contours] for contours in\\n input_data['contour']]\\n else:\\n input_data['contour'] = [np.cast['int32'](contour * rate) for contour in input_data['contour']]\\n input_data['center_point'] = [(np.cast['int32'](point[0] * rate),\\n np.cast['int32'](point[1] * rate)) for point in input_data['center_point']]\\n p_row = 0\\n while True:\\n if (input_data['img'].shape[0] + p_row) % 32 == 0:\\n break\\n p_row += 1\\n p_col = 0\\n while True:\\n if (input_data['img'].shape[1] + p_col) % 32 == 0:\\n break\\n p_col += 1\\n\\n input_data['img'] = np.pad(input_data['img'], ((0, p_row), (0, p_col), (0, 0)), mode='constant')\\n\\n return input_data\",\n \"def _shrinkCheck(self):\\n if self.size > self.INIT_CAPACITY and self.size / self.capacity <= 0.25:\\n self._shrink()\",\n \"def resize(self, in_size, out_size):\\n scaled_origin, scaled_data = resize_origin_and_bitmap(self._origin, self._data, in_size, out_size)\\n return MultichannelBitmap(data=scaled_data, origin=scaled_origin)\",\n \"def _shrink(values, last_dim, reduction_factor):\\n\\n shape = tf.shape(values)\\n new_shape = [\\n shape[0],\\n shape[1] // reduction_factor,\\n last_dim * reduction_factor\\n ]\\n values = tf.reshape(values, new_shape)\\n return values\",\n \"def body_resize(self):\",\n \"def _resize(self, c):\\n old = list(self.items())\\n self._table = [None] * c\\n self._n = 0\\n for (k, v) in old:\\n self[k] = v\",\n \"def maxsize(self, maxsize):\\n self.shape = (int(maxsize), ) + self.shape[1:]\\n self.clear()\",\n \"def resize_to_minimum(self):\\n if self.initialized:\\n min_size = self._compute_minimum_size()\\n self.set_min_size(min_size)\\n self.resize(min_size)\",\n \"def Resize_data(data_size):\\n\\n data_size = data_size\\n\\n str_taille = 0\\n\\n data_size_n = data_size - str_taille\\n\\n taille = data_size_n//3\\n\\n reste = data_size_n - (taille*3)\\n\\n taille_sup = taille+reste\\n\\n return (taille_sup,taille)\",\n \"def resize_bytes(fobj, old_size, new_size, offset):\\n\\n if new_size < old_size:\\n delete_size = old_size - new_size\\n delete_at = offset + new_size\\n delete_bytes(fobj, delete_size, delete_at)\\n elif new_size > old_size:\\n insert_size = new_size - old_size\\n insert_at = offset + old_size\\n insert_bytes(fobj, insert_size, insert_at)\",\n \"def resize(self, new_size):\\n resized_img = opencv.resize(self.img, new_size)\\n return Image(resized_img)\",\n \"def set_size(self, w, h):\\n\\t\\tpass\",\n \"def image_resize(img, min_size=600, max_size=1000):\\n C, H, W = img.shape\\n scale1 = min_size / min(H, W)\\n scale2 = max_size / max(H, W)\\n scale = min(scale1, scale2)\\n img = img / 255\\n img = transform.resize(img, (C, H * scale, W * scale),\\n mode='reflect', anti_aliasing=False)\\n # img = pytorch_normalize(img)\\n # img = caffe_normalize(img)\\n return img\",\n \"def dec_size(self):\\r\\n self.__length -= 1\",\n \"def resize(img, size):\\n img = tf.expand_dims(img, 0)\\n return tf.image.resize_bilinear(img, size)[0,:,:,:]\",\n \"def setinputsizes(self, sizes):\\r\\n if self._closed:\\r\\n raise Error('The cursor has been closed.')\\r\\n if self.connection._closed:\\r\\n raise Error('The connection to the database has been closed.')\\r\\n else:\\r\\n pass\",\n \"def assigninput(self, input):\\n if type(input) == str: # string type\\n self.name = input\\n else: # array, list, tuple\\n if len(input) == 2:\\n print input[0], 'input0'\\n try:\\n n = len(input[0])\\n except:\\n n = 1\\n if n == 1:\\n\\t\\t print 'INITIALIZING SPARSE ARRAY TO ZEROS'\\n self.ny, self.nx = input\\n input = zeros(input, int)\\n ## BELOW NOT QUITE RIGHT...\\n ## ACTUALLY IT JUST TAKES LONG TO BUILD THE HUGE ARRAY\\n # TAKES TIME TO UNRAVEL\\n # LET'S JUST MAKE IT RIGHT THE FIRST TIME:\\n #input = zeros(input[0] * input[1], 'int')\\n #self.data = input\\n self.data = ravel(array(input)) # ravel ADDED MUCH LATER\",\n \"def resize(img, min_size=512):\\n width, height, _ = tf.unstack(tf.shape(img), num=3)\\n if height < width:\\n new_height = min_size\\n new_width = int(width * new_height / height)\\n else:\\n new_width = min_size\\n new_height = int(height * new_width / width)\\n\\n img = tf.image.resize(img, size=(new_width, new_height))\\n return img\",\n \"def handleResize(self):\\n pass\",\n \"def resize(self, width, height):\\n if self.example:\\n self.example.resize(width, height)\",\n \"def resize_image_data(data, resize_shape):\\n if data is None or len(resize_shape) == 0:\\n return data\\n\\n if len(data.shape) > 1 and np.array_equal(data[0].shape, resize_shape):\\n return data\\n\\n output_data = []\\n for im in data:\\n output_data.append(zoom(input=im, zoom=np.divide(resize_shape, im.shape)))\\n\\n return np.array(output_data)\",\n \"def resizeChildren(self,newSize):\\n assert newSize > len(self.children)\\n self.children += [None] * (newSize - len(self.children))\",\n \"def np_resize(img, input_shape):\\n height, width = input_shape\\n return cv2.resize(img, (width, height))\",\n \"def np_resize(img, input_shape):\\n height, width = input_shape\\n return cv2.resize(img, (width, height))\",\n \"def resize(self, dims, default=None):\\n\\t\\twidth, height = dims\\n\\t\\tassert isinstance(width, int)\\n\\t\\tassert isinstance(height, int)\\n\\t\\tassert width > 0\\n\\t\\tassert height > 0\\n\\t\\tself.dims = Size(width, height)\\n\\t\\t# TODO maybe clearing is not the best idea, maybe I should keep old values wherever is possible.\\n\\t\\tself.data = [copy.deepcopy(default) for _ in range(width * height)]\",\n \"def _check_and_resize_input_tensor(self, input_data_map):\\r\\n is_need_reshape = False\\r\\n input_shape_list = []\\r\\n\\r\\n for model_input in self.model_inputs:\\r\\n tensor_name = model_input.name.rstrip()\\r\\n input_data = input_data_map.get(tensor_name, None)\\r\\n if input_data is None:\\r\\n raise ValueError(f'{tensor_name} is not in model inputs')\\r\\n if model_input.shape != list(input_data.shape):\\r\\n self.logger.warning(f'model input shape: {model_input.shape} is not equal'\\r\\n f'with input data shape: {input_data.shape}, model input shape'\\r\\n f'would be reshaped')\\r\\n is_need_reshape = True\\r\\n input_shape_list.append(list(input_data.shape))\\r\\n\\r\\n if is_need_reshape:\\r\\n self.model_session.resize(self.model_inputs, input_shape_list)\\r\\n self.model_inputs = self.model_session.get_inputs()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6756476","0.6747655","0.6701643","0.6621688","0.6541919","0.6481869","0.64757544","0.63817364","0.6371053","0.63494724","0.63349277","0.631679","0.6284716","0.62780786","0.62718976","0.6259087","0.62462807","0.61517614","0.6054047","0.5986684","0.5986038","0.5961687","0.59586847","0.5947642","0.5944008","0.5933804","0.5907133","0.58948416","0.58749425","0.5837909","0.58363146","0.5836176","0.5826402","0.58175933","0.57760173","0.574905","0.57420427","0.57366675","0.573184","0.56983507","0.5689354","0.56833917","0.5683004","0.56695366","0.5667458","0.5666197","0.5661232","0.5643739","0.5638898","0.56366163","0.5633482","0.56312937","0.56228054","0.5621773","0.56140876","0.5612108","0.5604956","0.5576605","0.5575069","0.55685514","0.5559668","0.5551117","0.5545876","0.55298036","0.5517277","0.5512608","0.55114156","0.5510612","0.55103916","0.5501399","0.5497607","0.5494633","0.54897314","0.54869086","0.54842085","0.54826707","0.54693246","0.5467385","0.5463932","0.54638714","0.5460567","0.5452959","0.545092","0.5441891","0.5432238","0.54266477","0.5415296","0.54114985","0.54079735","0.54077667","0.539975","0.5387335","0.5381509","0.538051","0.5376611","0.53701323","0.5352042","0.53477985","0.53477985","0.5347797","0.53456"],"string":"[\n \"0.6756476\",\n \"0.6747655\",\n \"0.6701643\",\n \"0.6621688\",\n \"0.6541919\",\n \"0.6481869\",\n \"0.64757544\",\n \"0.63817364\",\n \"0.6371053\",\n \"0.63494724\",\n \"0.63349277\",\n \"0.631679\",\n \"0.6284716\",\n \"0.62780786\",\n \"0.62718976\",\n \"0.6259087\",\n \"0.62462807\",\n \"0.61517614\",\n \"0.6054047\",\n \"0.5986684\",\n \"0.5986038\",\n \"0.5961687\",\n \"0.59586847\",\n \"0.5947642\",\n \"0.5944008\",\n \"0.5933804\",\n \"0.5907133\",\n \"0.58948416\",\n \"0.58749425\",\n \"0.5837909\",\n \"0.58363146\",\n \"0.5836176\",\n \"0.5826402\",\n \"0.58175933\",\n \"0.57760173\",\n \"0.574905\",\n \"0.57420427\",\n \"0.57366675\",\n \"0.573184\",\n \"0.56983507\",\n \"0.5689354\",\n \"0.56833917\",\n \"0.5683004\",\n \"0.56695366\",\n \"0.5667458\",\n \"0.5666197\",\n \"0.5661232\",\n \"0.5643739\",\n \"0.5638898\",\n \"0.56366163\",\n \"0.5633482\",\n \"0.56312937\",\n \"0.56228054\",\n \"0.5621773\",\n \"0.56140876\",\n \"0.5612108\",\n \"0.5604956\",\n \"0.5576605\",\n \"0.5575069\",\n \"0.55685514\",\n \"0.5559668\",\n \"0.5551117\",\n \"0.5545876\",\n \"0.55298036\",\n \"0.5517277\",\n \"0.5512608\",\n \"0.55114156\",\n \"0.5510612\",\n \"0.55103916\",\n \"0.5501399\",\n \"0.5497607\",\n \"0.5494633\",\n \"0.54897314\",\n \"0.54869086\",\n \"0.54842085\",\n \"0.54826707\",\n \"0.54693246\",\n \"0.5467385\",\n \"0.5463932\",\n \"0.54638714\",\n \"0.5460567\",\n \"0.5452959\",\n \"0.545092\",\n \"0.5441891\",\n \"0.5432238\",\n \"0.54266477\",\n \"0.5415296\",\n \"0.54114985\",\n \"0.54079735\",\n \"0.54077667\",\n \"0.539975\",\n \"0.5387335\",\n \"0.5381509\",\n \"0.538051\",\n \"0.5376611\",\n \"0.53701323\",\n \"0.5352042\",\n \"0.53477985\",\n \"0.53477985\",\n \"0.5347797\",\n \"0.53456\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88997,"cells":{"query":{"kind":"string","value":"resize images and cameras to fit the network (can be divided by base image size)"},"document":{"kind":"string","value":"def crop_mvs_input(images, cams, depth_image=None):\n\n # crop images and cameras\n for view in range(FLAGS.view_num):\n h, w = images[view].shape[0:2]\n new_h = h\n new_w = w\n if new_h > FLAGS.height:\n new_h = FLAGS.height\n else:\n new_h = int(math.ceil(h / FLAGS.base_image_size) * FLAGS.base_image_size)\n if new_w > FLAGS.width:\n new_w = FLAGS.width\n else:\n new_w = int(math.ceil(w / FLAGS.base_image_size) * FLAGS.base_image_size)\n start_h = int(math.ceil((h - new_h) / 2))\n start_w = int(math.ceil((w - new_w) / 2))\n finish_h = start_h + new_h\n finish_w = start_w + new_w\n images[view] = images[view][start_h:finish_h, start_w:finish_w]\n cams[view][1][0][2] = cams[view][1][0][2] - start_w\n cams[view][1][1][2] = cams[view][1][1][2] - start_h\n\n # crop depth image\n if not depth_image is None:\n depth_image = depth_image[start_h:finish_h, start_w:finish_w]\n return images, cams, depth_image\n else:\n return images, cams"},"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 resize_real_images(self, images):\n block_idx = (self.growth_idx + 1) // 2\n height, width = self.params[\"generator_projection_dims\"][0:2]\n resized_image = tf.image.resize(\n images=images,\n size=[\n height * (2 ** block_idx), width * (2 ** block_idx)\n ],\n method=\"nearest\",\n name=\"resized_real_image_{}\".format(self.growth_idx)\n )\n\n return resized_image","def image_resize(img, min_size=600, max_size=1000):\n C, H, W = img.shape\n scale1 = min_size / min(H, W)\n scale2 = max_size / max(H, W)\n scale = min(scale1, scale2)\n img = img / 255\n img = transform.resize(img, (C, H * scale, W * scale),\n mode='reflect', anti_aliasing=False)\n # img = pytorch_normalize(img)\n # img = caffe_normalize(img)\n return img","def resize_images(images, size):\n num_images = images.shape[0]\n num_channels = images.shape[3]\n output_images = numpy.empty((num_images, size[0], size[1], num_channels), dtype=images.dtype)\n with tqdm.tqdm(total=num_images) as progress:\n for i in range(num_images):\n output_images[i, :, :, :] = resize_image(images[i, :, :, :], size)\n progress.update(1)\n\n return output_images","def resize_frames(self, frames):\n tf.image.resize_images(X, (IMAGE_SIZE, IMAGE_SIZE), \n tf.image.ResizeMethod.NEAREST_NEIGHBOR)","def resize_images(imgs, size=(720, 720)):\n res = []\n for img in imgs:\n\n factor = max(1, size[0]/float(img.shape[0]), size[1]/float(img.shape[1]))\n if factor != 1: img = scale_image(img, factor)\n\n img = center_crop(img, size)\n res.append(img)\n\n return res","def run(self, image):\n # width, height = image.size\n # resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\n # target_size = (int(resize_ratio * width), int(resize_ratio * height))\n target_size = (self.INPUT_SIZE, self.INPUT_SIZE)\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\n net_image = resized_image\n if params.HZ_preprocess_activate:\n net_image = params.image_preprocess_func(resized_image)\n net_image = np.expand_dims(net_image, axis=-1)\n batch_seg_map = self.sess.run(\n self.OUTPUT_TENSOR_NAME,\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(net_image)]})\n seg_map = batch_seg_map[0]\n return resized_image, seg_map","def transform_images(img, size):\n return tf.image.resize(img, (size, size)) / 255","def resizeContours(self):\n scale = 500/self.images.shape[1]\n print('Scaling images by {} for display'.format(scale))\n self.lumenCopy = (self.lumen[0][:], self.lumen[1][:])\n self.plaqueCopy = (self.plaque[0][:], self.plaque[1][:])\n self.stentCopy = (self.stent[0][:], self.stent[1][:])\n self.lumen = self.resize(self.lumen, scale)\n self.plaque = self.resize(self.plaque, scale)\n self.stent = self.resize(self.stent, scale)","def resize_function(input):\n\n from keras.backend import tf as ktf\n return ktf.image.resize_images(input, (64, 64))","def resize(input, size):\n layer = tf.image.resize_images(input, size, method=tf.image.ResizeMethod.BICUBIC, align_corners=True,\n preserve_aspect_ratio=True)\n return layer","def set_size(self, size=None):\n if not size:\n size = self.output_size\n self.img = cv2.resize(self.img, size)\n self.update_image()\n self.update_size()","def crop_and_resize(input):\r\n\r\n # Locate the last Relu node of the first backbone (pre 1st NMS). Relu node contains feature maps\r\n # necessary for CropAndResize plugin.\r\n relu_name = \"StatefulPartitionedCall/model/\"\r\n relu_node = [node for node in self.graph.nodes if node.op == \"Relu\" and relu_name in node.name][-1]\r\n\r\n # Before passing 1st NMS's detection boxes (rois) to CropAndResize, we need to clip and normalize them.\r\n # Clipping happens for coordinates that are less than 0 and more than self.height.\r\n # Normalization is just divison of every coordinate by self.height.\r\n clip_min = np.asarray([0], dtype=np.float32)\r\n clip_max = np.asarray([self.height], dtype=np.float32)\r\n clip_out = self.graph.elt_const_clip(\"Clip\", \"FirstNMS/detection_boxes_clipper\", input, clip_min, clip_max)\r\n div_const = np.expand_dims(np.asarray([self.height, self.height, self.height, self.height], dtype=np.float32), axis=(0, 1))\r\n div_out = self.graph.elt_const(\"Div\", \"FirstNMS/detection_boxes_normalizer\", clip_out[0], div_const)\r\n\r\n # Linear transformation to convert box coordinates from (TopLeft, BottomRight) Corner encoding\r\n # to CenterSize encoding.\r\n matmul_const = np.matrix('0.5 0 -1 0; 0 0.5 0 -1; 0.5 0 1 0; 0 0.5 0 1', dtype=np.float32)\r\n matmul_out = self.graph.elt_const(\"MatMul\", \"FirstNMS/detection_boxes_conversion\", div_out[0], matmul_const)\r\n\r\n # Additionally CropAndResizePlugin requires 4th dimension of 1: [N, B, 4, 1], so\r\n # we need to add unsqeeze node to make tensor 4 dimensional. \r\n unsqueeze_node = self.graph.unsqueeze( \"FirstNMS/detection_boxes_unsqueeze\", div_out)\r\n\r\n # CropAndResizePlugin's inputs \r\n feature_maps = relu_node.outputs[0]\r\n rois = unsqueeze_node[0]\r\n\r\n # CropAndResize TensorRT Plugin.\r\n # Two inputs are given to the CropAndResize TensorRT node:\r\n # - The feature_maps (from the Relu node found above): [batch_size, channel_num, height, width]\r\n # - The rois (in other words clipped and normalized detection boxes resulting fromm 1st NMS): [batch_size, featuremap, 4, 1]\r\n cnr_inputs = [feature_maps, rois]\r\n cnr_op = \"CropAndResize\"\r\n cnr_attrs = {\r\n 'crop_width': self.initial_crop_size,\r\n 'crop_height': self.initial_crop_size,\r\n }\r\n\r\n # CropAndResize Outputs.\r\n cnr_pfmap = gs.Variable(name=\"pfmap\", dtype=np.float32,\r\n shape=[self.batch_size, self.first_stage_max_proposals, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size])\r\n cnr_outputs = [cnr_pfmap]\r\n\r\n # Create the CropandResize Plugin node with the selected inputs. \r\n self.graph.plugin(\r\n op=cnr_op,\r\n name=\"cnr/crop_and_resize\",\r\n inputs=cnr_inputs,\r\n outputs=cnr_outputs,\r\n attrs=cnr_attrs)\r\n log.info(\"Created CropAndResize plugin '{}' with attributes: {}\".format(cnr_op, cnr_attrs))\r\n\r\n # Reshape node that is preparing CropAndResize's pfmap output shape for MaxPool node that comes next,\r\n # after that is 2nd backbone that leads us to final 2nd NMS.\r\n reshape_shape = np.asarray([self.first_stage_max_proposals*self.batch_size, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size], dtype=np.int64)\r\n reshape_node = self.graph.elt_const(\"Reshape\", \"StatefulPartitionedCall/CropandResize/reshape\", cnr_outputs[0], reshape_shape)\r\n maxpl_name = \"StatefulPartitionedCall/MaxPool2D/MaxPool\"\r\n maxpool_node = [node for node in self.graph.nodes if node.op == \"MaxPool\" and maxpl_name == node.name][0]\r\n maxpool_node.inputs[0] = reshape_node[0]\r\n\r\n # Return linear transformation node, it will be located between 1st and 2nd NMS, \r\n # so we need to pass and connect it to 2nd NMS.\r\n return matmul_out[0]","def _resize_img(self, results):\n for key in results.get('img_fields', ['img']):\n if self.keep_ratio:\n img, scale_factor = mmcv.imrescale(\n results[key],\n results['scale'],\n return_scale=True,\n interpolation=self.interpolation,\n backend=self.backend)\n # the w_scale and h_scale has minor difference\n # a real fix should be done in the mmcv.imrescale in the future\n new_h, new_w = img.shape[:2]\n h, w = results[key].shape[:2]\n w_scale = new_w / w\n h_scale = new_h / h\n else:\n img, w_scale, h_scale = mmcv.imresize(\n results[key],\n results['scale'],\n return_scale=True,\n interpolation=self.interpolation,\n backend=self.backend)\n results[key] = img\n\n scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],\n dtype=np.float32)\n results['img_shape'] = img.shape\n # in case that there is no padding\n results['pad_shape'] = img.shape\n results['scale_factor'] = scale_factor\n results['keep_ratio'] = self.keep_ratio","def resizeImages(img_path,size=(50,50)):\n image = cv2.imread(img_path)\n resized = cv2.resize(image, size, interpolation=cv2.INTER_CUBIC)\n img=np.array([resized.flatten()])\n #print('resized image')\n return img","def resize_image(self, name, frame_dims):\n logger.debug(\"Resizing image: (name: '%s', frame_dims: %s\", name, frame_dims)\n displayimg = self._previewtrain[name][0]\n if frame_dims:\n frameratio = float(frame_dims[0]) / float(frame_dims[1])\n imgratio = float(displayimg.size[0]) / float(displayimg.size[1])\n\n if frameratio <= imgratio:\n scale = frame_dims[0] / float(displayimg.size[0])\n size = (frame_dims[0], int(displayimg.size[1] * scale))\n else:\n scale = frame_dims[1] / float(displayimg.size[1])\n size = (int(displayimg.size[0] * scale), frame_dims[1])\n logger.debug(\"Scaling: (scale: %s, size: %s\", scale, size)\n\n # Hacky fix to force a reload if it happens to find corrupted\n # data, probably due to reading the image whilst it is partially\n # saved. If it continues to fail, then eventually raise.\n for i in range(0, 1000):\n try:\n displayimg = displayimg.resize(size, Image.ANTIALIAS)\n except OSError:\n if i == 999:\n raise\n continue\n break\n self._previewtrain[name][1] = ImageTk.PhotoImage(displayimg)","def resize_for_interface(cv_img):\n\n height, width, channels = cv_img.shape\n width_ratio = width / Images.IMAGES_WIDTH\n height_ratio = height / Images.IMAGES_HEIGHT\n\n ratio = max(width_ratio, height_ratio)\n\n if ratio > 1:\n new_size = (int(width / ratio), int(height / ratio))\n return cv2.resize(cv_img, new_size)\n else:\n # No need to resize\n return cv_img","def resize_images(self, images):\n \n img_list = []\n \n for img in images:\n \n yield np.resize(img, (64, 64, 3))","def ResizeImages(\n images,\n size,\n method=tf.image.ResizeMethod.BILINEAR,\n align_corners=True,\n data_format='channels_last'):\n l = images\n if data_format == 'channels_first':\n l = tf.transpose(l, [0,2,3,1])\n l = tf.image.resize_images(l, size, method, align_corners)\n if data_format == 'channels_first':\n l = tf.transpose(l, [0,3,1,2])\n ret = tf.identity(l, name='output')\n return ret","def rescale_images(original_images):\n mobile_net_possible_dims = [128, 160, 192, 224]\n dim_goal = 128\n \n for dim in mobile_net_possible_dims:\n if original_images.shape[1] <= dim:\n dim_goal = dim\n break;\n print(f\"Image rescaled from dimension {original_images.shape[1]} to {dim_goal} for MobileNet\")\n scale = dim_goal/original_images.shape[1]\n images = np.empty((original_images.shape[0], dim_goal, dim_goal))\n for i, original_image in enumerate(original_images):\n images[i] = rescale(original_image, (scale, scale), multichannel=False)\n return images","def _resize_masks(self, results):\n for key in results.get('mask_fields', []):\n if results[key] is None:\n continue\n if self.keep_ratio:\n results[key] = results[key].rescale(results['scale'])\n else:\n results[key] = results[key].resize(results['img_shape'][:2])","def _resize_masks(self, results):\n for key in results.get('mask_fields', []):\n if results[key] is None:\n continue\n if self.keep_ratio:\n results[key] = results[key].rescale(results['scale'])\n else:\n results[key] = results[key].resize(results['img_shape'][:2])","def resize_batch(images : List[np.ndarray], size : Tuple[int,int,int,int], resize_kind='stretch') :\n assert resize_kind in ['stretch'] and len(size) == 4\n n, w, h, c = size if size[-1]==3 else tuple(size[i] for i in [0,3,1,2])\n resize = lambda x: BaseRuntime.resize_stretch(x, (h,w))\n dtype = images[0].dtype\n n_pad = n - len(images)\n batch_pad = [np.zeros((h,w,c),dtype=dtype)] * n_pad\n batch_image = list(map(resize, images))\n batch_image = batch_image + batch_pad\n return np.stack(batch_image)","def dataset_resize_images(self, img_name, label_name):\n image_string = tf.read_file(img_name)\n image_decoded = tf.image.decode_jpeg(image_string, channels=3)\n image_resized = tf.image.resize_images(image_decoded, [self.img_h, self.img_w])\n image_resized /= 255\n b, g, r = tf.split(image_resized, 3, 2)\n del image_string\n del image_resized\n return tf.concat([r, g, b], 2), label_name","def _resize_img(self, results):\n for key in results.get('img_fields', ['img']):\n if self.keep_ratio:\n img, scale_factor = general_ocr.imrescale(\n results[key],\n results['scale'],\n return_scale=True,\n backend=self.backend)\n # the w_scale and h_scale has minor difference\n # a real fix should be done in the general_ocr.imrescale in the future\n new_h, new_w = img.shape[:2]\n h, w = results[key].shape[:2]\n w_scale = new_w / w\n h_scale = new_h / h\n else:\n img, w_scale, h_scale = general_ocr.imresize(\n results[key],\n results['scale'],\n return_scale=True,\n backend=self.backend)\n results[key] = img\n\n scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],\n dtype=np.float32)\n results['img_shape'] = img.shape\n # in case that there is no padding\n results['pad_shape'] = img.shape\n results['scale_factor'] = scale_factor\n results['keep_ratio'] = self.keep_ratio","def resize_multiple_images(src_path, dst_path, img_size=None):\r\n for filename in os.listdir(src_path):\r\n try:\r\n img = cv.imread(os.path.join(src_path, filename))\r\n\r\n if img_size is None:\r\n # this shape should be the same as the one of the window used to take photos\r\n img_size = (640, 480)\r\n\r\n new_img = cv.resize(img, img_size)\r\n\r\n filename = filename.split(sep='.')[0]+'.jpg'\r\n cv.imwrite(os.path.join(dst_path, filename), new_img)\r\n print('Resized and saved {} successfully.'.format(filename))\r\n except:\r\n continue","def crop_and_resize(image, boxes, size):\n box_ind = keras.backend.zeros_like(boxes, tensorflow.int32)\n box_ind = box_ind[..., 0]\n box_ind = keras.backend.reshape(box_ind, [-1])\n\n boxes = keras.backend.reshape(boxes, [-1, 4])\n\n return tensorflow.image.crop_and_resize(image, boxes, box_ind, size)","def preprocess_train_keep_aspect_ratio(im, boxes, classes, inst_masks, mask, min_side, max_side,\n canvas_height, canvas_width,\n use_augment=False, training_scale=[0.3, 0.5, 0.7, 1.0]):\n im, inst_masks, mask, boxes, classes, im_scale = resize_as_min_side(im, inst_masks, mask, boxes, classes,\n min_side=min_side, max_side=max_side)\n\n im, inst_masks, mask, boxes, classes = random_flip(im, inst_masks, mask, boxes, classes)\n if use_augment:\n if np.random.choice([0, 1]) != 0:\n scale = np.random.choice(training_scale) # adding more small objects\n im, inst_masks, mask, boxes, classes = random_scale(im, inst_masks, mask, boxes, classes, scale=scale)\n\n im, inst_masks, mask, boxes, classes = pad_to_canvas(im, inst_masks, mask, boxes, classes,\n canvas_width=canvas_width,\n canvas_height=canvas_height)\n\n # im = distort_color(im)\n im = imcv2_recolor(im)\n\n boxes = np.asarray(boxes, dtype=np.float32)\n inst_masks = np.zeros([1, im.shape[0], im.shape[1]], dtype=inst_masks.dtype) if inst_masks.size == 0 else inst_masks\n return im, boxes, classes, inst_masks, mask, im_scale","def transform_images(x_image: tf.Tensor, size: int) -> tf.Tensor:\n x_image = tf.image.resize(x_image, (size, size))\n x_image = x_image / 255\n return x_image","def run(self, image):\r\n width, height = image.size\r\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\r\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\r\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\r\n batch_seg_map = self.sess.run(\r\n self.OUTPUT_TENSOR_NAME,\r\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\r\n seg_map = batch_seg_map[0]\r\n return resized_image, seg_map","def run(self, image):\n width, height = image.size\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\n batch_seg_map = self.sess.run(\n self.OUTPUT_TENSOR_NAME,\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\n seg_map = batch_seg_map[0]\n return resized_image, seg_map","def _pool_and_resize(self):\n # Pool if there are enough screens to do so.\n if self.frame_skip > 1:\n np.maximum(\n self.screen_buffer[0],\n self.screen_buffer[1],\n out=self.screen_buffer[0])\n\n transformed_image = cv2.resize(\n self.screen_buffer[0], (self.screen_size, self.screen_size),\n interpolation=cv2.INTER_AREA)\n int_image = np.asarray(transformed_image, dtype=np.uint8)\n return np.expand_dims(int_image, axis=2)","def resize_128(img): \n return cv2.resize(img,(128,128))","def preprocess_image(image, model_image_size):\n #resized_image = cv2.resize(image, tuple(reversed(model_image_size)), cv2.INTER_AREA)\n resized_image = letterbox_resize(image, tuple(reversed(model_image_size)))\n image_data = np.asarray(resized_image).astype('float32')\n image_data = normalize_image(image_data)\n image_data = np.expand_dims(image_data, 0) # Add batch dimension.\n return image_data","def resize_all_images(image_dir, width, height, resize_type):\n if width == \"\" and height == \"\":\n return 0\n print(\"Enter resizing image.\")\n print(\"Enter resizing.\", width)\n pool = Pool(1)\n pool.starmap(resize_image, zip(\n image_dir, itertools.repeat(width), itertools.repeat(height), itertools.repeat(resize_type)))\n pool.close()\n pool.join()","def enforce_size(img, targets, masks, num_crowds, new_w, new_h):\n with torch.no_grad():\n _, h, w = img.size()\n\n if False: #h == new_h and w == new_w:\n return img, targets, masks, num_crowds\n\n # Resize the image so that it fits within new_w, new_h\n w_prime = new_w\n h_prime = h * new_w / w\n\n if h_prime > new_h:\n w_prime *= new_h / h_prime\n h_prime = new_h\n\n w_prime = int(w_prime)\n h_prime = int(h_prime)\n\n # Do all the resizing\n img = F.interpolate(img.unsqueeze(0),\n (h_prime, w_prime),\n mode='bilinear',\n align_corners=False)\n img.squeeze_(0)\n\n # Act like each object is a color channel\n masks = F.interpolate(masks.unsqueeze(0),\n (h_prime, w_prime),\n mode='nearest')\n masks.squeeze_(0)\n\n # Scale bounding boxes (this will put them in the top left corner in the case of padding)\n targets[:, [0, 2]] *= (w_prime / new_w)\n targets[:, [1, 3]] *= (h_prime / new_h)\n\n # Finally, pad everything to be the new_w, new_h\n pad_dims = (0, new_w - w_prime, 0, new_h - h_prime)\n img = F.pad( img, pad_dims, mode='constant', value=0)\n masks = F.pad(masks, pad_dims, mode='constant', value=0)\n\n return img, targets, masks, num_crowds","def resize_if_big(im_cv):\n MAX_IMG_SIZE = 900 * 1024\n height, width, channels = im_cv.shape\n img_size = width * height * channels\n\n if channels != 3:\n print(\"image must be bgr24\")\n sys.exit(1)\n\n if img_size > MAX_IMG_SIZE:\n scale = math.sqrt(MAX_IMG_SIZE / img_size)\n im_cv = cv2.resize(im_cv, (0, 0), fx=scale, fy=scale)\n height, width, channels = im_cv.shape\n img_size_kb = int(width * height * channels/1024)\n print(f\"Scaled down to {width}x{height} ({img_size_kb} KB) to fit max size\")\n return im_cv","def resize(frame: Frame):\n\n frame.img = cv2.resize(frame.img, (720, 480))\n frame.orginal_img = cv2.resize(frame.orginal_img, (720, 480))\n\n return frame","def imgProcessing(self):\n if (self.image_width > 320):\n self.cv_image = imutils.resize(self.cv_image, width = 320)\n else:\n pass\n\n \"\"\" optional -- image-mirrored \"\"\"\n # self.cv_image = cv2.flip(self.cv_image, 1)","def resize_image(img):\n ratio = float(img.size[1]) / float(img.size[0])\n\n if ratio > 1.73:\n h, w = 320, 160 # 512, 256\n elif ratio < 1.0 / 1.73:\n h, w = 160, 320 # 256, 512\n elif ratio > 1.41:\n h, w = 384, 256\n elif ratio < 1. / 1.41:\n h, w = 256, 384\n elif ratio > 1.15:\n h, w = 320, 240 # 512, 384\n elif ratio < 1. / 1.15:\n h, w = 240, 320 # 384, 512\n else:\n h, w = 320, 320 # 384, 384\n\n h = int(h)\n w = int(w)\n img = TF.resize(img, size=[h, w], interpolation=Image.BILINEAR)\n return img","def reshape_coch_kell_2018(nets):\n print('### WARNING: tf.image.resize_images is not trusted, use caution ###')\n nets['min_cochleagram'] = tf.reduce_min(nets['cochleagram'])\n nets['max_cochleagram'] = tf.reduce_max(nets['cochleagram'])\n # it is possible that this scaling is going to mess up the gradients for the waveform generation\n nets['scaled_cochleagram'] = 255*(1-((nets['max_cochleagram']-nets['cochleagram'])/(nets['max_cochleagram']-nets['min_cochleagram'])))\n nets['reshaped_cochleagram'] = tf.image.resize_images(nets['scaled_cochleagram'],[256,256], align_corners=False, preserve_aspect_ratio=False)\n return nets, 'reshaped_cochleagram'","def scale_images(images, new_shape):\n\n images_list = list()\n\n for image in images:\n new_image = resize(image, new_shape)\n images_list.append(new_image)\n \n return np.asarray(images_list)","def _resize_video(self, images, dim=64):\n ret = np.zeros((images.shape[0], dim, dim, 3))\n\n for i in range(images.shape[0]):\n ret[i] = cv2.resize(images[i], dsize=(dim, dim),\n interpolation=cv2.INTER_CUBIC)\n\n return ret.astype(np.uint8)","def resize_multiple_images(src_path, dst_path):\n for filename in os.listdir(src_path):\n img=Image.open(src_path+'/'+filename)\n new_img = img.resize((96,96,))\n #new_img.resize(96,96,1)\n if not os.path.exists(dst_path):\n os.makedirs(dst_path)\n new_img.save(dst_path+'/'+filename)\n print('Resized and saved {} successfully.'.format(filename))","def reconstruct_image(self, net, images, name):\n target_img_grid = torchvision.utils.make_grid(images)\n images = images.to(self.device)\n output = net(images)\n img_grid = torchvision.utils.make_grid(output.cpu().data)\n if self.writer is not None:\n self.writer.add_image(f'{name} Reconstruct Image', target_img_grid, self.ae_epoch)\n self.writer.add_image('Target Image', img_grid, self.ae_epoch)","def preprocess(img, min_size, max_size):\n if(min_size > max_size):\n raise Exception('min_size should not exceed max_size')\n \n width, height = img.size\n minDim = min(width,height)\n maxDim = max(width,height)\n scale_shorter_side = min_size/minDim\n scale_longer_side = maxDim * scale_shorter_side\n if(scale_longer_side > max_size):\n scale = max_size/maxDim\n else:\n scale = scale_shorter_side\n transform = transforms.Compose([\n transforms.Resize((round(img.height*scale),round(img.width * scale))),\n transforms.ToTensor(),\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n ])\n img = transform(img)\n return scale,img","def reduce_resolution(input_dir, output_dir, factor=2):\n # Get the images.\n downsample_ratio = 1.0 / args.factor\n tiles = glob.glob(os.path.join(args.input_dir, 'S_*/*.tif*'))\n tiles.sort()\n print('Number of Tiles: ', len(tiles))\n print('Downsample Ratio: ', downsample_ratio)\n\n # Downsample the images by the requested factor with OpenCV's resize().\n for t in tqdm(tiles):\n dirname = os.path.basename(os.path.dirname(t))\n filename = os.path.basename(t)\n os.makedirs(os.path.join(args.output_dir, dirname), exist_ok=True)\n f_out = os.path.join(args.output_dir, dirname, filename)\n im = cv2.imread(t, 0)\n im_down = cv2.resize(im, (0, 0), fx=downsample_ratio, fy=downsample_ratio)\n cv2.imwrite(f_out, im_down)","def resize_large_images(image_urls):\n global cnt_resized_images\n\n for image_url in image_urls:\n file_name = web.get_file_name(image_url)\n file_path = cfg.PHOTO_DIR + file_name\n img = Image.open(file_path)\n width = img.size[0]\n if width > cfg.MAX_WIDTH:\n resize.resize_to_screen_width(file_path)\n cnt_resized_images += 1","def test_resize(dummy_input):\n # Test the 2D image: H, W, C\n image, label = dummy_input(image_size=(512, 512, 3),\n label_size=(512, 512, 1))\n transform = Resize(size=(64, 64))\n _image, _label = transform(image, label, resize_orders=[3, 0])\n assert _image.shape == (64, 64, 3)\n assert _image.dtype == image.dtype\n assert _label.shape == (64, 64, 1)\n assert _label.dtype == label.dtype\n\n # Test the 3D image: H, W, D, C\n image, label = dummy_input(image_size=(512, 512, 20, 3),\n label_size=(512, 512, 20, 1))\n transform = Resize(size=(64, 64, 10))\n _image, _label = transform(image, label, resize_orders=[3, 0])\n assert _image.shape == (64, 64, 10, 3)\n assert _image.dtype == image.dtype\n assert _label.shape == (64, 64, 10, 1)\n assert _label.dtype == label.dtype","def resize(image, size):\n return np.array(Image.fromarray(image).resize(size))","def reshape_raw_images(raw_im, \n resize_shape,\n ):\n _reshaped_im = np.array([cv2.resize(_lr, tuple(resize_shape[-2:]), \n interpolation=cv2.INTER_AREA) for _lr in raw_im])\n return _reshaped_im","def scale_boxes(boxes, image_shape):\n height = image_shape[0]\n width = image_shape[1]\n image_dims = K.stack([height, width, height, width])\n image_dims = K.reshape(image_dims, [1, 4])\n boxes = boxes * image_dims\n return boxes","def __resize_image(self, img):\n return cv2.resize(img, self.g.img_size, \n interpolation = cv2.INTER_CUBIC)","def process_image(fl):\n #print(\"processing of images\")\n print(fl)\n img = cv2.imread(fl, cv2.IMREAD_COLOR)\n resized_img = cv2.resize(img, (146, 243), interpolation=cv2.INTER_CUBIC)\n return resized_img","def resizeImage(image, newSize):\n\n # scale image\n scaledImage = cv2.resize(image, newSize)\n return scaledImage","def resize(img, size):\n img = tf.expand_dims(img, 0)\n return tf.image.resize_bilinear(img, size)[0,:,:,:]","def resize(im, target_size, max_size):\n im_shape = im.shape\n im_size_min = np.min(im_shape[0:2])\n im_size_max = np.max(im_shape[0:2])\n im_scale = float(target_size) / float(im_size_min)\n # prevent bigger axis from being more than max_size:\n if np.round(im_scale * im_size_max) > max_size:\n im_scale = float(max_size) / float(im_size_max)\n im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)\n return im, im_scale","def __init__(self, embed_size=256, finetune=False, cnn_type='resnet50',\n use_abs=False, no_imgnorm=False):\n super(EncoderImageFull, self).__init__()\n self.embed_size = embed_size\n self.no_imgnorm = no_imgnorm\n self.use_abs = use_abs\n\n # Load a pre-trained model\n model = get_model(name=cnn_type, num_classes=5607)\n model = torch.nn.DataParallel(model)\n model.to(\"cuda\")\n checkpoint = torch.load(\"/mnt/data2/betty/webvision_train/results/resnet50/5000classes_onemonth/model_best.tar\")\n model.load_state_dict(checkpoint['state_dict'])\n \n print(\"Successfully load the saved model at model_best.tar\") \n\n self.cnn = model\n\n\n # For efficient memory usage.\n for param in self.cnn.parameters():\n param.requires_grad = False\n\n # Replace the last fully connected layer of CNN with a new one\n \n if cnn_type.startswith('resnet'):\n self.fc = nn.Linear(self.cnn.module.fc.in_features, embed_size)\n self.cnn.module.fc = nn.Sequential()\n else:\n print(\"error in chosing the architecture\")\n return\n\n self.init_weights()","def preprocess_image(image: Image.Image, max_size: int = 1200) -> Image.Image:\n width_0, height_0 = image.size\n\n if max((width_0, height_0)) <= max_size:\n return image\n\n if width_0 > height_0:\n aspect_ratio = max_size / float(width_0)\n new_height = int(float(height_0) * float(aspect_ratio))\n image = image.resize((max_size, new_height), Image.ANTIALIAS)\n return image\n else:\n aspect_ratio = max_size / float(height_0)\n new_width = int(float(width_0) * float(aspect_ratio))\n image = image.resize((max_size, new_width), Image.ANTIALIAS)\n return image","def run(self, image):\n width, height = image.size\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\n batch_seg_map = self.sess.run(\n self.OUTPUT_TENSOR_NAME,\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\n seg_map = batch_seg_map[0]\n return resized_image, seg_map","def resize(img, size):\n img = cv2.resize(img, tuple(size[::-1]))\n return img","def initial_resizing(fr_raw_data_path, fr_data_path, dim=300):\n with h5py.File(fr_raw_data_path, 'r') as data:\n images = resize_array(np.asarray(data['images'].value), dim=dim)\n labels = data['labels'].value\n \n with h5py.File(fr_data_path, 'w') as f:\n f.create_dataset('images', data=images)\n\n with h5py.File(fr_raw_data_path, 'r') as data: \n f.copy(data['fri_data'], 'fri_data')\n f.copy(data['frii_data'], 'frii_data')\n f.copy(data['labels'], 'labels')","def resize(image):\n\treturn cv2.resize(image, \n\t\t\t\t\t (FACE_WIDTH, FACE_HEIGHT), \n\t\t\t\t\t interpolation=cv2.INTER_LANCZOS4)","def resize(img, size, method=\"bilinear\"):\n if method == Image.BILINEAR or method == \"bilinear\":\n method = cv2.INTER_AREA\n elif method == Image.CUBIC or method == \"cubic\":\n method = cv2.INTER_CUBIC\n elif method == Image.NEAREST or method == \"nearest\":\n method = cv2.INTER_NEAREST\n else:\n raise RuntimeError(\"wrong method {}\".format(method))\n if not isinstance(size, (tuple, list)):\n size = (size, size)\n if isinstance(size ,list):\n size = tuple(size)\n im = np.array(img)\n im = cv2.resize(im, size, interpolation=method)\n return Image.fromarray(im)","def change_resolution(img):\n scale_factor = np.random.choice(list(range(0, 6, 2)))\n if scale_factor == 0:\n return img\n downsample = nn.AvgPool2d(scale_factor)\n upsample = nn.UpsamplingNearest2d(scale_factor=scale_factor)\n new_res_img = upsample(downsample(img.unsqueeze(dim=1))).squeeze()\n return new_res_img","def run(self, image):\n width, height = image.size\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\n resized_image = image.convert('RGB').resize(\n target_size, Image.ANTIALIAS)\n batch_seg_map = self.sess.run(\n self.OUTPUT_TENSOR_NAME,\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\n seg_map = batch_seg_map[0]\n return resized_image, seg_map","def resize_image_batch(input_dir, output_dir, image_size):\n if not os.path.isdir(output_dir):\n os.mkdir(output_dir)\n input_paths = [os.path.join(input_dir, image_name) for image_name in os.listdir(input_dir)]\n output_paths = [os.path.join(output_dir, image_name) for image_name in os.listdir(input_dir)]\n image_sizes = [image_size]*len(input_paths)\n \n _ = Parallel(n_jobs=-1, verbose=3)(delayed(resize_one_image)(ipath, opath, img_size) for ipath, opath, img_size in zip(input_paths, output_paths, image_sizes))","def _images_and_boxes_preprocessing_cv2(self, imgs, boxes):\r\n\r\n height, width, _ = imgs[0].shape\r\n\r\n boxes[:, [0, 2]] *= width\r\n boxes[:, [1, 3]] *= height\r\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\r\n\r\n # `transform.py` is list of np.array. However, for AVA, we only have\r\n # one np.array.\r\n boxes = [boxes]\r\n # The image now is in HWC, BGR format.\r\n if self._split == \"train\": # \"train\"\r\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\r\n imgs,\r\n min_size=self._jitter_min_scale,\r\n max_size=self._jitter_max_scale,\r\n boxes=boxes,\r\n )\r\n imgs, boxes = cv2_transform.random_crop_list(\r\n imgs, self._crop_size, order=\"HWC\", boxes=boxes\r\n )\r\n if self.random_horizontal_flip:\r\n # random flip\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 0.5, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n elif self._split == \"val\":\r\n # Short side to test_scale. Non-local and STRG uses 256.\r\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\r\n boxes = [\r\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\r\n ]\r\n imgs, boxes = cv2_transform.spatial_shift_crop_list(\r\n self._crop_size, imgs, 1, boxes=boxes\r\n )\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 1, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n elif self._split == \"test\":\r\n # Short side to test_scale. Non-local and STRG uses 256.\r\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\r\n boxes = [\r\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\r\n ]\r\n\r\n if self._test_force_flip:\r\n imgs, boxes = cv2_transform.horizontal_flip_list(\r\n 1, imgs, order=\"HWC\", boxes=boxes\r\n )\r\n else:\r\n raise NotImplementedError(\"Unsupported split mode {}\".format(self._split))\r\n\r\n # Convert image to CHW keeping BGR order.\r\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\r\n\r\n # Image [0, 255] -> [0, 1].\r\n imgs = [img / 255.0 for img in imgs]\r\n\r\n imgs = [\r\n np.ascontiguousarray(\r\n # img.reshape((3, self._crop_size, self._crop_size))\r\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\r\n ).astype(np.float32)\r\n for img in imgs\r\n ]\r\n\r\n # Do color augmentation (after divided by 255.0).\r\n if self._split == \"train\" and self._use_color_augmentation:\r\n if not self._pca_jitter_only:\r\n imgs = cv2_transform.color_jitter_list(\r\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\r\n )\r\n\r\n imgs = cv2_transform.lighting_list(\r\n imgs,\r\n alphastd=0.1,\r\n eigval=np.array(self._pca_eigval).astype(np.float32),\r\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\r\n )\r\n\r\n # Normalize images by mean and std.\r\n imgs = [\r\n cv2_transform.color_normalization(\r\n img,\r\n np.array(self._data_mean, dtype=np.float32),\r\n np.array(self._data_std, dtype=np.float32),\r\n )\r\n for img in imgs\r\n ]\r\n\r\n # Concat list of images to single ndarray.\r\n imgs = np.concatenate([np.expand_dims(img, axis=1) for img in imgs], axis=1)\r\n\r\n if not self._use_bgr:\r\n # Convert image format from BGR to RGB.\r\n imgs = imgs[::-1, ...]\r\n\r\n imgs = np.ascontiguousarray(imgs)\r\n imgs = torch.from_numpy(imgs)\r\n boxes = cv2_transform.clip_boxes_to_image(\r\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\r\n )\r\n return imgs, boxes","def resize_image(parent_directory, img_columns,img_rows):\n\t#List of img files in the directory for the specific simulation file\n\tlisting = os.listdir(parent_directory)\n\t#Number of img files in the directory for the specific simulation file\n\tnum_samples = len(listing)\n\t#Create Directory to store the re-sized images\n\tdir_nam = parent_directory + '/resize_col_' + str(img_columns) + '_row_' + str(img_rows)\n\tif not os.path.exists(dir_nam):\n\t\tos.makedirs(dir_nam)\n\t#Open image and resize --> (img_rows,img_columns)\n\tfor file in listing:\n\t\tif file.endswith('.bmp'):\n\t\t\tim = PIL.Image.open(parent_directory + '/' + file)\n\t\t\tim_resized = im.resize((img_columns,img_rows))\n\t\t\tim_resized.save(dir_nam + '/' + file)\n\treturn;","def main(inputfile, output, size):\n if not output:\n output = join(dirname(inputfile), str(size))\n if not isdir(output):\n os.mkdir(output)\n\n logger.info('Resizing images from: %s' % inputfile)\n inputfile = realpath(inputfile)\n #/usr/share/datasets/KSCGR_Original/data1/boild-egg/0.jpg 0\n nb_lines = count_lines(inputfile)\n pbar = pb.ProgressBar(nb_lines)\n with open(inputfile) as fin:\n for line in fin:\n path, tl = line.strip().split()\n newpath = create_path(path, output)\n img = cv2.imread(path)\n img = resize_image(img, size)\n cv2.imwrite(newpath, img)\n pbar.update()\n logger.info('Total of images resized: %d' % nb_lines)","def _resize(img, max_dim=128):\n if max(img.shape[:3]) <= max_dim:\n return img\n else:\n new_size = [max_dim / s if s >= max_dim else 1.0 for s in img.shape[:3]]\n new_size.append(1.0) # for channel\n return scipy.ndimage.zoom(img, new_size, order=2)","def retinanet_resize_image(img, min_side=800, max_side=1333):\n # compute scale to resize the image\n scale = retinanet_compute_resize_scale(img.shape, min_side=min_side, max_side=max_side)\n # scale = round(scale, 4)\n # print(\"scale: \", scale)\n\n # resize the image with the computed scale\n img = cv2.resize(img, None, fx=scale, fy=scale)\n\n return img, scale","def resize_image(image, target_size):\n image = cv2.resize(image, target_size)\n return image","def demo2(image_paths, output_dir, cuda):\n\n device = get_device(cuda)\n\n # Synset words\n classes = get_classtable()\n\n # Model\n model = models.resnet152(pretrained=True)\n model.to(device)\n model.eval()\n\n # The four residual layers\n target_layers = [\"relu\", \"layer1\", \"layer2\", \"layer3\", \"layer4\"]\n target_class = 243 # \"bull mastif\"\n\n # Images\n images, raw_images = load_images(image_paths)\n images = torch.stack(images).to(device)\n\n gcam = GradCAM(model=model)\n probs, ids = gcam.forward(images)\n # ids_ = torch.LongTensor([[target_class]] * len(images)).to(device)\n ids_ = torch.tensor([[target_class]] * len(images), dtype=torch.long).to(device)\n gcam.backward(ids=ids_)\n\n for target_layer in target_layers:\n print(\"Generating Grad-CAM @{}\".format(target_layer))\n\n # Grad-CAM\n regions = gcam.generate(target_layer=target_layer)\n\n for j in range(len(images)):\n print(\n \"\\t#{}: {} ({:.5f})\".format(\n j, classes[target_class], float(probs[ids == target_class])\n )\n )\n\n # save_gradcam(\n # filename=osp.join(\n # output_dir,\n # \"{}-{}-gradcam-{}-{}.png\".format(\n # j, \"resnet152\", target_layer, classes[target_class]\n # ),\n # ),\n # gcam=regions[j, 0],\n # raw_image=raw_images[j],\n # )","def preprocess_train(im, boxes, classes, inst_masks, mask, input_size, min_size=2,\n use_augment=False, training_scale=[0.3, 0.5, 0.7, 1.0]):\n ori_im = np.copy(im)\n target_h, target_w = input_size\n\n # ---------- old data_augmentation ----------\n if use_augment:\n if np.random.choice([0, 1]) != 0:\n scale = np.random.choice(training_scale) # adding more small objects\n im, inst_masks, mask, boxes, classes = random_scale(im, inst_masks, mask, boxes, classes, scale=scale)\n min_obj_cover = np.random.choice([0.8, 0.9, 1.0])\n # truncted examples may lead to multiple-detections..\n im, inst_masks, mask, boxes, classes = random_aspect_ratio(im, inst_masks, mask, boxes, classes,\n min_aspect_ratio=0.5, max_aspect_ratio=2.0,\n min_obj_cover=min_obj_cover)\n #\n # # r = np.random.randint(0, 3)\n # if np.random.rand() < 0.75:\n # im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\n # else:\n # im, inst_masks, mask, boxes, classes = center_crop2fixed_pad(im, inst_masks, mask, boxes, classes, target_w, target_h,\n # min_size=min_size)\n\n # ---------- old data_augmentation ----------\n\n # ---------- none data_augmentation ----------\n im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\n im, inst_masks, mask, boxes, classes = random_flip(im, inst_masks, mask, boxes, classes)\n # ---------- none data_augmentation ----------\n\n # ---------- old data_augmentation ----------\n im = distort_color(im)\n # ---------- old data_augmentation ----------\n\n im = imcv2_recolor(im)\n\n # add this because zeros numpy array will cause errors in torch Dataloader\n inst_masks = np.zeros([1, target_h, target_w], dtype=inst_masks.dtype) if inst_masks.size == 0 else inst_masks\n\n boxes = np.asarray(boxes, dtype=np.float32)\n return im, boxes, classes, inst_masks, mask, ori_im","def ResNet(images, device):\n blocksPerSection = [2, 2, 2, 2]\n channelsPerSection = [64, 128, 256, 512]\n channelsPerBlock = [1, 1]\n downsampleSection = [0, 1, 1, 1]\n\n\n x = images\n channelsOut = 64\n\n with tf.device(device):\n\n x = ConvBlock(x, 64, [7,7], 2, '_init')\n x = slim.max_pool2d(x, [3, 3], stride=2, scope='pool_1')\n\n for s in range(len(blocksPerSection)):\n for l in range(blocksPerSection[s]):\n\n # Stride at the beginning of each block\n stride = 1\n if l == 0 and downsampleSection[s]:\n stride = 2\n\n sumInput = x\n\n # 2 conv only\n x = ConvBlock(x, channelsPerSection[s]*channelsPerBlock[1], [3, 3], stride, '%d_1_%d'%(s,l))\n x = ConvBlock(x, channelsPerSection[s]*channelsPerBlock[1], [3, 3], 1, '%d_2_%d'%(s,l), False)\n\n if l == 0 and channelsOut != channelsPerSection[s]*channelsPerBlock[1]:\n sumInput = ConvBlock(sumInput, channelsPerSection[s]*channelsPerBlock[1], [1,1], stride, '_sum%d'%(s), False)\n\n channelsOut = channelsPerSection[s]*channelsPerBlock[1]\n x = sumInput + x\n x = tf.nn.relu(x)\n\n with slim.arg_scope([slim.fully_connected],\n activation_fn=None,\n weights_regularizer=slim.l2_regularizer(0.0005),\n biases_regularizer=slim.l2_regularizer(0.0005),\n trainable=True):\n x = tf.reduce_mean(x, [1,2])\n softmax_linear = slim.fully_connected(x, NUM_CLASSES, scope='fc_1')\n\n return softmax_linear","def FlyResize( image, log_mess, nimages, method = Image.ANTIALIAS ):\n oldw, oldh = image.size\n resl = [8, 10, 14, 16, 20, 22, 24, 32, 40, 48, 64, 96, 128, 256]\n \n if oldw > 256 or oldh > 256:\n newsiz = min(resl, key = lambda x:abs(x - max(oldw, oldh)))\n image.thumbnail((newsiz, newsiz), method)\n neww, newh = image.size\n log_mess += ' and new size scaled = %s x %s' %(neww, newh)\n elif nimages > 1:\n log_mess += ' and size = %s x %s' %(oldw, oldh)\n \n return oldw, oldh, image, log_mess","def build_resnet152(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\n conv1_feats = nonlinear(conv1_feats, 'relu')\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\n\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\n \n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \n temp = res3a_feats\n for i in range(1, 8):\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\n res3b7_feats = temp\n \n res4a_feats = self.basic_block(res3b7_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\n temp = res4a_feats\n for i in range(1, 36):\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\n res4b35_feats = temp\n\n res5a_feats = self.basic_block(res4b35_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\n\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\n self.conv_feats = res5c_feats_flat\n self.conv_feat_shape = [49, 2048]\n self.num_ctx = 49 \n self.dim_ctx = 2048\n\n self.imgs = imgs\n self.is_train = is_train","def fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w):\n h, w, c = im.shape\n scale = float(target_h) / h\n im = cv2.resize(im, (target_w, target_h))\n mask = cv2.resize(mask, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\n if inst_masks.size > 0:\n inst_masks = np.transpose(inst_masks, (1, 2, 0)) # to (h, w, n)\n inst_masks = cv2.resize(inst_masks, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\n try:\n if inst_masks.ndim > 2:\n inst_masks = np.transpose(inst_masks, (2, 0, 1)) # to (n, h, w)\n else:\n inst_masks = inst_masks.reshape((1, target_h, target_w))\n except ValueError:\n print (inst_masks.ndim, inst_masks.shape)\n raise\n else:\n inst_masks = np.zeros((0, h, w), inst_masks.dtype)\n boxes[:, 0:4:2] = boxes[:, 0:4:2] * float(target_w) / w\n boxes[:, 1:4:2] = boxes[:, 1:4:2] * float(target_h) / h\n\n return im, inst_masks, mask, boxes, classes","def image_network_train(learn_data_path):\n\n # data selector ----------\n use_da_data = False\n increase_val = False\n print( \"\\nmode: Use Augmented data: {} | increase validation data: {}\".format(use_da_data, increase_val) )\n\n # First define original train_data only as train_dir\n train_dir = os.path.join(data_dir, \"train\")\n if (use_da_data == True) and (increase_val == False):\n # with_augmented data (no validation increase)\n train_dir = os.path.join(data_dir, \"train_with_aug\")\n validation_dir = os.path.join(data_dir, \"val\") # original validation data\n\n # pair of decreaced train_data and increased validation data\n if (increase_val == True):\n train_dir = os.path.join(data_dir, \"red_train\")\n if (use_da_data == True):\n train_dir = os.path.join(data_dir, \"red_train_with_aug\")\n validation_dir = os.path.join(data_dir, \"validation\")\n\n test_dir = os.path.join(data_dir, \"test\")\n\n print(\"\\ntrain_dir: \", train_dir)\n print(\"validation_dir: \", validation_dir)\n\n\n # calcucate the num of category\n num_category = 0\n for dirpath, dirnames, filenames in os.walk(train_dir):\n for dirname in dirnames:\n num_category += 1\n\n # All images will be resized to 299x299\n image_size = 299\n batch_size = 16\n\n # Rescale all images by 1./255 and apply image augmentation\n train_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\n validation_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\n test_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\n\n # Flow training images in batches of using train_datagen generator\n train_generator = train_datagen.flow_from_directory(\n train_dir, # Source directory for the training images\n target_size=(image_size, image_size),\n batch_size=batch_size,\n class_mode='categorical')\n\n # Flow validation images in batches of 20 using validation_datagen generator\n validation_generator = validation_datagen.flow_from_directory(\n validation_dir, # Source directory for the validation images\n target_size=(image_size, image_size),\n batch_size=batch_size,\n class_mode='categorical')\n\n # Flow validation images in batches of 20 using test_datagen generator\n test_generator = test_datagen.flow_from_directory(\n test_dir, # Source directory for the test images\n target_size=(image_size, image_size),\n batch_size=batch_size,\n class_mode='categorical')\n\n # Create the base model from the pre-trained convnets\n IMG_SHAPE = (image_size, image_size, 3)\n\n # Create the base model from the pre-trained model MobileNet V2\n base_model = keras.applications.xception.Xception(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')\n\n # Freeze the convolutional base\n base_model.trainable = False\n\n # モデル\n model = keras.Sequential([\n base_model,\n keras.layers.GlobalAveragePooling2D(),\n keras.layers.Dense(num_category, activation='softmax')\n ])\n\n # Compile the model\n model.compile(optimizer=keras.optimizers.Adam(lr=0.0001),\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n\n # early stopping\n es = keras.callbacks.EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)\n\n model.summary()\n\n # 更新される重みの数\n print('after', len(model.trainable_weights))\n\n # Train the model\n epochs = 30\n steps_per_epoch = train_generator.n // batch_size\n validation_steps = validation_generator.n // batch_size\n test_steps = test_generator.n // batch_size\n\n history = model.fit_generator(train_generator,\n steps_per_epoch = steps_per_epoch,\n epochs=epochs,\n workers=4,\n validation_data=validation_generator,\n validation_steps=validation_steps,\n callbacks=[es],\n class_weight={0:1.0, 1:0.4})\n\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\n print('val loss: {}, val acc: {}'.format(loss, acc))\n\n # Fine tuning\n # Un-freeze the top layers of the model\n base_model.trainable = True\n\n # The nums of layers are in the base model\n print(\"Number of layers in the base model: \", len(base_model.layers))\n\n # Fine tune from this layer onwards\n fine_tune_at = 108\n\n # Freeze all the layers before the `fine_tune_at` layer\n for layer in base_model.layers[:fine_tune_at]:\n layer.trainable = False\n\n # Compile the model using a much-lower training rate\n model.compile(optimizer = keras.optimizers.Adam(lr=2e-5),\n loss='categorical_crossentropy',\n metrics=['accuracy'])\n\n model.summary()\n\n # 更新される重みの数\n print('after Fine tune', len(model.trainable_weights))\n\n # Continue Train the model\n history_fine = model.fit_generator(train_generator,\n steps_per_epoch = steps_per_epoch,\n epochs=epochs,\n workers=4,\n validation_data=validation_generator,\n validation_steps=validation_steps,\n callbacks=[es],\n class_weight={0:1.0, 1:0.4})\n\n\n # print(history_fine.history)\n model_val_acc = history_fine.history['val_accuracy'][-1]\n print('val_acc: ', model_val_acc)\n\n # save model into hdf5 file ----------\n model.save(learn_data_path + '/shen_model.h5')\n\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\n print('val loss: {}, val acc: {}'.format(loss, acc))\n\n loss, acc = model.evaluate_generator(test_generator, steps=test_steps)\n print('Test loss: {}, Test acc: {}'.format(loss, acc))","def optimize_images(conv_id=None, num_iterations=30):\n\n if conv_id is None:\n print(\"Final fully-connected layer before softmax.\")\n else:\n print(\"Layer:\", conv_names[conv_id])\n\n images = []\n for feature in range(0, 10):\n print(\"Optimizing image for feature no.\", feature)\n\n image = optimize_image(conv_id=conv_id, feature=feature, show_progress=False, num_iterations=num_iterations)\n\n image = image.squeeze()\n images.append(image)\n\n images = np.array(images)\n\n plot_images10(images=images)","def process_image(image):\n image = resize(image)\n return image","def img_preprocess(self, img, output_size=64):\n w, h = img.size\n if w > h:\n box_param = (int(w * 0.5 - h * 0.5), 0, int(w * 0.5 + h * 0.5), h)\n cropped = img.crop(box_param)\n else: # w < h\n box_param = (0, int(h * 0.5 - w * 0.5), w, int(h * 0.5 + w * 0.5))\n cropped = img.crop(box_param)\n\n resized = cropped.resize((output_size, output_size))\n resized = np.asarray(resized)\n\n return resized","def SqueezeNet(input_shape=(224, 224, 3)):\n image_input = Input(shape=input_shape)\n\n network = Conv2D(64, (3, 3), strides=(2, 2), padding=\"valid\")(image_input)\n network = Activation(\"relu\")(network)\n network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network)\n\n network = squeezenet_fire_module(\n input=network, input_channel_small=16, input_channel_large=64\n )\n network = squeezenet_fire_module(\n input=network, input_channel_small=16, input_channel_large=64\n )\n network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network)\n\n network = squeezenet_fire_module(\n input=network, input_channel_small=32, input_channel_large=128\n )\n network = squeezenet_fire_module(\n input=network, input_channel_small=32, input_channel_large=128\n )\n network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network)\n\n network = squeezenet_fire_module(\n input=network, input_channel_small=48, input_channel_large=192\n )\n network = squeezenet_fire_module(\n input=network, input_channel_small=48, input_channel_large=192\n )\n network = squeezenet_fire_module(\n input=network, input_channel_small=64, input_channel_large=256\n )\n network = squeezenet_fire_module(\n input=network, input_channel_small=64, input_channel_large=256\n )\n\n # Remove layers like Dropout and BatchNormalization, they are only needed in training\n # network = Dropout(0.5)(network)\n\n network = Conv2D(1000, kernel_size=(1, 1), padding=\"valid\", name=\"last_conv\")(\n network\n )\n network = Activation(\"relu\")(network)\n\n network = GlobalAvgPool2D()(network)\n network = Activation(\"softmax\", name=\"output\")(network)\n\n input_image = image_input\n model = Model(inputs=input_image, outputs=network)\n\n return model","def resize_image(image: Image) -> Image:\n expected_x: int = 1024\n expected_y: int = 768\n x, y = image.size\n if x > expected_x or y > expected_y:\n scale = min(expected_x / x, expected_y / y)\n return image.resize((int(x * scale), int(y * scale)))\n else:\n return image.resize((int(0.9*x), int(0.9*y)))","def build_resnet50(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\n conv1_feats = nonlinear(conv1_feats, 'relu')\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\n\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\n \n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128)\n res3b_feats = self.basic_block2(res3a_feats, 'res3b', 'bn3b', is_train, use_batch_norm, 128)\n res3c_feats = self.basic_block2(res3b_feats, 'res3c', 'bn3c', is_train, use_batch_norm, 128)\n res3d_feats = self.basic_block2(res3c_feats, 'res3d', 'bn3d', is_train, use_batch_norm, 128)\n\n res4a_feats = self.basic_block(res3d_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\n res4b_feats = self.basic_block2(res4a_feats, 'res4b', 'bn4b', is_train, use_batch_norm, 256)\n res4c_feats = self.basic_block2(res4b_feats, 'res4c', 'bn4c', is_train, use_batch_norm, 256)\n res4d_feats = self.basic_block2(res4c_feats, 'res4d', 'bn4d', is_train, use_batch_norm, 256)\n res4e_feats = self.basic_block2(res4d_feats, 'res4e', 'bn4e', is_train, use_batch_norm, 256)\n res4f_feats = self.basic_block2(res4e_feats, 'res4f', 'bn4f', is_train, use_batch_norm, 256)\n\n res5a_feats = self.basic_block(res4f_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\n\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\n self.conv_feats = res5c_feats_flat\n self.conv_feat_shape = [49, 2048]\n self.num_ctx = 49 \n self.dim_ctx = 2048\n\n self.imgs = imgs\n self.is_train = is_train","def capture():\n stream = BytesIO()\n cam.capture(stream, 'jpeg')\n data = np.fromstring(stream.getvalue(), dtype=np.uint8)\n # \"Decode\" the image preserving color\n img = cv2.imdecode(data, 1)\n # switch BGR order to RGB order\n img = img[:, :, ::-1]\n\n # resize image to match training size\n img = cv2.resize(img, (args.resize, args.resize), interpolation=cv2.INTER_AREA)\n print(\"done resizing\")\n\n# cv2.imshow('image',img)\n# cv2.waitKey(0)\n# cv2.destroyAllWindows()\n return img.flatten()","def frame_size_standardize(self, frame):\r\n h,w,_ = frame.shape\r\n standard_size = self.cfg.PRETRAIN.STANDARD_SIZE\r\n if isinstance(standard_size, list):\r\n assert len(standard_size) == 3\r\n size_s, size_l, crop_size = standard_size\r\n reshape_size = random.randint(int(size_s), int(size_l))\r\n else:\r\n crop_size = standard_size\r\n reshape_size = standard_size\r\n\r\n # resize the short side to standard size\r\n dtype = frame.dtype\r\n frame = frame.permute(2, 0, 1).to(torch.float) # C, H, W\r\n aspect_ratio = random.uniform(self.aspect_ratio[0], self.aspect_ratio[1])\r\n if h <= w:\r\n new_h = reshape_size\r\n new_w = int(new_h / h * w)\r\n # resize\r\n frame = F.resize(frame.unsqueeze(0), (new_h, new_w), \"bilinear\").squeeze(0) \r\n elif h > w:\r\n new_w = reshape_size\r\n new_h = int(new_w / w * h)\r\n # resize\r\n frame = F.resize(frame.unsqueeze(0), (new_h, new_w), \"bilinear\").squeeze(0) \r\n \r\n # crop\r\n if aspect_ratio >= 1: \r\n crop_h = int(crop_size / aspect_ratio)\r\n crop_w = crop_size\r\n else:\r\n crop_h = crop_size\r\n crop_w = int(crop_size * aspect_ratio)\r\n start_h = random.randint(0, new_h - crop_h)\r\n start_w = random.randint(0, new_w - crop_w)\r\n return frame[:, start_h:start_h+crop_h, start_w:start_w+crop_w].to(dtype).permute(1, 2, 0) # H, W, C\r","def run(basedir, resize_height=288):\n print(\"initialize\")\n\n img0 = [os.path.join(basedir, 'images', f) \\\n for f in sorted(os.listdir(os.path.join(basedir, 'images'))) \\\n if f.endswith('JPG') or f.endswith('jpg') or f.endswith('png')][0]\n sh = cv2.imread(img0).shape\n height = resize_height\n factor = sh[0] / float(height)\n width = int(round(sh[1] / factor))\n _minify(basedir, resolutions=[[height, width]])\n\n print(\"finished\")","def autoencode(self, imgs):\n x = tf.layers.conv2d(imgs, filters=32, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\n shape2 = x.shape\n x = tf.layers.max_pooling2d(x, pool_size=2, strides=2)\n x = tf.layers.conv2d(x, filters=64, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\n shape1 = x.shape\n x = tf.layers.max_pooling2d(x, pool_size=2, strides=2)\n # shape0 = x.shape\n # x = tf.layers.conv2d(x, filters=128, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\n # x = tf.layers.max_pooling2d(x, pool_size=2, strides=2)\n# shape_orig = x.shape\n# x = tf.layers.flatten(x)\n# shape_dense = x.shape\n# x = tf.layers.dense(x, units=512, activation=tf.nn.relu)\n# x = tf.layers.dense(x, units=shape_dense[-1], activation=tf.nn.relu)\n# x = tf.reshape(x, [-1, shape_orig[1], shape_orig[2], shape_orig[3]])\n # x = tf.layers.conv2d(x, filters=128, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\n # x = tf.image.resize(x, size=(shape0[1], shape0[2]), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n x = tf.layers.conv2d(x, filters=64, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\n x = tf.image.resize(x, size=(shape1[1], shape1[2]), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n x = tf.layers.conv2d(x, filters=32, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\n x = tf.image.resize(x, size=(shape2[1], shape2[2]), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\n x = tf.layers.conv2d(x, filters=3, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\n \n return x","def transform_images(image, size):\n\n # convert image to tensor\n image = tf.convert_to_tensor(image)\n \n # add batch dimension to image\n image = tf.expand_dims(image, axis = 0)\n \n # resize image to specified size\n image = tf.image.resize_with_pad(image, size, size)\n \n # standardize image\n image = image / 255\n \n # remove batch dimension\n image = tf.squeeze(image, axis = 0)\n \n return image.numpy()","def resize(image):\r\n return cv2.resize(image, (200, 66), interpolation=cv2.INTER_AREA)","def resize(self):\n pass","def resize(img):\n size = (500, 500)\n img.thumbnail(size)\n return img","def scale_image(img, factor=1):\n return cv2.resize(img, (int(img.shape[1] * factor), int(img.shape[0] * factor)))","def test_resize3d():\n\n # Check resize3d for images with different size and without channel nor batch - Pass\n input_shape = (1, 3, 5)\n output_shape = (2, 4, 6)\n size = (2, 4, 6)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for images with different size and without channel - Pass\n input_shape = (1, 1, 3, 5)\n output_shape = (1, 2, 4, 6)\n size = (2, 4, 6)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for images with different size and with one channel - Pass\n input_shape = (1, 1, 3, 5, 1)\n output_shape = (1, 2, 4, 6, 1)\n size = (2, 4, 6)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for images with different size and with multiple channels - Pass\n input_shape = (1, 1, 3, 5, 3)\n output_shape = (1, 2, 4, 6, 3)\n size = (2, 4, 6)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for images with the same size and without channel nor batch - Pass\n input_shape = (1, 3, 5)\n output_shape = (1, 3, 5)\n size = (1, 3, 5)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for images with the same size and without channel - Pass\n input_shape = (1, 1, 3, 5)\n output_shape = (1, 1, 3, 5)\n size = (1, 3, 5)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for images with the same size and with one channel - Pass\n input_shape = (1, 1, 3, 5, 1)\n output_shape = (1, 1, 3, 5, 1)\n size = (1, 3, 5)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for images with the same size and with multiple channels - Pass\n input_shape = (1, 1, 3, 5, 3)\n output_shape = (1, 1, 3, 5, 3)\n size = (1, 3, 5)\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\n assert got.shape == output_shape\n\n # Check resize3d for proper image dimensions - Fail\n input_shape = (1, 1)\n size = (1, 1, 1)\n with pytest.raises(ValueError) as execinfo:\n layer_util.resize3d(image=tf.ones(input_shape), size=size)\n msg = \" \".join(execinfo.value.args[0].split())\n assert \"resize3d takes input image of dimension 3 or 4 or 5\" in msg\n\n # Check resize3d for proper size - Fail\n input_shape = (1, 1, 1)\n size = (1, 1)\n with pytest.raises(ValueError) as execinfo:\n layer_util.resize3d(image=tf.ones(input_shape), size=size)\n msg = \" \".join(execinfo.value.args[0].split())\n assert \"resize3d takes size of type tuple/list and of length 3\" in msg","def resizeAndRepubThread():\n\n # reference globals\n global primaryCamString\n global secondaryCamString\n global armCamImage\n global headCamImage\n\n # initialize image publishers\n primaryPub = rospy.Publisher(primaryCamRepub, Image, queue_size=1)\n secondaryPub = rospy.Publisher(secondaryCamRepub, Image, queue_size=1)\n\n # create CvBridge object for converting CV2 images to sensor_msgs/Image messages\n backBridge = CvBridge()\n\n while(True):\n primaryImage = np.zeros(shape=[512, 512, 3])\n secondaryImage = np.zeros(shape=[512, 512, 3])\n\n # just keep looping until we get images\n\n if(np.sum(headCamImage) == 0 or np.sum(armCamImage) == 0):\n rospy.loginfo(\"still waiting on camera images...\")\n continue\n\n # get primary image\n if(primaryCamString == \"head\"):\n primaryImage = resizeImage(headCamImage, primarySize)\n elif(primaryCamString == \"leftArm\"):\n primaryImage = resizeImage(armCamImage, primarySize)\n elif(primaryCamString == \"\"):\n pass\n else:\n rospy.logerr(\"Invalid Option for primaryCamString recieved!\")\n\n # get secondary image\n if(secondaryCamString == \"head\"):\n secondaryImage = resizeImage(headCamImage, secondarySize)\n elif(secondaryCamString == \"leftArm\"):\n secondaryImage = resizeImage(armCamImage, secondarySize)\n elif(secondaryCamString == \"\"):\n pass\n else:\n rospy.logerr(\"Invalid Option for secondaryCamString recieved!\")\n\n # publish both new images\n if(np.sum(primaryImage) != 0 and np.sum(secondaryImage) != 0):\n primaryImageMessage = backBridge.cv2_to_imgmsg(primaryImage, \"bgr8\")\n primaryPub.publish(primaryImageMessage)\n\n secondaryImageMessage = backBridge.cv2_to_imgmsg(secondaryImage, \"bgr8\")\n secondaryPub.publish(secondaryImageMessage)","def scale_image(img, factor=1):\n\treturn cv2.resize(img,(int(img.shape[1]*factor), int(img.shape[0]*factor)))","def resize(self, new_size):\n resized_img = opencv.resize(self.img, new_size)\n return Image(resized_img)","def resnet(num_blocks, classes=10, training=None):\n\n input_shape = (32, 32, 3)\n img_input = layers.Input(shape=input_shape)\n\n if backend.image_data_format() == 'channels_first':\n x = layers.Lambda(lambda x: backend.permute_dimensions(x, (0, 3, 1, 2)),\n name='transpose')(img_input)\n bn_axis = 1\n else: # channel_last\n x = img_input\n bn_axis = 3\n\n x = tf.keras.layers.ZeroPadding2D(padding=(1, 1), name='conv1_pad')(x)\n x = tf.keras.layers.Conv2D(16, (3, 3),\n strides=(1, 1),\n padding='valid',\n kernel_initializer='he_normal',\n kernel_regularizer=\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\n bias_regularizer=\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\n name='conv1')(x)\n x = tf.keras.layers.BatchNormalization(axis=bn_axis, name='bn_conv1',\n momentum=BATCH_NORM_DECAY,\n epsilon=BATCH_NORM_EPSILON)(\n x, training=training)\n x = tf.keras.layers.Activation('relu')(x)\n\n x = resnet_block(x, size=num_blocks, kernel_size=3, filters=[16, 16],\n stage=2, conv_strides=(1, 1), training=training)\n\n x = resnet_block(x, size=num_blocks, kernel_size=3, filters=[32, 32],\n stage=3, conv_strides=(2, 2), training=training)\n\n x = resnet_block(x, size=num_blocks, kernel_size=3, filters=[64, 64],\n stage=4, conv_strides=(2, 2), training=training)\n\n x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)\n x = tf.keras.layers.Dense(classes, activation='softmax',\n kernel_initializer='he_normal',\n kernel_regularizer=\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\n bias_regularizer=\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\n name='fc10')(x)\n\n inputs = img_input\n # Create model.\n model = tf.keras.models.Model(inputs, x, name='resnet56')\n\n return model","def set_scale_factors_to_output_size(self):\n # Compute the scale_factor using rounded scaled image size.\n height = tf.shape(self._image)[0]\n width = tf.shape(self._image)[1]\n max_image_size = tf.to_float(tf.maximum(height, width))\n image_scale = tf.to_float(self._output_size) / max_image_size\n scaled_height = tf.to_int32(tf.to_float(height) * image_scale)\n scaled_width = tf.to_int32(tf.to_float(width) * image_scale)\n self._image_scale = image_scale\n self._scaled_height = scaled_height\n self._scaled_width = scaled_width","def resize_image(image, bboxes=None, min_size=None, max_size=None):\n image_shape = tf.to_float(tf.shape(image))\n height = image_shape[0]\n width = image_shape[1]\n\n if min_size is not None:\n # We calculate the upscale factor, the rate we need to use to end up\n # with an image with it's lowest dimension at least `image_min_size`.\n # In case of being big enough the scale factor is 1. (no change)\n min_size = tf.to_float(min_size)\n min_dimension = tf.minimum(height, width)\n upscale_factor = tf.maximum(min_size / min_dimension, 1.)\n else:\n upscale_factor = tf.constant(1.)\n\n if max_size is not None:\n # We do the same calculating the downscale factor, to end up with an\n # image where the biggest dimension is less than `image_max_size`.\n # When the image is small enough the scale factor is 1. (no change)\n max_size = tf.to_float(max_size)\n max_dimension = tf.maximum(height, width)\n downscale_factor = tf.minimum(max_size / max_dimension, 1.)\n else:\n downscale_factor = tf.constant(1.)\n\n scale_factor = upscale_factor * downscale_factor\n\n # New size is calculate using the scale factor and rounding to int.\n new_height = height * scale_factor\n new_width = width * scale_factor\n\n # Resize image using TensorFlow's own `resize_image` utility.\n image = tf.image.resize_images(\n image, tf.stack(tf.to_int32([new_height, new_width])),\n method=tf.image.ResizeMethod.BILINEAR\n )\n\n if bboxes is not None:\n bboxes = adjust_bboxes(\n bboxes,\n old_height=height, old_width=width,\n new_height=new_height, new_width=new_width\n )\n return {\n 'image': image,\n 'bboxes': bboxes,\n 'scale_factor': scale_factor,\n }\n\n return {\n 'image': image,\n 'scale_factor': scale_factor,\n }"],"string":"[\n \"def resize_real_images(self, images):\\n block_idx = (self.growth_idx + 1) // 2\\n height, width = self.params[\\\"generator_projection_dims\\\"][0:2]\\n resized_image = tf.image.resize(\\n images=images,\\n size=[\\n height * (2 ** block_idx), width * (2 ** block_idx)\\n ],\\n method=\\\"nearest\\\",\\n name=\\\"resized_real_image_{}\\\".format(self.growth_idx)\\n )\\n\\n return resized_image\",\n \"def image_resize(img, min_size=600, max_size=1000):\\n C, H, W = img.shape\\n scale1 = min_size / min(H, W)\\n scale2 = max_size / max(H, W)\\n scale = min(scale1, scale2)\\n img = img / 255\\n img = transform.resize(img, (C, H * scale, W * scale),\\n mode='reflect', anti_aliasing=False)\\n # img = pytorch_normalize(img)\\n # img = caffe_normalize(img)\\n return img\",\n \"def resize_images(images, size):\\n num_images = images.shape[0]\\n num_channels = images.shape[3]\\n output_images = numpy.empty((num_images, size[0], size[1], num_channels), dtype=images.dtype)\\n with tqdm.tqdm(total=num_images) as progress:\\n for i in range(num_images):\\n output_images[i, :, :, :] = resize_image(images[i, :, :, :], size)\\n progress.update(1)\\n\\n return output_images\",\n \"def resize_frames(self, frames):\\n tf.image.resize_images(X, (IMAGE_SIZE, IMAGE_SIZE), \\n tf.image.ResizeMethod.NEAREST_NEIGHBOR)\",\n \"def resize_images(imgs, size=(720, 720)):\\n res = []\\n for img in imgs:\\n\\n factor = max(1, size[0]/float(img.shape[0]), size[1]/float(img.shape[1]))\\n if factor != 1: img = scale_image(img, factor)\\n\\n img = center_crop(img, size)\\n res.append(img)\\n\\n return res\",\n \"def run(self, image):\\n # width, height = image.size\\n # resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\n # target_size = (int(resize_ratio * width), int(resize_ratio * height))\\n target_size = (self.INPUT_SIZE, self.INPUT_SIZE)\\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\\n net_image = resized_image\\n if params.HZ_preprocess_activate:\\n net_image = params.image_preprocess_func(resized_image)\\n net_image = np.expand_dims(net_image, axis=-1)\\n batch_seg_map = self.sess.run(\\n self.OUTPUT_TENSOR_NAME,\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(net_image)]})\\n seg_map = batch_seg_map[0]\\n return resized_image, seg_map\",\n \"def transform_images(img, size):\\n return tf.image.resize(img, (size, size)) / 255\",\n \"def resizeContours(self):\\n scale = 500/self.images.shape[1]\\n print('Scaling images by {} for display'.format(scale))\\n self.lumenCopy = (self.lumen[0][:], self.lumen[1][:])\\n self.plaqueCopy = (self.plaque[0][:], self.plaque[1][:])\\n self.stentCopy = (self.stent[0][:], self.stent[1][:])\\n self.lumen = self.resize(self.lumen, scale)\\n self.plaque = self.resize(self.plaque, scale)\\n self.stent = self.resize(self.stent, scale)\",\n \"def resize_function(input):\\n\\n from keras.backend import tf as ktf\\n return ktf.image.resize_images(input, (64, 64))\",\n \"def resize(input, size):\\n layer = tf.image.resize_images(input, size, method=tf.image.ResizeMethod.BICUBIC, align_corners=True,\\n preserve_aspect_ratio=True)\\n return layer\",\n \"def set_size(self, size=None):\\n if not size:\\n size = self.output_size\\n self.img = cv2.resize(self.img, size)\\n self.update_image()\\n self.update_size()\",\n \"def crop_and_resize(input):\\r\\n\\r\\n # Locate the last Relu node of the first backbone (pre 1st NMS). Relu node contains feature maps\\r\\n # necessary for CropAndResize plugin.\\r\\n relu_name = \\\"StatefulPartitionedCall/model/\\\"\\r\\n relu_node = [node for node in self.graph.nodes if node.op == \\\"Relu\\\" and relu_name in node.name][-1]\\r\\n\\r\\n # Before passing 1st NMS's detection boxes (rois) to CropAndResize, we need to clip and normalize them.\\r\\n # Clipping happens for coordinates that are less than 0 and more than self.height.\\r\\n # Normalization is just divison of every coordinate by self.height.\\r\\n clip_min = np.asarray([0], dtype=np.float32)\\r\\n clip_max = np.asarray([self.height], dtype=np.float32)\\r\\n clip_out = self.graph.elt_const_clip(\\\"Clip\\\", \\\"FirstNMS/detection_boxes_clipper\\\", input, clip_min, clip_max)\\r\\n div_const = np.expand_dims(np.asarray([self.height, self.height, self.height, self.height], dtype=np.float32), axis=(0, 1))\\r\\n div_out = self.graph.elt_const(\\\"Div\\\", \\\"FirstNMS/detection_boxes_normalizer\\\", clip_out[0], div_const)\\r\\n\\r\\n # Linear transformation to convert box coordinates from (TopLeft, BottomRight) Corner encoding\\r\\n # to CenterSize encoding.\\r\\n matmul_const = np.matrix('0.5 0 -1 0; 0 0.5 0 -1; 0.5 0 1 0; 0 0.5 0 1', dtype=np.float32)\\r\\n matmul_out = self.graph.elt_const(\\\"MatMul\\\", \\\"FirstNMS/detection_boxes_conversion\\\", div_out[0], matmul_const)\\r\\n\\r\\n # Additionally CropAndResizePlugin requires 4th dimension of 1: [N, B, 4, 1], so\\r\\n # we need to add unsqeeze node to make tensor 4 dimensional. \\r\\n unsqueeze_node = self.graph.unsqueeze( \\\"FirstNMS/detection_boxes_unsqueeze\\\", div_out)\\r\\n\\r\\n # CropAndResizePlugin's inputs \\r\\n feature_maps = relu_node.outputs[0]\\r\\n rois = unsqueeze_node[0]\\r\\n\\r\\n # CropAndResize TensorRT Plugin.\\r\\n # Two inputs are given to the CropAndResize TensorRT node:\\r\\n # - The feature_maps (from the Relu node found above): [batch_size, channel_num, height, width]\\r\\n # - The rois (in other words clipped and normalized detection boxes resulting fromm 1st NMS): [batch_size, featuremap, 4, 1]\\r\\n cnr_inputs = [feature_maps, rois]\\r\\n cnr_op = \\\"CropAndResize\\\"\\r\\n cnr_attrs = {\\r\\n 'crop_width': self.initial_crop_size,\\r\\n 'crop_height': self.initial_crop_size,\\r\\n }\\r\\n\\r\\n # CropAndResize Outputs.\\r\\n cnr_pfmap = gs.Variable(name=\\\"pfmap\\\", dtype=np.float32,\\r\\n shape=[self.batch_size, self.first_stage_max_proposals, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size])\\r\\n cnr_outputs = [cnr_pfmap]\\r\\n\\r\\n # Create the CropandResize Plugin node with the selected inputs. \\r\\n self.graph.plugin(\\r\\n op=cnr_op,\\r\\n name=\\\"cnr/crop_and_resize\\\",\\r\\n inputs=cnr_inputs,\\r\\n outputs=cnr_outputs,\\r\\n attrs=cnr_attrs)\\r\\n log.info(\\\"Created CropAndResize plugin '{}' with attributes: {}\\\".format(cnr_op, cnr_attrs))\\r\\n\\r\\n # Reshape node that is preparing CropAndResize's pfmap output shape for MaxPool node that comes next,\\r\\n # after that is 2nd backbone that leads us to final 2nd NMS.\\r\\n reshape_shape = np.asarray([self.first_stage_max_proposals*self.batch_size, feature_maps.shape[1], self.initial_crop_size, self.initial_crop_size], dtype=np.int64)\\r\\n reshape_node = self.graph.elt_const(\\\"Reshape\\\", \\\"StatefulPartitionedCall/CropandResize/reshape\\\", cnr_outputs[0], reshape_shape)\\r\\n maxpl_name = \\\"StatefulPartitionedCall/MaxPool2D/MaxPool\\\"\\r\\n maxpool_node = [node for node in self.graph.nodes if node.op == \\\"MaxPool\\\" and maxpl_name == node.name][0]\\r\\n maxpool_node.inputs[0] = reshape_node[0]\\r\\n\\r\\n # Return linear transformation node, it will be located between 1st and 2nd NMS, \\r\\n # so we need to pass and connect it to 2nd NMS.\\r\\n return matmul_out[0]\",\n \"def _resize_img(self, results):\\n for key in results.get('img_fields', ['img']):\\n if self.keep_ratio:\\n img, scale_factor = mmcv.imrescale(\\n results[key],\\n results['scale'],\\n return_scale=True,\\n interpolation=self.interpolation,\\n backend=self.backend)\\n # the w_scale and h_scale has minor difference\\n # a real fix should be done in the mmcv.imrescale in the future\\n new_h, new_w = img.shape[:2]\\n h, w = results[key].shape[:2]\\n w_scale = new_w / w\\n h_scale = new_h / h\\n else:\\n img, w_scale, h_scale = mmcv.imresize(\\n results[key],\\n results['scale'],\\n return_scale=True,\\n interpolation=self.interpolation,\\n backend=self.backend)\\n results[key] = img\\n\\n scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],\\n dtype=np.float32)\\n results['img_shape'] = img.shape\\n # in case that there is no padding\\n results['pad_shape'] = img.shape\\n results['scale_factor'] = scale_factor\\n results['keep_ratio'] = self.keep_ratio\",\n \"def resizeImages(img_path,size=(50,50)):\\n image = cv2.imread(img_path)\\n resized = cv2.resize(image, size, interpolation=cv2.INTER_CUBIC)\\n img=np.array([resized.flatten()])\\n #print('resized image')\\n return img\",\n \"def resize_image(self, name, frame_dims):\\n logger.debug(\\\"Resizing image: (name: '%s', frame_dims: %s\\\", name, frame_dims)\\n displayimg = self._previewtrain[name][0]\\n if frame_dims:\\n frameratio = float(frame_dims[0]) / float(frame_dims[1])\\n imgratio = float(displayimg.size[0]) / float(displayimg.size[1])\\n\\n if frameratio <= imgratio:\\n scale = frame_dims[0] / float(displayimg.size[0])\\n size = (frame_dims[0], int(displayimg.size[1] * scale))\\n else:\\n scale = frame_dims[1] / float(displayimg.size[1])\\n size = (int(displayimg.size[0] * scale), frame_dims[1])\\n logger.debug(\\\"Scaling: (scale: %s, size: %s\\\", scale, size)\\n\\n # Hacky fix to force a reload if it happens to find corrupted\\n # data, probably due to reading the image whilst it is partially\\n # saved. If it continues to fail, then eventually raise.\\n for i in range(0, 1000):\\n try:\\n displayimg = displayimg.resize(size, Image.ANTIALIAS)\\n except OSError:\\n if i == 999:\\n raise\\n continue\\n break\\n self._previewtrain[name][1] = ImageTk.PhotoImage(displayimg)\",\n \"def resize_for_interface(cv_img):\\n\\n height, width, channels = cv_img.shape\\n width_ratio = width / Images.IMAGES_WIDTH\\n height_ratio = height / Images.IMAGES_HEIGHT\\n\\n ratio = max(width_ratio, height_ratio)\\n\\n if ratio > 1:\\n new_size = (int(width / ratio), int(height / ratio))\\n return cv2.resize(cv_img, new_size)\\n else:\\n # No need to resize\\n return cv_img\",\n \"def resize_images(self, images):\\n \\n img_list = []\\n \\n for img in images:\\n \\n yield np.resize(img, (64, 64, 3))\",\n \"def ResizeImages(\\n images,\\n size,\\n method=tf.image.ResizeMethod.BILINEAR,\\n align_corners=True,\\n data_format='channels_last'):\\n l = images\\n if data_format == 'channels_first':\\n l = tf.transpose(l, [0,2,3,1])\\n l = tf.image.resize_images(l, size, method, align_corners)\\n if data_format == 'channels_first':\\n l = tf.transpose(l, [0,3,1,2])\\n ret = tf.identity(l, name='output')\\n return ret\",\n \"def rescale_images(original_images):\\n mobile_net_possible_dims = [128, 160, 192, 224]\\n dim_goal = 128\\n \\n for dim in mobile_net_possible_dims:\\n if original_images.shape[1] <= dim:\\n dim_goal = dim\\n break;\\n print(f\\\"Image rescaled from dimension {original_images.shape[1]} to {dim_goal} for MobileNet\\\")\\n scale = dim_goal/original_images.shape[1]\\n images = np.empty((original_images.shape[0], dim_goal, dim_goal))\\n for i, original_image in enumerate(original_images):\\n images[i] = rescale(original_image, (scale, scale), multichannel=False)\\n return images\",\n \"def _resize_masks(self, results):\\n for key in results.get('mask_fields', []):\\n if results[key] is None:\\n continue\\n if self.keep_ratio:\\n results[key] = results[key].rescale(results['scale'])\\n else:\\n results[key] = results[key].resize(results['img_shape'][:2])\",\n \"def _resize_masks(self, results):\\n for key in results.get('mask_fields', []):\\n if results[key] is None:\\n continue\\n if self.keep_ratio:\\n results[key] = results[key].rescale(results['scale'])\\n else:\\n results[key] = results[key].resize(results['img_shape'][:2])\",\n \"def resize_batch(images : List[np.ndarray], size : Tuple[int,int,int,int], resize_kind='stretch') :\\n assert resize_kind in ['stretch'] and len(size) == 4\\n n, w, h, c = size if size[-1]==3 else tuple(size[i] for i in [0,3,1,2])\\n resize = lambda x: BaseRuntime.resize_stretch(x, (h,w))\\n dtype = images[0].dtype\\n n_pad = n - len(images)\\n batch_pad = [np.zeros((h,w,c),dtype=dtype)] * n_pad\\n batch_image = list(map(resize, images))\\n batch_image = batch_image + batch_pad\\n return np.stack(batch_image)\",\n \"def dataset_resize_images(self, img_name, label_name):\\n image_string = tf.read_file(img_name)\\n image_decoded = tf.image.decode_jpeg(image_string, channels=3)\\n image_resized = tf.image.resize_images(image_decoded, [self.img_h, self.img_w])\\n image_resized /= 255\\n b, g, r = tf.split(image_resized, 3, 2)\\n del image_string\\n del image_resized\\n return tf.concat([r, g, b], 2), label_name\",\n \"def _resize_img(self, results):\\n for key in results.get('img_fields', ['img']):\\n if self.keep_ratio:\\n img, scale_factor = general_ocr.imrescale(\\n results[key],\\n results['scale'],\\n return_scale=True,\\n backend=self.backend)\\n # the w_scale and h_scale has minor difference\\n # a real fix should be done in the general_ocr.imrescale in the future\\n new_h, new_w = img.shape[:2]\\n h, w = results[key].shape[:2]\\n w_scale = new_w / w\\n h_scale = new_h / h\\n else:\\n img, w_scale, h_scale = general_ocr.imresize(\\n results[key],\\n results['scale'],\\n return_scale=True,\\n backend=self.backend)\\n results[key] = img\\n\\n scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],\\n dtype=np.float32)\\n results['img_shape'] = img.shape\\n # in case that there is no padding\\n results['pad_shape'] = img.shape\\n results['scale_factor'] = scale_factor\\n results['keep_ratio'] = self.keep_ratio\",\n \"def resize_multiple_images(src_path, dst_path, img_size=None):\\r\\n for filename in os.listdir(src_path):\\r\\n try:\\r\\n img = cv.imread(os.path.join(src_path, filename))\\r\\n\\r\\n if img_size is None:\\r\\n # this shape should be the same as the one of the window used to take photos\\r\\n img_size = (640, 480)\\r\\n\\r\\n new_img = cv.resize(img, img_size)\\r\\n\\r\\n filename = filename.split(sep='.')[0]+'.jpg'\\r\\n cv.imwrite(os.path.join(dst_path, filename), new_img)\\r\\n print('Resized and saved {} successfully.'.format(filename))\\r\\n except:\\r\\n continue\",\n \"def crop_and_resize(image, boxes, size):\\n box_ind = keras.backend.zeros_like(boxes, tensorflow.int32)\\n box_ind = box_ind[..., 0]\\n box_ind = keras.backend.reshape(box_ind, [-1])\\n\\n boxes = keras.backend.reshape(boxes, [-1, 4])\\n\\n return tensorflow.image.crop_and_resize(image, boxes, box_ind, size)\",\n \"def preprocess_train_keep_aspect_ratio(im, boxes, classes, inst_masks, mask, min_side, max_side,\\n canvas_height, canvas_width,\\n use_augment=False, training_scale=[0.3, 0.5, 0.7, 1.0]):\\n im, inst_masks, mask, boxes, classes, im_scale = resize_as_min_side(im, inst_masks, mask, boxes, classes,\\n min_side=min_side, max_side=max_side)\\n\\n im, inst_masks, mask, boxes, classes = random_flip(im, inst_masks, mask, boxes, classes)\\n if use_augment:\\n if np.random.choice([0, 1]) != 0:\\n scale = np.random.choice(training_scale) # adding more small objects\\n im, inst_masks, mask, boxes, classes = random_scale(im, inst_masks, mask, boxes, classes, scale=scale)\\n\\n im, inst_masks, mask, boxes, classes = pad_to_canvas(im, inst_masks, mask, boxes, classes,\\n canvas_width=canvas_width,\\n canvas_height=canvas_height)\\n\\n # im = distort_color(im)\\n im = imcv2_recolor(im)\\n\\n boxes = np.asarray(boxes, dtype=np.float32)\\n inst_masks = np.zeros([1, im.shape[0], im.shape[1]], dtype=inst_masks.dtype) if inst_masks.size == 0 else inst_masks\\n return im, boxes, classes, inst_masks, mask, im_scale\",\n \"def transform_images(x_image: tf.Tensor, size: int) -> tf.Tensor:\\n x_image = tf.image.resize(x_image, (size, size))\\n x_image = x_image / 255\\n return x_image\",\n \"def run(self, image):\\r\\n width, height = image.size\\r\\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\r\\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\\r\\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\\r\\n batch_seg_map = self.sess.run(\\r\\n self.OUTPUT_TENSOR_NAME,\\r\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\\r\\n seg_map = batch_seg_map[0]\\r\\n return resized_image, seg_map\",\n \"def run(self, image):\\n width, height = image.size\\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\\n batch_seg_map = self.sess.run(\\n self.OUTPUT_TENSOR_NAME,\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\\n seg_map = batch_seg_map[0]\\n return resized_image, seg_map\",\n \"def _pool_and_resize(self):\\n # Pool if there are enough screens to do so.\\n if self.frame_skip > 1:\\n np.maximum(\\n self.screen_buffer[0],\\n self.screen_buffer[1],\\n out=self.screen_buffer[0])\\n\\n transformed_image = cv2.resize(\\n self.screen_buffer[0], (self.screen_size, self.screen_size),\\n interpolation=cv2.INTER_AREA)\\n int_image = np.asarray(transformed_image, dtype=np.uint8)\\n return np.expand_dims(int_image, axis=2)\",\n \"def resize_128(img): \\n return cv2.resize(img,(128,128))\",\n \"def preprocess_image(image, model_image_size):\\n #resized_image = cv2.resize(image, tuple(reversed(model_image_size)), cv2.INTER_AREA)\\n resized_image = letterbox_resize(image, tuple(reversed(model_image_size)))\\n image_data = np.asarray(resized_image).astype('float32')\\n image_data = normalize_image(image_data)\\n image_data = np.expand_dims(image_data, 0) # Add batch dimension.\\n return image_data\",\n \"def resize_all_images(image_dir, width, height, resize_type):\\n if width == \\\"\\\" and height == \\\"\\\":\\n return 0\\n print(\\\"Enter resizing image.\\\")\\n print(\\\"Enter resizing.\\\", width)\\n pool = Pool(1)\\n pool.starmap(resize_image, zip(\\n image_dir, itertools.repeat(width), itertools.repeat(height), itertools.repeat(resize_type)))\\n pool.close()\\n pool.join()\",\n \"def enforce_size(img, targets, masks, num_crowds, new_w, new_h):\\n with torch.no_grad():\\n _, h, w = img.size()\\n\\n if False: #h == new_h and w == new_w:\\n return img, targets, masks, num_crowds\\n\\n # Resize the image so that it fits within new_w, new_h\\n w_prime = new_w\\n h_prime = h * new_w / w\\n\\n if h_prime > new_h:\\n w_prime *= new_h / h_prime\\n h_prime = new_h\\n\\n w_prime = int(w_prime)\\n h_prime = int(h_prime)\\n\\n # Do all the resizing\\n img = F.interpolate(img.unsqueeze(0),\\n (h_prime, w_prime),\\n mode='bilinear',\\n align_corners=False)\\n img.squeeze_(0)\\n\\n # Act like each object is a color channel\\n masks = F.interpolate(masks.unsqueeze(0),\\n (h_prime, w_prime),\\n mode='nearest')\\n masks.squeeze_(0)\\n\\n # Scale bounding boxes (this will put them in the top left corner in the case of padding)\\n targets[:, [0, 2]] *= (w_prime / new_w)\\n targets[:, [1, 3]] *= (h_prime / new_h)\\n\\n # Finally, pad everything to be the new_w, new_h\\n pad_dims = (0, new_w - w_prime, 0, new_h - h_prime)\\n img = F.pad( img, pad_dims, mode='constant', value=0)\\n masks = F.pad(masks, pad_dims, mode='constant', value=0)\\n\\n return img, targets, masks, num_crowds\",\n \"def resize_if_big(im_cv):\\n MAX_IMG_SIZE = 900 * 1024\\n height, width, channels = im_cv.shape\\n img_size = width * height * channels\\n\\n if channels != 3:\\n print(\\\"image must be bgr24\\\")\\n sys.exit(1)\\n\\n if img_size > MAX_IMG_SIZE:\\n scale = math.sqrt(MAX_IMG_SIZE / img_size)\\n im_cv = cv2.resize(im_cv, (0, 0), fx=scale, fy=scale)\\n height, width, channels = im_cv.shape\\n img_size_kb = int(width * height * channels/1024)\\n print(f\\\"Scaled down to {width}x{height} ({img_size_kb} KB) to fit max size\\\")\\n return im_cv\",\n \"def resize(frame: Frame):\\n\\n frame.img = cv2.resize(frame.img, (720, 480))\\n frame.orginal_img = cv2.resize(frame.orginal_img, (720, 480))\\n\\n return frame\",\n \"def imgProcessing(self):\\n if (self.image_width > 320):\\n self.cv_image = imutils.resize(self.cv_image, width = 320)\\n else:\\n pass\\n\\n \\\"\\\"\\\" optional -- image-mirrored \\\"\\\"\\\"\\n # self.cv_image = cv2.flip(self.cv_image, 1)\",\n \"def resize_image(img):\\n ratio = float(img.size[1]) / float(img.size[0])\\n\\n if ratio > 1.73:\\n h, w = 320, 160 # 512, 256\\n elif ratio < 1.0 / 1.73:\\n h, w = 160, 320 # 256, 512\\n elif ratio > 1.41:\\n h, w = 384, 256\\n elif ratio < 1. / 1.41:\\n h, w = 256, 384\\n elif ratio > 1.15:\\n h, w = 320, 240 # 512, 384\\n elif ratio < 1. / 1.15:\\n h, w = 240, 320 # 384, 512\\n else:\\n h, w = 320, 320 # 384, 384\\n\\n h = int(h)\\n w = int(w)\\n img = TF.resize(img, size=[h, w], interpolation=Image.BILINEAR)\\n return img\",\n \"def reshape_coch_kell_2018(nets):\\n print('### WARNING: tf.image.resize_images is not trusted, use caution ###')\\n nets['min_cochleagram'] = tf.reduce_min(nets['cochleagram'])\\n nets['max_cochleagram'] = tf.reduce_max(nets['cochleagram'])\\n # it is possible that this scaling is going to mess up the gradients for the waveform generation\\n nets['scaled_cochleagram'] = 255*(1-((nets['max_cochleagram']-nets['cochleagram'])/(nets['max_cochleagram']-nets['min_cochleagram'])))\\n nets['reshaped_cochleagram'] = tf.image.resize_images(nets['scaled_cochleagram'],[256,256], align_corners=False, preserve_aspect_ratio=False)\\n return nets, 'reshaped_cochleagram'\",\n \"def scale_images(images, new_shape):\\n\\n images_list = list()\\n\\n for image in images:\\n new_image = resize(image, new_shape)\\n images_list.append(new_image)\\n \\n return np.asarray(images_list)\",\n \"def _resize_video(self, images, dim=64):\\n ret = np.zeros((images.shape[0], dim, dim, 3))\\n\\n for i in range(images.shape[0]):\\n ret[i] = cv2.resize(images[i], dsize=(dim, dim),\\n interpolation=cv2.INTER_CUBIC)\\n\\n return ret.astype(np.uint8)\",\n \"def resize_multiple_images(src_path, dst_path):\\n for filename in os.listdir(src_path):\\n img=Image.open(src_path+'/'+filename)\\n new_img = img.resize((96,96,))\\n #new_img.resize(96,96,1)\\n if not os.path.exists(dst_path):\\n os.makedirs(dst_path)\\n new_img.save(dst_path+'/'+filename)\\n print('Resized and saved {} successfully.'.format(filename))\",\n \"def reconstruct_image(self, net, images, name):\\n target_img_grid = torchvision.utils.make_grid(images)\\n images = images.to(self.device)\\n output = net(images)\\n img_grid = torchvision.utils.make_grid(output.cpu().data)\\n if self.writer is not None:\\n self.writer.add_image(f'{name} Reconstruct Image', target_img_grid, self.ae_epoch)\\n self.writer.add_image('Target Image', img_grid, self.ae_epoch)\",\n \"def preprocess(img, min_size, max_size):\\n if(min_size > max_size):\\n raise Exception('min_size should not exceed max_size')\\n \\n width, height = img.size\\n minDim = min(width,height)\\n maxDim = max(width,height)\\n scale_shorter_side = min_size/minDim\\n scale_longer_side = maxDim * scale_shorter_side\\n if(scale_longer_side > max_size):\\n scale = max_size/maxDim\\n else:\\n scale = scale_shorter_side\\n transform = transforms.Compose([\\n transforms.Resize((round(img.height*scale),round(img.width * scale))),\\n transforms.ToTensor(),\\n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\\n ])\\n img = transform(img)\\n return scale,img\",\n \"def reduce_resolution(input_dir, output_dir, factor=2):\\n # Get the images.\\n downsample_ratio = 1.0 / args.factor\\n tiles = glob.glob(os.path.join(args.input_dir, 'S_*/*.tif*'))\\n tiles.sort()\\n print('Number of Tiles: ', len(tiles))\\n print('Downsample Ratio: ', downsample_ratio)\\n\\n # Downsample the images by the requested factor with OpenCV's resize().\\n for t in tqdm(tiles):\\n dirname = os.path.basename(os.path.dirname(t))\\n filename = os.path.basename(t)\\n os.makedirs(os.path.join(args.output_dir, dirname), exist_ok=True)\\n f_out = os.path.join(args.output_dir, dirname, filename)\\n im = cv2.imread(t, 0)\\n im_down = cv2.resize(im, (0, 0), fx=downsample_ratio, fy=downsample_ratio)\\n cv2.imwrite(f_out, im_down)\",\n \"def resize_large_images(image_urls):\\n global cnt_resized_images\\n\\n for image_url in image_urls:\\n file_name = web.get_file_name(image_url)\\n file_path = cfg.PHOTO_DIR + file_name\\n img = Image.open(file_path)\\n width = img.size[0]\\n if width > cfg.MAX_WIDTH:\\n resize.resize_to_screen_width(file_path)\\n cnt_resized_images += 1\",\n \"def test_resize(dummy_input):\\n # Test the 2D image: H, W, C\\n image, label = dummy_input(image_size=(512, 512, 3),\\n label_size=(512, 512, 1))\\n transform = Resize(size=(64, 64))\\n _image, _label = transform(image, label, resize_orders=[3, 0])\\n assert _image.shape == (64, 64, 3)\\n assert _image.dtype == image.dtype\\n assert _label.shape == (64, 64, 1)\\n assert _label.dtype == label.dtype\\n\\n # Test the 3D image: H, W, D, C\\n image, label = dummy_input(image_size=(512, 512, 20, 3),\\n label_size=(512, 512, 20, 1))\\n transform = Resize(size=(64, 64, 10))\\n _image, _label = transform(image, label, resize_orders=[3, 0])\\n assert _image.shape == (64, 64, 10, 3)\\n assert _image.dtype == image.dtype\\n assert _label.shape == (64, 64, 10, 1)\\n assert _label.dtype == label.dtype\",\n \"def resize(image, size):\\n return np.array(Image.fromarray(image).resize(size))\",\n \"def reshape_raw_images(raw_im, \\n resize_shape,\\n ):\\n _reshaped_im = np.array([cv2.resize(_lr, tuple(resize_shape[-2:]), \\n interpolation=cv2.INTER_AREA) for _lr in raw_im])\\n return _reshaped_im\",\n \"def scale_boxes(boxes, image_shape):\\n height = image_shape[0]\\n width = image_shape[1]\\n image_dims = K.stack([height, width, height, width])\\n image_dims = K.reshape(image_dims, [1, 4])\\n boxes = boxes * image_dims\\n return boxes\",\n \"def __resize_image(self, img):\\n return cv2.resize(img, self.g.img_size, \\n interpolation = cv2.INTER_CUBIC)\",\n \"def process_image(fl):\\n #print(\\\"processing of images\\\")\\n print(fl)\\n img = cv2.imread(fl, cv2.IMREAD_COLOR)\\n resized_img = cv2.resize(img, (146, 243), interpolation=cv2.INTER_CUBIC)\\n return resized_img\",\n \"def resizeImage(image, newSize):\\n\\n # scale image\\n scaledImage = cv2.resize(image, newSize)\\n return scaledImage\",\n \"def resize(img, size):\\n img = tf.expand_dims(img, 0)\\n return tf.image.resize_bilinear(img, size)[0,:,:,:]\",\n \"def resize(im, target_size, max_size):\\n im_shape = im.shape\\n im_size_min = np.min(im_shape[0:2])\\n im_size_max = np.max(im_shape[0:2])\\n im_scale = float(target_size) / float(im_size_min)\\n # prevent bigger axis from being more than max_size:\\n if np.round(im_scale * im_size_max) > max_size:\\n im_scale = float(max_size) / float(im_size_max)\\n im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)\\n return im, im_scale\",\n \"def __init__(self, embed_size=256, finetune=False, cnn_type='resnet50',\\n use_abs=False, no_imgnorm=False):\\n super(EncoderImageFull, self).__init__()\\n self.embed_size = embed_size\\n self.no_imgnorm = no_imgnorm\\n self.use_abs = use_abs\\n\\n # Load a pre-trained model\\n model = get_model(name=cnn_type, num_classes=5607)\\n model = torch.nn.DataParallel(model)\\n model.to(\\\"cuda\\\")\\n checkpoint = torch.load(\\\"/mnt/data2/betty/webvision_train/results/resnet50/5000classes_onemonth/model_best.tar\\\")\\n model.load_state_dict(checkpoint['state_dict'])\\n \\n print(\\\"Successfully load the saved model at model_best.tar\\\") \\n\\n self.cnn = model\\n\\n\\n # For efficient memory usage.\\n for param in self.cnn.parameters():\\n param.requires_grad = False\\n\\n # Replace the last fully connected layer of CNN with a new one\\n \\n if cnn_type.startswith('resnet'):\\n self.fc = nn.Linear(self.cnn.module.fc.in_features, embed_size)\\n self.cnn.module.fc = nn.Sequential()\\n else:\\n print(\\\"error in chosing the architecture\\\")\\n return\\n\\n self.init_weights()\",\n \"def preprocess_image(image: Image.Image, max_size: int = 1200) -> Image.Image:\\n width_0, height_0 = image.size\\n\\n if max((width_0, height_0)) <= max_size:\\n return image\\n\\n if width_0 > height_0:\\n aspect_ratio = max_size / float(width_0)\\n new_height = int(float(height_0) * float(aspect_ratio))\\n image = image.resize((max_size, new_height), Image.ANTIALIAS)\\n return image\\n else:\\n aspect_ratio = max_size / float(height_0)\\n new_width = int(float(width_0) * float(aspect_ratio))\\n image = image.resize((max_size, new_width), Image.ANTIALIAS)\\n return image\",\n \"def run(self, image):\\n width, height = image.size\\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\\n resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\\n batch_seg_map = self.sess.run(\\n self.OUTPUT_TENSOR_NAME,\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\\n seg_map = batch_seg_map[0]\\n return resized_image, seg_map\",\n \"def resize(img, size):\\n img = cv2.resize(img, tuple(size[::-1]))\\n return img\",\n \"def initial_resizing(fr_raw_data_path, fr_data_path, dim=300):\\n with h5py.File(fr_raw_data_path, 'r') as data:\\n images = resize_array(np.asarray(data['images'].value), dim=dim)\\n labels = data['labels'].value\\n \\n with h5py.File(fr_data_path, 'w') as f:\\n f.create_dataset('images', data=images)\\n\\n with h5py.File(fr_raw_data_path, 'r') as data: \\n f.copy(data['fri_data'], 'fri_data')\\n f.copy(data['frii_data'], 'frii_data')\\n f.copy(data['labels'], 'labels')\",\n \"def resize(image):\\n\\treturn cv2.resize(image, \\n\\t\\t\\t\\t\\t (FACE_WIDTH, FACE_HEIGHT), \\n\\t\\t\\t\\t\\t interpolation=cv2.INTER_LANCZOS4)\",\n \"def resize(img, size, method=\\\"bilinear\\\"):\\n if method == Image.BILINEAR or method == \\\"bilinear\\\":\\n method = cv2.INTER_AREA\\n elif method == Image.CUBIC or method == \\\"cubic\\\":\\n method = cv2.INTER_CUBIC\\n elif method == Image.NEAREST or method == \\\"nearest\\\":\\n method = cv2.INTER_NEAREST\\n else:\\n raise RuntimeError(\\\"wrong method {}\\\".format(method))\\n if not isinstance(size, (tuple, list)):\\n size = (size, size)\\n if isinstance(size ,list):\\n size = tuple(size)\\n im = np.array(img)\\n im = cv2.resize(im, size, interpolation=method)\\n return Image.fromarray(im)\",\n \"def change_resolution(img):\\n scale_factor = np.random.choice(list(range(0, 6, 2)))\\n if scale_factor == 0:\\n return img\\n downsample = nn.AvgPool2d(scale_factor)\\n upsample = nn.UpsamplingNearest2d(scale_factor=scale_factor)\\n new_res_img = upsample(downsample(img.unsqueeze(dim=1))).squeeze()\\n return new_res_img\",\n \"def run(self, image):\\n width, height = image.size\\n resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\\n target_size = (int(resize_ratio * width), int(resize_ratio * height))\\n resized_image = image.convert('RGB').resize(\\n target_size, Image.ANTIALIAS)\\n batch_seg_map = self.sess.run(\\n self.OUTPUT_TENSOR_NAME,\\n feed_dict={self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\\n seg_map = batch_seg_map[0]\\n return resized_image, seg_map\",\n \"def resize_image_batch(input_dir, output_dir, image_size):\\n if not os.path.isdir(output_dir):\\n os.mkdir(output_dir)\\n input_paths = [os.path.join(input_dir, image_name) for image_name in os.listdir(input_dir)]\\n output_paths = [os.path.join(output_dir, image_name) for image_name in os.listdir(input_dir)]\\n image_sizes = [image_size]*len(input_paths)\\n \\n _ = Parallel(n_jobs=-1, verbose=3)(delayed(resize_one_image)(ipath, opath, img_size) for ipath, opath, img_size in zip(input_paths, output_paths, image_sizes))\",\n \"def _images_and_boxes_preprocessing_cv2(self, imgs, boxes):\\r\\n\\r\\n height, width, _ = imgs[0].shape\\r\\n\\r\\n boxes[:, [0, 2]] *= width\\r\\n boxes[:, [1, 3]] *= height\\r\\n boxes = cv2_transform.clip_boxes_to_image(boxes, height, width)\\r\\n\\r\\n # `transform.py` is list of np.array. However, for AVA, we only have\\r\\n # one np.array.\\r\\n boxes = [boxes]\\r\\n # The image now is in HWC, BGR format.\\r\\n if self._split == \\\"train\\\": # \\\"train\\\"\\r\\n imgs, boxes = cv2_transform.random_short_side_scale_jitter_list(\\r\\n imgs,\\r\\n min_size=self._jitter_min_scale,\\r\\n max_size=self._jitter_max_scale,\\r\\n boxes=boxes,\\r\\n )\\r\\n imgs, boxes = cv2_transform.random_crop_list(\\r\\n imgs, self._crop_size, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n if self.random_horizontal_flip:\\r\\n # random flip\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 0.5, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n elif self._split == \\\"val\\\":\\r\\n # Short side to test_scale. Non-local and STRG uses 256.\\r\\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\r\\n boxes = [\\r\\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\\r\\n ]\\r\\n imgs, boxes = cv2_transform.spatial_shift_crop_list(\\r\\n self._crop_size, imgs, 1, boxes=boxes\\r\\n )\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n elif self._split == \\\"test\\\":\\r\\n # Short side to test_scale. Non-local and STRG uses 256.\\r\\n imgs = [cv2_transform.scale(self._crop_size, img) for img in imgs]\\r\\n boxes = [\\r\\n cv2_transform.scale_boxes(self._crop_size, boxes[0], height, width)\\r\\n ]\\r\\n\\r\\n if self._test_force_flip:\\r\\n imgs, boxes = cv2_transform.horizontal_flip_list(\\r\\n 1, imgs, order=\\\"HWC\\\", boxes=boxes\\r\\n )\\r\\n else:\\r\\n raise NotImplementedError(\\\"Unsupported split mode {}\\\".format(self._split))\\r\\n\\r\\n # Convert image to CHW keeping BGR order.\\r\\n imgs = [cv2_transform.HWC2CHW(img) for img in imgs]\\r\\n\\r\\n # Image [0, 255] -> [0, 1].\\r\\n imgs = [img / 255.0 for img in imgs]\\r\\n\\r\\n imgs = [\\r\\n np.ascontiguousarray(\\r\\n # img.reshape((3, self._crop_size, self._crop_size))\\r\\n img.reshape((3, imgs[0].shape[1], imgs[0].shape[2]))\\r\\n ).astype(np.float32)\\r\\n for img in imgs\\r\\n ]\\r\\n\\r\\n # Do color augmentation (after divided by 255.0).\\r\\n if self._split == \\\"train\\\" and self._use_color_augmentation:\\r\\n if not self._pca_jitter_only:\\r\\n imgs = cv2_transform.color_jitter_list(\\r\\n imgs, img_brightness=0.4, img_contrast=0.4, img_saturation=0.4\\r\\n )\\r\\n\\r\\n imgs = cv2_transform.lighting_list(\\r\\n imgs,\\r\\n alphastd=0.1,\\r\\n eigval=np.array(self._pca_eigval).astype(np.float32),\\r\\n eigvec=np.array(self._pca_eigvec).astype(np.float32),\\r\\n )\\r\\n\\r\\n # Normalize images by mean and std.\\r\\n imgs = [\\r\\n cv2_transform.color_normalization(\\r\\n img,\\r\\n np.array(self._data_mean, dtype=np.float32),\\r\\n np.array(self._data_std, dtype=np.float32),\\r\\n )\\r\\n for img in imgs\\r\\n ]\\r\\n\\r\\n # Concat list of images to single ndarray.\\r\\n imgs = np.concatenate([np.expand_dims(img, axis=1) for img in imgs], axis=1)\\r\\n\\r\\n if not self._use_bgr:\\r\\n # Convert image format from BGR to RGB.\\r\\n imgs = imgs[::-1, ...]\\r\\n\\r\\n imgs = np.ascontiguousarray(imgs)\\r\\n imgs = torch.from_numpy(imgs)\\r\\n boxes = cv2_transform.clip_boxes_to_image(\\r\\n boxes[0], imgs[0].shape[1], imgs[0].shape[2]\\r\\n )\\r\\n return imgs, boxes\",\n \"def resize_image(parent_directory, img_columns,img_rows):\\n\\t#List of img files in the directory for the specific simulation file\\n\\tlisting = os.listdir(parent_directory)\\n\\t#Number of img files in the directory for the specific simulation file\\n\\tnum_samples = len(listing)\\n\\t#Create Directory to store the re-sized images\\n\\tdir_nam = parent_directory + '/resize_col_' + str(img_columns) + '_row_' + str(img_rows)\\n\\tif not os.path.exists(dir_nam):\\n\\t\\tos.makedirs(dir_nam)\\n\\t#Open image and resize --> (img_rows,img_columns)\\n\\tfor file in listing:\\n\\t\\tif file.endswith('.bmp'):\\n\\t\\t\\tim = PIL.Image.open(parent_directory + '/' + file)\\n\\t\\t\\tim_resized = im.resize((img_columns,img_rows))\\n\\t\\t\\tim_resized.save(dir_nam + '/' + file)\\n\\treturn;\",\n \"def main(inputfile, output, size):\\n if not output:\\n output = join(dirname(inputfile), str(size))\\n if not isdir(output):\\n os.mkdir(output)\\n\\n logger.info('Resizing images from: %s' % inputfile)\\n inputfile = realpath(inputfile)\\n #/usr/share/datasets/KSCGR_Original/data1/boild-egg/0.jpg 0\\n nb_lines = count_lines(inputfile)\\n pbar = pb.ProgressBar(nb_lines)\\n with open(inputfile) as fin:\\n for line in fin:\\n path, tl = line.strip().split()\\n newpath = create_path(path, output)\\n img = cv2.imread(path)\\n img = resize_image(img, size)\\n cv2.imwrite(newpath, img)\\n pbar.update()\\n logger.info('Total of images resized: %d' % nb_lines)\",\n \"def _resize(img, max_dim=128):\\n if max(img.shape[:3]) <= max_dim:\\n return img\\n else:\\n new_size = [max_dim / s if s >= max_dim else 1.0 for s in img.shape[:3]]\\n new_size.append(1.0) # for channel\\n return scipy.ndimage.zoom(img, new_size, order=2)\",\n \"def retinanet_resize_image(img, min_side=800, max_side=1333):\\n # compute scale to resize the image\\n scale = retinanet_compute_resize_scale(img.shape, min_side=min_side, max_side=max_side)\\n # scale = round(scale, 4)\\n # print(\\\"scale: \\\", scale)\\n\\n # resize the image with the computed scale\\n img = cv2.resize(img, None, fx=scale, fy=scale)\\n\\n return img, scale\",\n \"def resize_image(image, target_size):\\n image = cv2.resize(image, target_size)\\n return image\",\n \"def demo2(image_paths, output_dir, cuda):\\n\\n device = get_device(cuda)\\n\\n # Synset words\\n classes = get_classtable()\\n\\n # Model\\n model = models.resnet152(pretrained=True)\\n model.to(device)\\n model.eval()\\n\\n # The four residual layers\\n target_layers = [\\\"relu\\\", \\\"layer1\\\", \\\"layer2\\\", \\\"layer3\\\", \\\"layer4\\\"]\\n target_class = 243 # \\\"bull mastif\\\"\\n\\n # Images\\n images, raw_images = load_images(image_paths)\\n images = torch.stack(images).to(device)\\n\\n gcam = GradCAM(model=model)\\n probs, ids = gcam.forward(images)\\n # ids_ = torch.LongTensor([[target_class]] * len(images)).to(device)\\n ids_ = torch.tensor([[target_class]] * len(images), dtype=torch.long).to(device)\\n gcam.backward(ids=ids_)\\n\\n for target_layer in target_layers:\\n print(\\\"Generating Grad-CAM @{}\\\".format(target_layer))\\n\\n # Grad-CAM\\n regions = gcam.generate(target_layer=target_layer)\\n\\n for j in range(len(images)):\\n print(\\n \\\"\\\\t#{}: {} ({:.5f})\\\".format(\\n j, classes[target_class], float(probs[ids == target_class])\\n )\\n )\\n\\n # save_gradcam(\\n # filename=osp.join(\\n # output_dir,\\n # \\\"{}-{}-gradcam-{}-{}.png\\\".format(\\n # j, \\\"resnet152\\\", target_layer, classes[target_class]\\n # ),\\n # ),\\n # gcam=regions[j, 0],\\n # raw_image=raw_images[j],\\n # )\",\n \"def preprocess_train(im, boxes, classes, inst_masks, mask, input_size, min_size=2,\\n use_augment=False, training_scale=[0.3, 0.5, 0.7, 1.0]):\\n ori_im = np.copy(im)\\n target_h, target_w = input_size\\n\\n # ---------- old data_augmentation ----------\\n if use_augment:\\n if np.random.choice([0, 1]) != 0:\\n scale = np.random.choice(training_scale) # adding more small objects\\n im, inst_masks, mask, boxes, classes = random_scale(im, inst_masks, mask, boxes, classes, scale=scale)\\n min_obj_cover = np.random.choice([0.8, 0.9, 1.0])\\n # truncted examples may lead to multiple-detections..\\n im, inst_masks, mask, boxes, classes = random_aspect_ratio(im, inst_masks, mask, boxes, classes,\\n min_aspect_ratio=0.5, max_aspect_ratio=2.0,\\n min_obj_cover=min_obj_cover)\\n #\\n # # r = np.random.randint(0, 3)\\n # if np.random.rand() < 0.75:\\n # im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\\n # else:\\n # im, inst_masks, mask, boxes, classes = center_crop2fixed_pad(im, inst_masks, mask, boxes, classes, target_w, target_h,\\n # min_size=min_size)\\n\\n # ---------- old data_augmentation ----------\\n\\n # ---------- none data_augmentation ----------\\n im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\\n im, inst_masks, mask, boxes, classes = random_flip(im, inst_masks, mask, boxes, classes)\\n # ---------- none data_augmentation ----------\\n\\n # ---------- old data_augmentation ----------\\n im = distort_color(im)\\n # ---------- old data_augmentation ----------\\n\\n im = imcv2_recolor(im)\\n\\n # add this because zeros numpy array will cause errors in torch Dataloader\\n inst_masks = np.zeros([1, target_h, target_w], dtype=inst_masks.dtype) if inst_masks.size == 0 else inst_masks\\n\\n boxes = np.asarray(boxes, dtype=np.float32)\\n return im, boxes, classes, inst_masks, mask, ori_im\",\n \"def ResNet(images, device):\\n blocksPerSection = [2, 2, 2, 2]\\n channelsPerSection = [64, 128, 256, 512]\\n channelsPerBlock = [1, 1]\\n downsampleSection = [0, 1, 1, 1]\\n\\n\\n x = images\\n channelsOut = 64\\n\\n with tf.device(device):\\n\\n x = ConvBlock(x, 64, [7,7], 2, '_init')\\n x = slim.max_pool2d(x, [3, 3], stride=2, scope='pool_1')\\n\\n for s in range(len(blocksPerSection)):\\n for l in range(blocksPerSection[s]):\\n\\n # Stride at the beginning of each block\\n stride = 1\\n if l == 0 and downsampleSection[s]:\\n stride = 2\\n\\n sumInput = x\\n\\n # 2 conv only\\n x = ConvBlock(x, channelsPerSection[s]*channelsPerBlock[1], [3, 3], stride, '%d_1_%d'%(s,l))\\n x = ConvBlock(x, channelsPerSection[s]*channelsPerBlock[1], [3, 3], 1, '%d_2_%d'%(s,l), False)\\n\\n if l == 0 and channelsOut != channelsPerSection[s]*channelsPerBlock[1]:\\n sumInput = ConvBlock(sumInput, channelsPerSection[s]*channelsPerBlock[1], [1,1], stride, '_sum%d'%(s), False)\\n\\n channelsOut = channelsPerSection[s]*channelsPerBlock[1]\\n x = sumInput + x\\n x = tf.nn.relu(x)\\n\\n with slim.arg_scope([slim.fully_connected],\\n activation_fn=None,\\n weights_regularizer=slim.l2_regularizer(0.0005),\\n biases_regularizer=slim.l2_regularizer(0.0005),\\n trainable=True):\\n x = tf.reduce_mean(x, [1,2])\\n softmax_linear = slim.fully_connected(x, NUM_CLASSES, scope='fc_1')\\n\\n return softmax_linear\",\n \"def FlyResize( image, log_mess, nimages, method = Image.ANTIALIAS ):\\n oldw, oldh = image.size\\n resl = [8, 10, 14, 16, 20, 22, 24, 32, 40, 48, 64, 96, 128, 256]\\n \\n if oldw > 256 or oldh > 256:\\n newsiz = min(resl, key = lambda x:abs(x - max(oldw, oldh)))\\n image.thumbnail((newsiz, newsiz), method)\\n neww, newh = image.size\\n log_mess += ' and new size scaled = %s x %s' %(neww, newh)\\n elif nimages > 1:\\n log_mess += ' and size = %s x %s' %(oldw, oldh)\\n \\n return oldw, oldh, image, log_mess\",\n \"def build_resnet152(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128) \\n temp = res3a_feats\\n for i in range(1, 8):\\n temp = self.basic_block2(temp, 'res3b'+str(i), 'bn3b'+str(i), is_train, use_batch_norm, 128)\\n res3b7_feats = temp\\n \\n res4a_feats = self.basic_block(res3b7_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n temp = res4a_feats\\n for i in range(1, 36):\\n temp = self.basic_block2(temp, 'res4b'+str(i), 'bn4b'+str(i), is_train, use_batch_norm, 256)\\n res4b35_feats = temp\\n\\n res5a_feats = self.basic_block(res4b35_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w):\\n h, w, c = im.shape\\n scale = float(target_h) / h\\n im = cv2.resize(im, (target_w, target_h))\\n mask = cv2.resize(mask, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\\n if inst_masks.size > 0:\\n inst_masks = np.transpose(inst_masks, (1, 2, 0)) # to (h, w, n)\\n inst_masks = cv2.resize(inst_masks, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\\n try:\\n if inst_masks.ndim > 2:\\n inst_masks = np.transpose(inst_masks, (2, 0, 1)) # to (n, h, w)\\n else:\\n inst_masks = inst_masks.reshape((1, target_h, target_w))\\n except ValueError:\\n print (inst_masks.ndim, inst_masks.shape)\\n raise\\n else:\\n inst_masks = np.zeros((0, h, w), inst_masks.dtype)\\n boxes[:, 0:4:2] = boxes[:, 0:4:2] * float(target_w) / w\\n boxes[:, 1:4:2] = boxes[:, 1:4:2] * float(target_h) / h\\n\\n return im, inst_masks, mask, boxes, classes\",\n \"def image_network_train(learn_data_path):\\n\\n # data selector ----------\\n use_da_data = False\\n increase_val = False\\n print( \\\"\\\\nmode: Use Augmented data: {} | increase validation data: {}\\\".format(use_da_data, increase_val) )\\n\\n # First define original train_data only as train_dir\\n train_dir = os.path.join(data_dir, \\\"train\\\")\\n if (use_da_data == True) and (increase_val == False):\\n # with_augmented data (no validation increase)\\n train_dir = os.path.join(data_dir, \\\"train_with_aug\\\")\\n validation_dir = os.path.join(data_dir, \\\"val\\\") # original validation data\\n\\n # pair of decreaced train_data and increased validation data\\n if (increase_val == True):\\n train_dir = os.path.join(data_dir, \\\"red_train\\\")\\n if (use_da_data == True):\\n train_dir = os.path.join(data_dir, \\\"red_train_with_aug\\\")\\n validation_dir = os.path.join(data_dir, \\\"validation\\\")\\n\\n test_dir = os.path.join(data_dir, \\\"test\\\")\\n\\n print(\\\"\\\\ntrain_dir: \\\", train_dir)\\n print(\\\"validation_dir: \\\", validation_dir)\\n\\n\\n # calcucate the num of category\\n num_category = 0\\n for dirpath, dirnames, filenames in os.walk(train_dir):\\n for dirname in dirnames:\\n num_category += 1\\n\\n # All images will be resized to 299x299\\n image_size = 299\\n batch_size = 16\\n\\n # Rescale all images by 1./255 and apply image augmentation\\n train_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\\n validation_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\\n test_datagen = keras.preprocessing.image.ImageDataGenerator(rescale=1./255)\\n\\n # Flow training images in batches of using train_datagen generator\\n train_generator = train_datagen.flow_from_directory(\\n train_dir, # Source directory for the training images\\n target_size=(image_size, image_size),\\n batch_size=batch_size,\\n class_mode='categorical')\\n\\n # Flow validation images in batches of 20 using validation_datagen generator\\n validation_generator = validation_datagen.flow_from_directory(\\n validation_dir, # Source directory for the validation images\\n target_size=(image_size, image_size),\\n batch_size=batch_size,\\n class_mode='categorical')\\n\\n # Flow validation images in batches of 20 using test_datagen generator\\n test_generator = test_datagen.flow_from_directory(\\n test_dir, # Source directory for the test images\\n target_size=(image_size, image_size),\\n batch_size=batch_size,\\n class_mode='categorical')\\n\\n # Create the base model from the pre-trained convnets\\n IMG_SHAPE = (image_size, image_size, 3)\\n\\n # Create the base model from the pre-trained model MobileNet V2\\n base_model = keras.applications.xception.Xception(input_shape=IMG_SHAPE, include_top=False, weights='imagenet')\\n\\n # Freeze the convolutional base\\n base_model.trainable = False\\n\\n # モデル\\n model = keras.Sequential([\\n base_model,\\n keras.layers.GlobalAveragePooling2D(),\\n keras.layers.Dense(num_category, activation='softmax')\\n ])\\n\\n # Compile the model\\n model.compile(optimizer=keras.optimizers.Adam(lr=0.0001),\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n\\n # early stopping\\n es = keras.callbacks.EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)\\n\\n model.summary()\\n\\n # 更新される重みの数\\n print('after', len(model.trainable_weights))\\n\\n # Train the model\\n epochs = 30\\n steps_per_epoch = train_generator.n // batch_size\\n validation_steps = validation_generator.n // batch_size\\n test_steps = test_generator.n // batch_size\\n\\n history = model.fit_generator(train_generator,\\n steps_per_epoch = steps_per_epoch,\\n epochs=epochs,\\n workers=4,\\n validation_data=validation_generator,\\n validation_steps=validation_steps,\\n callbacks=[es],\\n class_weight={0:1.0, 1:0.4})\\n\\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\\n print('val loss: {}, val acc: {}'.format(loss, acc))\\n\\n # Fine tuning\\n # Un-freeze the top layers of the model\\n base_model.trainable = True\\n\\n # The nums of layers are in the base model\\n print(\\\"Number of layers in the base model: \\\", len(base_model.layers))\\n\\n # Fine tune from this layer onwards\\n fine_tune_at = 108\\n\\n # Freeze all the layers before the `fine_tune_at` layer\\n for layer in base_model.layers[:fine_tune_at]:\\n layer.trainable = False\\n\\n # Compile the model using a much-lower training rate\\n model.compile(optimizer = keras.optimizers.Adam(lr=2e-5),\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n\\n model.summary()\\n\\n # 更新される重みの数\\n print('after Fine tune', len(model.trainable_weights))\\n\\n # Continue Train the model\\n history_fine = model.fit_generator(train_generator,\\n steps_per_epoch = steps_per_epoch,\\n epochs=epochs,\\n workers=4,\\n validation_data=validation_generator,\\n validation_steps=validation_steps,\\n callbacks=[es],\\n class_weight={0:1.0, 1:0.4})\\n\\n\\n # print(history_fine.history)\\n model_val_acc = history_fine.history['val_accuracy'][-1]\\n print('val_acc: ', model_val_acc)\\n\\n # save model into hdf5 file ----------\\n model.save(learn_data_path + '/shen_model.h5')\\n\\n loss, acc = model.evaluate_generator(validation_generator, steps=validation_steps)\\n print('val loss: {}, val acc: {}'.format(loss, acc))\\n\\n loss, acc = model.evaluate_generator(test_generator, steps=test_steps)\\n print('Test loss: {}, Test acc: {}'.format(loss, acc))\",\n \"def optimize_images(conv_id=None, num_iterations=30):\\n\\n if conv_id is None:\\n print(\\\"Final fully-connected layer before softmax.\\\")\\n else:\\n print(\\\"Layer:\\\", conv_names[conv_id])\\n\\n images = []\\n for feature in range(0, 10):\\n print(\\\"Optimizing image for feature no.\\\", feature)\\n\\n image = optimize_image(conv_id=conv_id, feature=feature, show_progress=False, num_iterations=num_iterations)\\n\\n image = image.squeeze()\\n images.append(image)\\n\\n images = np.array(images)\\n\\n plot_images10(images=images)\",\n \"def process_image(image):\\n image = resize(image)\\n return image\",\n \"def img_preprocess(self, img, output_size=64):\\n w, h = img.size\\n if w > h:\\n box_param = (int(w * 0.5 - h * 0.5), 0, int(w * 0.5 + h * 0.5), h)\\n cropped = img.crop(box_param)\\n else: # w < h\\n box_param = (0, int(h * 0.5 - w * 0.5), w, int(h * 0.5 + w * 0.5))\\n cropped = img.crop(box_param)\\n\\n resized = cropped.resize((output_size, output_size))\\n resized = np.asarray(resized)\\n\\n return resized\",\n \"def SqueezeNet(input_shape=(224, 224, 3)):\\n image_input = Input(shape=input_shape)\\n\\n network = Conv2D(64, (3, 3), strides=(2, 2), padding=\\\"valid\\\")(image_input)\\n network = Activation(\\\"relu\\\")(network)\\n network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network)\\n\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=16, input_channel_large=64\\n )\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=16, input_channel_large=64\\n )\\n network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network)\\n\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=32, input_channel_large=128\\n )\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=32, input_channel_large=128\\n )\\n network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network)\\n\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=48, input_channel_large=192\\n )\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=48, input_channel_large=192\\n )\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=64, input_channel_large=256\\n )\\n network = squeezenet_fire_module(\\n input=network, input_channel_small=64, input_channel_large=256\\n )\\n\\n # Remove layers like Dropout and BatchNormalization, they are only needed in training\\n # network = Dropout(0.5)(network)\\n\\n network = Conv2D(1000, kernel_size=(1, 1), padding=\\\"valid\\\", name=\\\"last_conv\\\")(\\n network\\n )\\n network = Activation(\\\"relu\\\")(network)\\n\\n network = GlobalAvgPool2D()(network)\\n network = Activation(\\\"softmax\\\", name=\\\"output\\\")(network)\\n\\n input_image = image_input\\n model = Model(inputs=input_image, outputs=network)\\n\\n return model\",\n \"def resize_image(image: Image) -> Image:\\n expected_x: int = 1024\\n expected_y: int = 768\\n x, y = image.size\\n if x > expected_x or y > expected_y:\\n scale = min(expected_x / x, expected_y / y)\\n return image.resize((int(x * scale), int(y * scale)))\\n else:\\n return image.resize((int(0.9*x), int(0.9*y)))\",\n \"def build_resnet50(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_feats = convolution(imgs, 7, 7, 64, 2, 2, 'conv1')\\n conv1_feats = batch_norm(conv1_feats, 'bn_conv1', is_train, use_batch_norm)\\n conv1_feats = nonlinear(conv1_feats, 'relu')\\n pool1_feats = max_pool(conv1_feats, 3, 3, 2, 2, 'pool1')\\n\\n res2a_feats = self.basic_block(pool1_feats, 'res2a', 'bn2a', is_train, use_batch_norm, 64, 1)\\n res2b_feats = self.basic_block2(res2a_feats, 'res2b', 'bn2b', is_train, use_batch_norm, 64)\\n res2c_feats = self.basic_block2(res2b_feats, 'res2c', 'bn2c', is_train, use_batch_norm, 64)\\n \\n res3a_feats = self.basic_block(res2c_feats, 'res3a', 'bn3a', is_train, use_batch_norm, 128)\\n res3b_feats = self.basic_block2(res3a_feats, 'res3b', 'bn3b', is_train, use_batch_norm, 128)\\n res3c_feats = self.basic_block2(res3b_feats, 'res3c', 'bn3c', is_train, use_batch_norm, 128)\\n res3d_feats = self.basic_block2(res3c_feats, 'res3d', 'bn3d', is_train, use_batch_norm, 128)\\n\\n res4a_feats = self.basic_block(res3d_feats, 'res4a', 'bn4a', is_train, use_batch_norm, 256)\\n res4b_feats = self.basic_block2(res4a_feats, 'res4b', 'bn4b', is_train, use_batch_norm, 256)\\n res4c_feats = self.basic_block2(res4b_feats, 'res4c', 'bn4c', is_train, use_batch_norm, 256)\\n res4d_feats = self.basic_block2(res4c_feats, 'res4d', 'bn4d', is_train, use_batch_norm, 256)\\n res4e_feats = self.basic_block2(res4d_feats, 'res4e', 'bn4e', is_train, use_batch_norm, 256)\\n res4f_feats = self.basic_block2(res4e_feats, 'res4f', 'bn4f', is_train, use_batch_norm, 256)\\n\\n res5a_feats = self.basic_block(res4f_feats, 'res5a', 'bn5a', is_train, use_batch_norm, 512)\\n res5b_feats = self.basic_block2(res5a_feats, 'res5b', 'bn5b', is_train, use_batch_norm, 512)\\n res5c_feats = self.basic_block2(res5b_feats, 'res5c', 'bn5c', is_train, use_batch_norm, 512)\\n\\n res5c_feats_flat = tf.reshape(res5c_feats, [self.batch_size, 49, 2048])\\n self.conv_feats = res5c_feats_flat\\n self.conv_feat_shape = [49, 2048]\\n self.num_ctx = 49 \\n self.dim_ctx = 2048\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def capture():\\n stream = BytesIO()\\n cam.capture(stream, 'jpeg')\\n data = np.fromstring(stream.getvalue(), dtype=np.uint8)\\n # \\\"Decode\\\" the image preserving color\\n img = cv2.imdecode(data, 1)\\n # switch BGR order to RGB order\\n img = img[:, :, ::-1]\\n\\n # resize image to match training size\\n img = cv2.resize(img, (args.resize, args.resize), interpolation=cv2.INTER_AREA)\\n print(\\\"done resizing\\\")\\n\\n# cv2.imshow('image',img)\\n# cv2.waitKey(0)\\n# cv2.destroyAllWindows()\\n return img.flatten()\",\n \"def frame_size_standardize(self, frame):\\r\\n h,w,_ = frame.shape\\r\\n standard_size = self.cfg.PRETRAIN.STANDARD_SIZE\\r\\n if isinstance(standard_size, list):\\r\\n assert len(standard_size) == 3\\r\\n size_s, size_l, crop_size = standard_size\\r\\n reshape_size = random.randint(int(size_s), int(size_l))\\r\\n else:\\r\\n crop_size = standard_size\\r\\n reshape_size = standard_size\\r\\n\\r\\n # resize the short side to standard size\\r\\n dtype = frame.dtype\\r\\n frame = frame.permute(2, 0, 1).to(torch.float) # C, H, W\\r\\n aspect_ratio = random.uniform(self.aspect_ratio[0], self.aspect_ratio[1])\\r\\n if h <= w:\\r\\n new_h = reshape_size\\r\\n new_w = int(new_h / h * w)\\r\\n # resize\\r\\n frame = F.resize(frame.unsqueeze(0), (new_h, new_w), \\\"bilinear\\\").squeeze(0) \\r\\n elif h > w:\\r\\n new_w = reshape_size\\r\\n new_h = int(new_w / w * h)\\r\\n # resize\\r\\n frame = F.resize(frame.unsqueeze(0), (new_h, new_w), \\\"bilinear\\\").squeeze(0) \\r\\n \\r\\n # crop\\r\\n if aspect_ratio >= 1: \\r\\n crop_h = int(crop_size / aspect_ratio)\\r\\n crop_w = crop_size\\r\\n else:\\r\\n crop_h = crop_size\\r\\n crop_w = int(crop_size * aspect_ratio)\\r\\n start_h = random.randint(0, new_h - crop_h)\\r\\n start_w = random.randint(0, new_w - crop_w)\\r\\n return frame[:, start_h:start_h+crop_h, start_w:start_w+crop_w].to(dtype).permute(1, 2, 0) # H, W, C\\r\",\n \"def run(basedir, resize_height=288):\\n print(\\\"initialize\\\")\\n\\n img0 = [os.path.join(basedir, 'images', f) \\\\\\n for f in sorted(os.listdir(os.path.join(basedir, 'images'))) \\\\\\n if f.endswith('JPG') or f.endswith('jpg') or f.endswith('png')][0]\\n sh = cv2.imread(img0).shape\\n height = resize_height\\n factor = sh[0] / float(height)\\n width = int(round(sh[1] / factor))\\n _minify(basedir, resolutions=[[height, width]])\\n\\n print(\\\"finished\\\")\",\n \"def autoencode(self, imgs):\\n x = tf.layers.conv2d(imgs, filters=32, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\\n shape2 = x.shape\\n x = tf.layers.max_pooling2d(x, pool_size=2, strides=2)\\n x = tf.layers.conv2d(x, filters=64, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\\n shape1 = x.shape\\n x = tf.layers.max_pooling2d(x, pool_size=2, strides=2)\\n # shape0 = x.shape\\n # x = tf.layers.conv2d(x, filters=128, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\\n # x = tf.layers.max_pooling2d(x, pool_size=2, strides=2)\\n# shape_orig = x.shape\\n# x = tf.layers.flatten(x)\\n# shape_dense = x.shape\\n# x = tf.layers.dense(x, units=512, activation=tf.nn.relu)\\n# x = tf.layers.dense(x, units=shape_dense[-1], activation=tf.nn.relu)\\n# x = tf.reshape(x, [-1, shape_orig[1], shape_orig[2], shape_orig[3]])\\n # x = tf.layers.conv2d(x, filters=128, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\\n # x = tf.image.resize(x, size=(shape0[1], shape0[2]), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\\n x = tf.layers.conv2d(x, filters=64, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\\n x = tf.image.resize(x, size=(shape1[1], shape1[2]), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\\n x = tf.layers.conv2d(x, filters=32, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\\n x = tf.image.resize(x, size=(shape2[1], shape2[2]), method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)\\n x = tf.layers.conv2d(x, filters=3, kernel_size=3, strides=1, padding='same', activation=tf.nn.relu)\\n \\n return x\",\n \"def transform_images(image, size):\\n\\n # convert image to tensor\\n image = tf.convert_to_tensor(image)\\n \\n # add batch dimension to image\\n image = tf.expand_dims(image, axis = 0)\\n \\n # resize image to specified size\\n image = tf.image.resize_with_pad(image, size, size)\\n \\n # standardize image\\n image = image / 255\\n \\n # remove batch dimension\\n image = tf.squeeze(image, axis = 0)\\n \\n return image.numpy()\",\n \"def resize(image):\\r\\n return cv2.resize(image, (200, 66), interpolation=cv2.INTER_AREA)\",\n \"def resize(self):\\n pass\",\n \"def resize(img):\\n size = (500, 500)\\n img.thumbnail(size)\\n return img\",\n \"def scale_image(img, factor=1):\\n return cv2.resize(img, (int(img.shape[1] * factor), int(img.shape[0] * factor)))\",\n \"def test_resize3d():\\n\\n # Check resize3d for images with different size and without channel nor batch - Pass\\n input_shape = (1, 3, 5)\\n output_shape = (2, 4, 6)\\n size = (2, 4, 6)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for images with different size and without channel - Pass\\n input_shape = (1, 1, 3, 5)\\n output_shape = (1, 2, 4, 6)\\n size = (2, 4, 6)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for images with different size and with one channel - Pass\\n input_shape = (1, 1, 3, 5, 1)\\n output_shape = (1, 2, 4, 6, 1)\\n size = (2, 4, 6)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for images with different size and with multiple channels - Pass\\n input_shape = (1, 1, 3, 5, 3)\\n output_shape = (1, 2, 4, 6, 3)\\n size = (2, 4, 6)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for images with the same size and without channel nor batch - Pass\\n input_shape = (1, 3, 5)\\n output_shape = (1, 3, 5)\\n size = (1, 3, 5)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for images with the same size and without channel - Pass\\n input_shape = (1, 1, 3, 5)\\n output_shape = (1, 1, 3, 5)\\n size = (1, 3, 5)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for images with the same size and with one channel - Pass\\n input_shape = (1, 1, 3, 5, 1)\\n output_shape = (1, 1, 3, 5, 1)\\n size = (1, 3, 5)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for images with the same size and with multiple channels - Pass\\n input_shape = (1, 1, 3, 5, 3)\\n output_shape = (1, 1, 3, 5, 3)\\n size = (1, 3, 5)\\n got = layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n assert got.shape == output_shape\\n\\n # Check resize3d for proper image dimensions - Fail\\n input_shape = (1, 1)\\n size = (1, 1, 1)\\n with pytest.raises(ValueError) as execinfo:\\n layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n msg = \\\" \\\".join(execinfo.value.args[0].split())\\n assert \\\"resize3d takes input image of dimension 3 or 4 or 5\\\" in msg\\n\\n # Check resize3d for proper size - Fail\\n input_shape = (1, 1, 1)\\n size = (1, 1)\\n with pytest.raises(ValueError) as execinfo:\\n layer_util.resize3d(image=tf.ones(input_shape), size=size)\\n msg = \\\" \\\".join(execinfo.value.args[0].split())\\n assert \\\"resize3d takes size of type tuple/list and of length 3\\\" in msg\",\n \"def resizeAndRepubThread():\\n\\n # reference globals\\n global primaryCamString\\n global secondaryCamString\\n global armCamImage\\n global headCamImage\\n\\n # initialize image publishers\\n primaryPub = rospy.Publisher(primaryCamRepub, Image, queue_size=1)\\n secondaryPub = rospy.Publisher(secondaryCamRepub, Image, queue_size=1)\\n\\n # create CvBridge object for converting CV2 images to sensor_msgs/Image messages\\n backBridge = CvBridge()\\n\\n while(True):\\n primaryImage = np.zeros(shape=[512, 512, 3])\\n secondaryImage = np.zeros(shape=[512, 512, 3])\\n\\n # just keep looping until we get images\\n\\n if(np.sum(headCamImage) == 0 or np.sum(armCamImage) == 0):\\n rospy.loginfo(\\\"still waiting on camera images...\\\")\\n continue\\n\\n # get primary image\\n if(primaryCamString == \\\"head\\\"):\\n primaryImage = resizeImage(headCamImage, primarySize)\\n elif(primaryCamString == \\\"leftArm\\\"):\\n primaryImage = resizeImage(armCamImage, primarySize)\\n elif(primaryCamString == \\\"\\\"):\\n pass\\n else:\\n rospy.logerr(\\\"Invalid Option for primaryCamString recieved!\\\")\\n\\n # get secondary image\\n if(secondaryCamString == \\\"head\\\"):\\n secondaryImage = resizeImage(headCamImage, secondarySize)\\n elif(secondaryCamString == \\\"leftArm\\\"):\\n secondaryImage = resizeImage(armCamImage, secondarySize)\\n elif(secondaryCamString == \\\"\\\"):\\n pass\\n else:\\n rospy.logerr(\\\"Invalid Option for secondaryCamString recieved!\\\")\\n\\n # publish both new images\\n if(np.sum(primaryImage) != 0 and np.sum(secondaryImage) != 0):\\n primaryImageMessage = backBridge.cv2_to_imgmsg(primaryImage, \\\"bgr8\\\")\\n primaryPub.publish(primaryImageMessage)\\n\\n secondaryImageMessage = backBridge.cv2_to_imgmsg(secondaryImage, \\\"bgr8\\\")\\n secondaryPub.publish(secondaryImageMessage)\",\n \"def scale_image(img, factor=1):\\n\\treturn cv2.resize(img,(int(img.shape[1]*factor), int(img.shape[0]*factor)))\",\n \"def resize(self, new_size):\\n resized_img = opencv.resize(self.img, new_size)\\n return Image(resized_img)\",\n \"def resnet(num_blocks, classes=10, training=None):\\n\\n input_shape = (32, 32, 3)\\n img_input = layers.Input(shape=input_shape)\\n\\n if backend.image_data_format() == 'channels_first':\\n x = layers.Lambda(lambda x: backend.permute_dimensions(x, (0, 3, 1, 2)),\\n name='transpose')(img_input)\\n bn_axis = 1\\n else: # channel_last\\n x = img_input\\n bn_axis = 3\\n\\n x = tf.keras.layers.ZeroPadding2D(padding=(1, 1), name='conv1_pad')(x)\\n x = tf.keras.layers.Conv2D(16, (3, 3),\\n strides=(1, 1),\\n padding='valid',\\n kernel_initializer='he_normal',\\n kernel_regularizer=\\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\\n bias_regularizer=\\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\\n name='conv1')(x)\\n x = tf.keras.layers.BatchNormalization(axis=bn_axis, name='bn_conv1',\\n momentum=BATCH_NORM_DECAY,\\n epsilon=BATCH_NORM_EPSILON)(\\n x, training=training)\\n x = tf.keras.layers.Activation('relu')(x)\\n\\n x = resnet_block(x, size=num_blocks, kernel_size=3, filters=[16, 16],\\n stage=2, conv_strides=(1, 1), training=training)\\n\\n x = resnet_block(x, size=num_blocks, kernel_size=3, filters=[32, 32],\\n stage=3, conv_strides=(2, 2), training=training)\\n\\n x = resnet_block(x, size=num_blocks, kernel_size=3, filters=[64, 64],\\n stage=4, conv_strides=(2, 2), training=training)\\n\\n x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)\\n x = tf.keras.layers.Dense(classes, activation='softmax',\\n kernel_initializer='he_normal',\\n kernel_regularizer=\\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\\n bias_regularizer=\\n tf.keras.regularizers.l2(L2_WEIGHT_DECAY),\\n name='fc10')(x)\\n\\n inputs = img_input\\n # Create model.\\n model = tf.keras.models.Model(inputs, x, name='resnet56')\\n\\n return model\",\n \"def set_scale_factors_to_output_size(self):\\n # Compute the scale_factor using rounded scaled image size.\\n height = tf.shape(self._image)[0]\\n width = tf.shape(self._image)[1]\\n max_image_size = tf.to_float(tf.maximum(height, width))\\n image_scale = tf.to_float(self._output_size) / max_image_size\\n scaled_height = tf.to_int32(tf.to_float(height) * image_scale)\\n scaled_width = tf.to_int32(tf.to_float(width) * image_scale)\\n self._image_scale = image_scale\\n self._scaled_height = scaled_height\\n self._scaled_width = scaled_width\",\n \"def resize_image(image, bboxes=None, min_size=None, max_size=None):\\n image_shape = tf.to_float(tf.shape(image))\\n height = image_shape[0]\\n width = image_shape[1]\\n\\n if min_size is not None:\\n # We calculate the upscale factor, the rate we need to use to end up\\n # with an image with it's lowest dimension at least `image_min_size`.\\n # In case of being big enough the scale factor is 1. (no change)\\n min_size = tf.to_float(min_size)\\n min_dimension = tf.minimum(height, width)\\n upscale_factor = tf.maximum(min_size / min_dimension, 1.)\\n else:\\n upscale_factor = tf.constant(1.)\\n\\n if max_size is not None:\\n # We do the same calculating the downscale factor, to end up with an\\n # image where the biggest dimension is less than `image_max_size`.\\n # When the image is small enough the scale factor is 1. (no change)\\n max_size = tf.to_float(max_size)\\n max_dimension = tf.maximum(height, width)\\n downscale_factor = tf.minimum(max_size / max_dimension, 1.)\\n else:\\n downscale_factor = tf.constant(1.)\\n\\n scale_factor = upscale_factor * downscale_factor\\n\\n # New size is calculate using the scale factor and rounding to int.\\n new_height = height * scale_factor\\n new_width = width * scale_factor\\n\\n # Resize image using TensorFlow's own `resize_image` utility.\\n image = tf.image.resize_images(\\n image, tf.stack(tf.to_int32([new_height, new_width])),\\n method=tf.image.ResizeMethod.BILINEAR\\n )\\n\\n if bboxes is not None:\\n bboxes = adjust_bboxes(\\n bboxes,\\n old_height=height, old_width=width,\\n new_height=new_height, new_width=new_width\\n )\\n return {\\n 'image': image,\\n 'bboxes': bboxes,\\n 'scale_factor': scale_factor,\\n }\\n\\n return {\\n 'image': image,\\n 'scale_factor': scale_factor,\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66563886","0.66166437","0.6392838","0.6369865","0.63596517","0.63324946","0.6206985","0.6188757","0.6171561","0.6120761","0.60885406","0.60879236","0.6077981","0.607681","0.6075122","0.607204","0.6069862","0.6055661","0.6013288","0.6003485","0.6003485","0.5973104","0.5961235","0.59476364","0.5942752","0.59315866","0.5914289","0.58936983","0.58843327","0.5875295","0.5870673","0.5868392","0.5855706","0.5839727","0.5839319","0.58193254","0.58016104","0.5801002","0.57856727","0.5780806","0.5768361","0.57669","0.57650113","0.57596755","0.57510436","0.5738724","0.5730531","0.57202744","0.5682917","0.567833","0.56748295","0.56738955","0.56686044","0.56513584","0.56511956","0.56397027","0.56345505","0.56329507","0.5631616","0.5623698","0.56209385","0.56172305","0.5613306","0.5612534","0.5612231","0.5603728","0.5601594","0.55813766","0.557845","0.557726","0.55746686","0.5571788","0.55688846","0.5550673","0.55487645","0.5544633","0.55440605","0.55435014","0.55421436","0.5539745","0.55368644","0.5535744","0.5522496","0.55175495","0.55157","0.55155134","0.5506034","0.5505329","0.5504585","0.5504289","0.5500027","0.5492621","0.54905987","0.54796886","0.54774535","0.5471897","0.546556","0.5464765","0.5463945","0.5457812","0.5450512"],"string":"[\n \"0.66563886\",\n \"0.66166437\",\n \"0.6392838\",\n \"0.6369865\",\n \"0.63596517\",\n \"0.63324946\",\n \"0.6206985\",\n \"0.6188757\",\n \"0.6171561\",\n \"0.6120761\",\n \"0.60885406\",\n \"0.60879236\",\n \"0.6077981\",\n \"0.607681\",\n \"0.6075122\",\n \"0.607204\",\n \"0.6069862\",\n \"0.6055661\",\n \"0.6013288\",\n \"0.6003485\",\n \"0.6003485\",\n \"0.5973104\",\n \"0.5961235\",\n \"0.59476364\",\n \"0.5942752\",\n \"0.59315866\",\n \"0.5914289\",\n \"0.58936983\",\n \"0.58843327\",\n \"0.5875295\",\n \"0.5870673\",\n \"0.5868392\",\n \"0.5855706\",\n \"0.5839727\",\n \"0.5839319\",\n \"0.58193254\",\n \"0.58016104\",\n \"0.5801002\",\n \"0.57856727\",\n \"0.5780806\",\n \"0.5768361\",\n \"0.57669\",\n \"0.57650113\",\n \"0.57596755\",\n \"0.57510436\",\n \"0.5738724\",\n \"0.5730531\",\n \"0.57202744\",\n \"0.5682917\",\n \"0.567833\",\n \"0.56748295\",\n \"0.56738955\",\n \"0.56686044\",\n \"0.56513584\",\n \"0.56511956\",\n \"0.56397027\",\n \"0.56345505\",\n \"0.56329507\",\n \"0.5631616\",\n \"0.5623698\",\n \"0.56209385\",\n \"0.56172305\",\n \"0.5613306\",\n \"0.5612534\",\n \"0.5612231\",\n \"0.5603728\",\n \"0.5601594\",\n \"0.55813766\",\n \"0.557845\",\n \"0.557726\",\n \"0.55746686\",\n \"0.5571788\",\n \"0.55688846\",\n \"0.5550673\",\n \"0.55487645\",\n \"0.5544633\",\n \"0.55440605\",\n \"0.55435014\",\n \"0.55421436\",\n \"0.5539745\",\n \"0.55368644\",\n \"0.5535744\",\n \"0.5522496\",\n \"0.55175495\",\n \"0.55157\",\n \"0.55155134\",\n \"0.5506034\",\n \"0.5505329\",\n \"0.5504585\",\n \"0.5504289\",\n \"0.5500027\",\n \"0.5492621\",\n \"0.54905987\",\n \"0.54796886\",\n \"0.54774535\",\n \"0.5471897\",\n \"0.546556\",\n \"0.5464765\",\n \"0.5463945\",\n \"0.5457812\",\n \"0.5450512\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88998,"cells":{"query":{"kind":"string","value":"mask outofrange pixel to zero"},"document":{"kind":"string","value":"def mask_depth_image(depth_image, min_depth, max_depth):\n # print ('mask min max', min_depth, max_depth)\n ret, depth_image = cv2.threshold(depth_image, min_depth, 100000, cv2.THRESH_TOZERO)\n ret, depth_image = cv2.threshold(depth_image, max_depth, 100000, cv2.THRESH_TOZERO_INV)\n depth_image = np.expand_dims(depth_image, 2)\n return depth_image"},"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 Mask(self) -> int:","def mask(self):","def applymask(self,mask):\n self.spec[mask==0]=np.nan","def pixel2mask(image: np.ndarray, low: float, high: float) -> np.ndarray:\n mask = image > low\n labels = smeasure.label(mask, background=0)\n for region in smeasure.regionprops(label_image=labels, intensity_image=image):\n if region.max_intensity < high:\n mask[region.coords[:, 0], region.coords[:, 1]] = 0\n\n return mask","def mask_image(image):\n pass","def ignore_and_range(MAT, k=-9999.0):\n MAT[MAT==k]=0\n MAT = ((MAT-(MAT.min()))) / (MAT.max() - MAT.min())\n MAT *= 255\n \n return MAT","def mask_region(self, ypos, xpos, r):\r\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\r\n if (j - ypos) ** 2 + (i - xpos) ** 2 <= r ** 2 and 0 <= j<= self.shapes[0] - 1 and 0<= i <=self.shapes[1] - 1:\r\n j = int(j)\r\n i = int(i)\r\n self.masked[j, i] = 0","def get_binary_mask(self,index):\n mask = self.load_mask_png(index)\n (rows,cols) = np.where(mask>0)[0:2] #pixels in mask disregarding the color\n new_mask = np.zeros(shape=mask.shape[0:2], dtype=np.uint8)\n new_mask[(rows,cols)] = 255\n return new_mask","def zero_one(im):\n m = im.min()\n im = (im - m) / (im.max() - m)\n return im","def mask(self):\n mask = np.zeros((self.height, self.width))\n pts = [\n np.array(anno).reshape(-1, 2).round().astype(int)\n for anno in self.segmentation\n ]\n mask = cv2.fillPoly(mask, pts, 1)\n return mask","def r_erosion(image,size,origin=-1):\n return cv2.erode(image.astype(uint8), brick(size))\n # return filters.minimum_filter(image,size,origin=0, mode='constant', cval=1)","def dynamic_masking(image):\n image = img_as_float(image)\n background = gaussian_filter(median_filter(image,3),1)\n image[background > threshold_otsu(background)/5.0] = 0.0\n \n return image","def unmold_mask(mask, bbox, image_shape):\n threshold = 0.5\n y1, x1, y2, x2 = bbox\n mask = scipy.misc.imresize(\n mask, (y2 - y1, x2 - x1), interp='bilinear').astype(np.float32) / 255.0\n mask = np.where(mask >= threshold, 1, 0).astype(np.uint8)\n\n # Put the mask in the right location.\n full_mask = np.zeros(image_shape[:2], dtype=np.uint8)\n full_mask[y1:y2, x1:x2] = mask\n return full_mask","def rb_erosion(image,size,origin=-1):\n return cv2.erode(image.astype(uint8), brick(size))\n # output = zeros(image.shape,'f')\n # filters.uniform_filter(image,size,output=output,origin=0, mode='constant', cval=1)\n # return array(output==1,'i')","def mask(self):\n\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\n\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\n\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\n\n cv2.floodFill(image=mask,\n mask=mask_with_border,\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\n newVal=constants.COLOR_WHITE_MONO)\n\n return mask","def preprocess_mask(y):\n y[y <= 255./2] = 0 # Needs to be in this order, otherwise 1 gets overwritten\n y[y > 255./2] = 1\n binary_mask = y.astype(np.uint8)\n\n return binary_mask","def _clip(image):\r\n return np.clip(image, 0, 255).astype(np.uint8)","def preprocess_mask(mask):\n # Project values interval on [0.0; 1.0]\n if mask.max() > 1:\n mask[mask <= 127.5] = 0.\n mask[mask > 127.5] = 1.\n else:\n mask[mask <= .5] = 0.\n mask[mask > .5] = 1.\n return mask","def mask_img(img, mask):\n masked_img = np.zeros(img.shape)\n masked_img[mask] = img[mask]\n return masked_img","def apply_mask(components):\n img = components[10]\n mask = components[11]\n if mask is not None:\n img[:, :, 0] = img[:, :, 0] * mask\n img[:, :, 1] = img[:, :, 1] * mask\n img[:, :, 2] = img[:, :, 2] * mask\n img[img == 0] = 128\n return components","def get_mask(total, begin, end):\n mask = np.zeros([total]).astype(np.float32)\n mask[begin:end] = 1\n return np.array(mask, dtype=np.bool)","def getMask(self):\r\n mask = np.array(self.array, dtype=np.float32)\r\n mask[mask == 0] = np.nan\r\n return mask","def mask(self):\n return np.ones((self.size, self.size))","def negative_unlifted(pixmap):\n negative = np.logical_not(pixmap).astype(int)\n color = max(pixmap.max(), 1)\n return [negative * color]","def unmold_mask(mask, bbox, image_shape):\n threshold = 0.5\n y1, x1, y2, x2 = bbox\n mask = resize(mask, (y2 - y1, x2 - x1))\n mask = np.where(mask >= threshold, 1, 0).astype(np.bool)\n\n # Put the mask in the right location.\n full_mask = np.zeros(image_shape[:2], dtype=np.bool)\n full_mask[y1:y2, x1:x2] = mask\n return full_mask","def filterNotInRange(frame, min, max, colorMode):\n\n tempFrame = cv2.cvtColor(frame, colorMode)\n\n mask = cv2.inRange(tempFrame, min, max)\n\n filtered_frame = cv2.bitwise_and(frame, frame, mask=mask)\n\n return filtered_frame","def fix_generate_mask(self):\r\n mask = np.zeros((self.width, self.height), np.uint8)\r\n size = int((self.width + self.height) * 0.01)\r\n if self.width < 32 or self.height < 32:\r\n raise Exception(\"Width and Height of mask must be at least 64!\")\r\n i = 0\r\n for _ in range(1, int(0.3 * self.width)):\r\n index_xline = random.sample(range(0, self.width), int(0.5 * self.width))\r\n x1 = index_xline[i]\r\n i += 1\r\n thickness = 1\r\n cv2.line(mask, (0, x1), (self.height - 1, x1), 1, thickness)\r\n\r\n return 1 - mask","def zero_blind_range(data):\n try:\n start_i = data['first_data_bin']\n except:\n start_i = 0\n data['data'][...,:start_i] = 0.0","def rg_erosion(image,size,origin=0):\n return cv2.erode(image, brick(size))\n # return filters.minimum_filter(image,size,origin=origin, mode='constant', cval=1)","def process_mask(self, image):\n image = np.array(image)\n image[image == 5] = 1 # set un-classified to undestroyed\n return Image.fromarray(image)","def set_transparent(img):\n assert img.shape[-1] == 4\n white_pix = np.all(img == [255, 255, 255, 255], axis=-1)\n # print(white_pix)\n img[white_pix, -1] = 0\n # return img","def sanitize_mask(orig_x, orig_y, mask):\n contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n\n # Draw contours:\n cv2.drawContours(mask, contours, 0, (0, 255, 0), 2)\n # Calculate image moments of the detected contour\n num_objects = (len(contours))\n #threshold\n threshold = 3\n\n center_list = []\n # print(num_objects)\n if num_objects > 1:\n for item in range(num_objects):\n M = cv2.moments(contours[item])\n try:\n center_x = round(M['m10'] / M['m00'])\n center_y = round(M['m01'] / M['m00'])\n center_list.append([center_y , center_x ])\n except:\n pass\n\n # initialize retmask\n retmask = mask\n if num_objects > 1:\n for x, y in center_list:\n if orig_x - threshold <= x <= orig_x + threshold and orig_y - threshold <= y <= orig_y + threshold:\n pass\n else:\n def dfs_removal(px , py, mask):\n R = len(mask)\n C = len(mask[0])\n if mask[px][py ] != 255: \n return\n mask[px][py] = 0\n if 0 <= px - 1 and mask[px - 1][py ] == 255: dfs_removal(px - 1 , py , mask)\n if px + 1 < R and mask[px + 1][py ] == 255: dfs_removal(px + 1 , py , mask)\n if 0 <= py - 1 and mask[px][py - 1] == 255: dfs_removal(px, py -1 , mask)\n if py + 1 < C and mask[px][py + 1] == 255: dfs_removal(px, py + 1 , mask)\n\n dfs_removal(x,y, mask)\n\n return retmask","def unsharp_mask(img, size=3):\n\n # apply the averaging filter\n avg = average(img, size)\n\n # subtract the average from the image, for a \"diference\" mask\n int_img = np.asarray(img, np.int)\n diff_mask = int_img - avg\n\n # Finally add the mask to the original image\n sharp = int_img + diff_mask\n\n return np.asarray(np.clip(sharp, 0, 255), dtype=np.uint8)","def zero_mask(self):\n accum = 0\n for i in range(self.data.itemsize):\n accum += (0x55 << (i << 3))\n return accum","def drizzle_mask(source, dest, output):\n if os.path.exists(output):\n os.system('rm %s' % output)\n coord_src = flatten_pixcoord(source)\n print \"Transforming coordinates...\"\n coord_dest = transform_pixcoord(source, dest)\n hdr_dest = pyfits.getheader(dest)\n mask_in = pyfits.getdata(source)\n mask_out = np.zeros((hdr_dest['naxis1'], hdr_dest['naxis2']))\n # Now this might take a lot of time... is there a more clever way?\n print \"Start looping all the pixels, might take a while...\"\n for i in range(coord_src.shape[0]):\n x0, y0 = coord_src[i]\n if mask_in[y0-1,x0-1] > 0:\n x1, y1 = coord_dest[i]\n mask_out[y1-1,x1-1] = 1\n # write output\n pyfits.append(output, data=mask_out, header=hdr_dest)","def isolate_burned_pixels(array, upper, lower):\n not_burned = numpy.logical_or(array <= lower,\n array >= upper)\n array[not_burned] = 0\n return array","def pos_mask(row: int, col: int) -> int:\n assert 0 <= row < 8\n assert 0 <= col < 8\n return 0x8000000000000000 >> col >> row * 8","def scan(self, mask):","def test_offcenter(self):\n actual = cm.ring_mask((5, 5), 1, 2, center=(2, 3))\n expected = np.array([[False, False, False, True, False],\n [False, False, True, False, True],\n [False, True, False, False, False],\n [False, False, True, False, True],\n [False, False, False, True, False]])\n self.assertIsNone(np.testing.assert_array_equal(actual, expected))","def __mask(input, mask):\n return cv2.bitwise_and(input, input, mask=mask)","def mask_annular(m, bound):\n rmin, rmax, cmin, cmax = bound\n m[:rmin,:] = True\n m[rmax:,:] = True\n m[:,:cmin] = True\n m[:,cmax:] = True\n return m","def _masked_edge(var,xac):\n\n if np.any(xac>0):\n ind_gap = (xac==np.nanmin(xac[xac>0]))\n if ind_gap.size==var.size:\n if ind_gap.shape!=var.shape:\n ind_gap = ind_gap.transpose()\n var[ind_gap] = np.nan\n elif ind_gap.size==var.shape[1]:\n var[:,ind_gap] = np.nan\n if np.any(xac<0):\n ind_gap = (xac==np.nanmax(xac[xac<0]))\n if ind_gap.size==var.size:\n if ind_gap.shape!=var.shape:\n ind_gap = ind_gap.transpose()\n var[ind_gap] = np.nan\n elif ind_gap.size==var.shape[1]:\n var[:,ind_gap] = np.nan\n\n return var","def reset_mask(self):\n\n self.mask = np.ones(self.dispersion.shape, dtype=bool)","def negative(img): \n for pixel in img:\n x, y, col = pixel \n r, g, b = col\n \n new_color = create_color(255 - r, 255 - g, 255 - b)\n set_color(img, x, y, new_color)","def get_none_zero_region(im, margin):\n input_shape = im.shape\n if(type(margin) is int ):\n margin = [margin]*len(input_shape)\n assert(len(input_shape) == len(margin))\n indxes = np.nonzero(im)\n idx_min = []\n idx_max = []\n for i in range(len(input_shape)):\n idx_min.append(indxes[i].min())\n idx_max.append(indxes[i].max())\n\n for i in range(len(input_shape)):\n idx_min[i] = max(idx_min[i] - margin[i], 0)\n idx_max[i] = min(idx_max[i] + margin[i], input_shape[i] - 1)\n return idx_min, idx_max","def setMask(self, mask):\n try:\n self.mask = mask\n self.inds = na.nonzero(self.mask.flat)[0]\n #print \"length of self.inds\",len(self.inds)\n #print self.inds\n self.dim = self.mask.shape[::-1]\n #print self.mask.shape\n return True\n except Exception as error:\n print(\"failed in setMask\", error)","def fill_blind_pores(im):\n holes = find_disconnected_voxels(im)\n im[holes] = False\n return im","def get_mask(data):\n # saturated CCD count\n saturation_adu = 63000\n\n mask_sat = (data[:, 20:-20] >= saturation_adu)\n\n mask_bad = np.zeros_like(data[:, 20:-20], dtype=np.int16)\n # currently no bad pixels in FOCES CCD\n\n mask = np.int16(mask_sat)*4 + np.int16(mask_bad)*2\n\n return mask","def crop_to_nonzero(arrayin, mask=None):\r\n\r\n if type(arrayin) == np.ndarray :\r\n array = arrayin\r\n elif type(arrayin) == list :\r\n array = arrayin[0]\r\n\r\n if mask==None :\r\n mask = array\r\n #most left point \r\n for i in range(mask.shape[1]):\r\n tot = np.sum(np.abs(mask[:,i]))\r\n if tot > 0.0 :\r\n break\r\n left = i\r\n #most right point \r\n for i in range(mask.shape[1]-1,-1,-1):\r\n tot = np.sum(np.abs(mask[:,i]))\r\n if tot > 0.0 :\r\n break\r\n right = i\r\n #most up point \r\n for i in range(mask.shape[0]):\r\n tot = np.sum(np.abs(mask[i,:]))\r\n if tot > 0.0 :\r\n break\r\n top = i\r\n #most down point\r\n for i in range(mask.shape[0]-1,-1,-1):\r\n tot = np.sum(np.abs(mask[i,:]))\r\n if tot > 0.0 :\r\n break\r\n bottom = i\r\n if type(arrayin) == np.ndarray :\r\n arrayout = array[top:bottom+1,left:right+1]\r\n elif type(arrayin) == list :\r\n arrayout = []\r\n for i in arrayin :\r\n arrayout.append(i[top:bottom+1,left:right+1])\r\n return arrayout","def sentinel2_(image):\n nubes = image.select(\"QA60\")\n opaque = tools.compute_bits_client(nubes, 10, 10, \"opaque\")\n cirrus = tools.compute_bits_client(nubes, 11, 11, \"cirrus\")\n mask = opaque.Or(cirrus)\n result = image.updateMask(mask.Not())\n return result","def normalization_mask(img, mask):\n zone1 = img[mask != 0]\n zone2 = img[mask == 0]\n zone1 = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\n zone2 = (zone2 - zone2.min()) / (zone2.max() - zone2.min())\n imge = img.copy()\n imge[mask != 0] = zone1\n imge[mask == 0] = zone2\n return imge","def fill_off(self, start=0, end=0):\n self.fill_rgb(0, 0, 0, start, end)","def remove_border_vals(img, x: torch.Tensor, y: torch.Tensor, c: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: \r\n\r\n new_x = img.shape[3] - 8\r\n new_y = img.shape[2] - 8\r\n \r\n mask = x.ge(8) & x.le(new_x) & y.ge(8) & y.le(new_y)\r\n x = torch.masked_select(x, mask)\r\n y = torch.masked_select(y, mask)\r\n c = torch.masked_select(c, mask)\r\n\r\n return x, y, c","def get_sample_mask(self):","def _generate_mask(self):\r\n mask = np.zeros((self.width, self.height), np.uint8)\r\n size = int((self.width + self.height) * 0.01)\r\n if self.width < 32 or self.height < 32:\r\n raise Exception(\"Width and Height of mask must be at least 64!\")\r\n for _ in range(randint(1,int(0.5*self.width))):\r\n x1 = randint(0, self.width-1)\r\n thickness = 1\r\n cv2.line(mask, (0, x1),(self.height-1, x1), 1, thickness)\r\n return 1 - mask","def zero_to_nodata(base_raster):\n target_raster = base_raster.copy()\n target_raster[target_raster == 0] = _IC_NODATA\n return target_raster","def mask_incoherent(self):\n self.MaskPrefix = 'i' + self.MaskPrefix\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\n for ig in self.Set:\n igram = self.load_ma(ig)\n mskFile = ig.Path[:-3] + 'msk'\n coherence = roipy.tools.load_half(ig, 2, mskFile)\n incoherent = ma.masked_less(coherence, self.Cothresh)\n igram[incoherent.mask] = ma.masked\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\n print(mskFile)\n\n print('Done')","def _mask(self, map_):\n return None","def setNoZeroColor():\n dislin.nobgd()","def mask(n):\n if n >= 0:\n return 2**n - 1\n else:\n return 0","def mask(n):\n if n >= 0:\n return 2**n - 1\n else:\n return 0","def mask_stump(img, mask=None, mask_only=True):\n if img.ndim < 3:\n print('better to pass the raw image')\n channel = img\n else:\n channel = img[...,0]\n\n C = channel.copy()\n\n if mask is not None:\n C[mask] = 0\n elif ma.is_masked(img):\n C[img.mask] = 0\n mask = img.mask\n else:\n mask = np.zeros(img.shape, np.bool)\n\n thresh = (170/255)*C.max()\n b = ndi.white_tophat(C > thresh, 90)\n b = remove_small_objects(b, 1000)\n #b = convex_hull_object(b)\n b[mask] = 0\n\n # sort by size of object (largest first)\n\n# incl_count = 0 #objects used\n# mags = sorted(list(range(1,n_labs+1)), key=lambda lb: np.sum(labs==lb),\n# reverse=True)\n# print(mags)\n# for l in mags:\n# # big things get weird\n# if np.sum(b==l) > 5000:\n# print('skipping very large object')\n# # get rid of it, whatever\n# plt.imshow(b==l)\n# b[b==l] = 0\n# else:\n# incl_count += 1\n#\n# if incl_count > 4:\n# print('only removing a few things here')\n# b[b==l] = 0\n#\n# print('b after')\n# plt.imshow(b)\n# b = ndi.binary_dilation(b, disk(15))\n#\n if mask_only:\n return b\n\n else:\n # will add to existing mask\n return ma.masked_array(img, mask=b)","def color_thresh(orig_img, thresh_img):\n new_img = orig_img\n\n for i in range(orig_img.shape[0]):\n for j in range(orig_img.shape[1]):\n if thresh_img[i,j] == 255:\n new_img[i,j] = 0\n\n return new_img","def apply_mask(im, mask, color=(1, 0, 0)):\n masked = np.zeros(im.shape)\n for x, y in mask: masked[x][y] = color\n return masked","def removeScale(self, img, _lower =[0,0,0], _upper=[127,127,127]):\n lower = np.array(_lower)\n upper = np.array(_upper)\n mask = cv2.inRange(img, lower, upper)\n res = cv2.bitwise_and(img, img, mask= mask)\n return res","def ice_unmasked(res='4x5', debug=False):\n # Create a np.ma mask\n m = np.logical_not((land_unmasked(res)*ocean_unmasked(res)))\n if debug:\n print((mask, mask.shape))\n return m","def __generate_mask(self):\n mask = np.concatenate([np.ones(len(self.fixed[0])),\n np.zeros(self.num_points),\n np.ones(len(self.fixed[1]))])\n return mask","def _mask(self):\n if self.__mask is None:\n # need this to be *exactly* the numpy boolean False\n return nomask\n return self.__mask","def clean_mask(mask, background=0):\n kernels = [\n np.array([[ 1, -1, -1], [-1, 1, -1], [-1, -1, -1]]), # top left standalone pixel\n np.array([[-1, -1, 1], [-1, 1, -1], [-1, -1, -1]]), # top right standalone pixel\n np.array([[-1, -1, -1], [-1, 1, -1], [ 1, -1, -1]]), # bottom left standalone pixel\n np.array([[-1, -1, -1], [-1, 1, -1], [-1, -1, 1]]) # bottom right standalone pixel\n ]\n\n proc_masks = [cv2.morphologyEx(mask, cv2.MORPH_HITMISS, kernel).astype(np.bool) for kernel in kernels]\n\n for proc_mask in proc_masks:\n mask[proc_mask] = background\n return mask","def attention_mask(x):\n mask = torch.zeros(len(x), len(x[0]))\n for i in range(len(x)):\n try:\n index = np.where(x[i]==1)[0][0]\n mask[i][index:] = -np.inf\n except:\n pass\n return mask","def _get_mask(self, anno, idx):\n coco = self.coco\n img_info = coco.loadImgs(self.img_ids[idx])[0]\n\n m = np.zeros((img_info['height'], img_info['width']), dtype=np.float32)\n\n for obj in anno:\n if 'segmentation' in obj:\n if obj['iscrowd']:\n rle = pycocotools.mask.frPyObjects(obj['segmentation'],\n img_info['height'],\n img_info['width'])\n m += pycocotools.mask.decode(rle)\n elif obj['num_keypoints'] == 0:\n rles = pycocotools.mask.frPyObjects(obj['segmentation'],\n img_info['height'],\n img_info['width'])\n for rle in rles:\n m += pycocotools.mask.decode(rle)\n\n return m < 0.5","def get_mask(self, img):\n raise NotImplementedError()","def createmask(imagename,thres,outmask):\n os.system(\"rm -rf \" + outmask)\n immath(imagename = imagename,\n mode = \"evalexpr\",\n expr = \"iif(IM0 >= \" + str(thres) + \", 1.0, 0.0)\",\n outfile = outmask)\n imhead(imagename = outmask,\n mode = \"del\",\n hdkey = \"beammajor\")","def threshold_mask(image, threshold):\n image = image.copy()\n if threshold == None:\n threshold = skimage.filters.threshold_isodata(image)\n image[image > threshold] = 255\n image[image <= threshold] = 0\n return image","def cfmask_to_mask(raster):\r\n mask = raster.ReadAsArray()\r\n # A value of 0 is clear of clouds/water. Make all other values = 1.\r\n mask[mask != 0] = 1\r\n\r\n # That's it, just return the result...\r\n return mask","def shrink_mask(self):\n m = self._mask\n if m.ndim and not m.any():\n self._mask = nomask\n return self","def aerosols(self, mask: Mask):\n raise NotImplementedError(\"Subclass must implement\")","def calcmask(self, *args, **kwargs):\n return _image.image_calcmask(self, *args, **kwargs)","def _reset_mask(self, reset_to=False):\n self.data.mask = reset_to","def generate_mask(self, thresh=50, b_ground=None):\n img = self.load_image()\n thresh = np.zeros(img.shape, \"uint8\")\n if b_ground is not None:\n img = img - b_ground\n thresh[img > 25] = 255\n mask = ndimage.morphology.binary_dilation(thresh).astype(\"uint8\")\n self.mask = 255*mask","def _occlude_image(im, cR, cC, size_patch, stride):\n im[cR:cR + stride, cC:cC + stride, :] = 127.5\n occ_map = np.ones((im_target_size, im_target_size))\n occ_map[cR:cR + stride, cC:cC + stride] = 0\n return im, occ_map","def generate_inpaint_mask(n_samples, n_colors, spatial_width):\n mask = np.zeros((n_samples, n_colors, spatial_width, spatial_width), dtype=bool)\n # simple mask -- just mask out half the image\n mask[:,:,:,spatial_width/2:] = True\n return mask.ravel()","def flag_absolute(data):\n data.mask = np.logical_or(data.mask, data > params.thr_max)\n data.mask = np.logical_or(data.mask, data < params.thr_min)\n return data.mask","def vis_mask(img, mask, col, alpha=0.4):\n\n img = img.astype(np.float32)\n idx = np.nonzero(mask)\n\n img[idx[0], idx[1], :] *= 1.0 - alpha\n img[idx[0], idx[1], :] += alpha * col\n\n return img.astype(np.uint8)","def get_no_cloud_mask(twc_col_p, wow, _buffer=3):\n # set range limits for a one second measurement\n # interval (=64 single measurements)\n rng_limits = (1E-12, 0.1)\n mask = np.zeros(twc_col_p.shape[0], dtype=np.int8)\n\n rng = np.max(twc_col_p, axis=1)-np.min(twc_col_p, axis=1)\n mask[(rng > rng_limits[0]) &\n (rng < rng_limits[1]) &\n np.max(wow == 0, axis=1)] = 1\n # add two second time buffer, so that all data two seconds before\n # and after the estimated mask are also flagged as in cloud\n ix = np.where(mask == 0)[0]\n for i in range(_buffer*-1, _buffer+1):\n ix = list(set(list(np.concatenate((np.array(ix), np.array(ix)+i)))))\n # make sure that the indices do not exceed array dimensions\n ix = np.clip(ix, 0, len(mask)-1)\n mask[ix] = 0\n return mask","def threshold_mask(mask, threshold=0.5):\n mask[np.where(mask >= threshold)] = 1.\n mask[np.where(mask < threshold)] = 0.\n return mask","def mask_sonar_image(img, display_results=False):\n lower_color_bounds = (40, 80, 0) # Filter out lower values (ie blue)\n upper_color_bounds = (230, 250, 255) # Filter out too high values\n mask = cv2.inRange(img, lower_color_bounds, upper_color_bounds)\n\n if display_results:\n cv2.imshow(\"mask\", mask)\n cv2.waitKey(0)\n\n return mask","def get_mask(self):\n\t\treturn pygame.mask.from_surface(self.img)","def maskByModel(self, model, sigma=3, pixel_start=30, pixel_end=-10):\n\t\tpixel = np.delete(np.arange(len(self.oriWave)),self.mask)[pixel_start: pixel_end]\n\t\tcustom_mask2 = pixel[np.where(np.abs(self.flux-model.flux) > sigma*np.std(self.flux-model.flux))]\n\t\tprint(custom_mask2)\n\t\tcustom_mask2 = np.append(custom_mask2, np.array(self.mask))\n\t\tcustom_mask2.sort()\n\t\tcustom_mask2 = custom_mask2.tolist()\n\t\tself.mask_custom(custom_mask2)","def bad_pixel_mask(self):\n from mkidpipeline.pipeline import PROBLEM_FLAGS # This must be here to prevent a circular import!\n return self.flagged(PROBLEM_FLAGS)","def mask_sparse(self, threshold=10):\n self.MaskPrefix = 's' + self.MaskPrefix\n print('Masking pixels that do not have at least {0} coherent values'.format(threshold))\n # each pixel assigned an integer corresponding to # of igrams where coherent\n # NOTE: save coverage map if it doesn't exist already\n coverage = self.get_coverage()\n sparse = ma.masked_less(coverage, threshold)\n for ig in self.Set:\n igram = self.load_ma(ig)\n igram[sparse.mask] = ma.masked\n self.save_ma(ig, igram)\n print('Done')","def shade_neighbours(x: int, y: int) -> None:\r\n if x > 0:\r\n safeboard[x-1, y] = 0\r\n if x < shape-1:\r\n safeboard[x+1, y] = 0\r\n if y > 0:\r\n safeboard[x, y-1] = 0\r\n if y < shape-1:\r\n safeboard[x, y+1] = 0\r\n safeboard[x, y] = 0","def get_regions_mask(self, input):","def get_masked_scene(orig, mask, local_context_size = 80, dilation=False):\n orig_scene = orig.copy()\n mask_scene = mask.copy()\n orig_scene_no_mask = orig.copy()\n \n mask_info = np.where(mask_scene == 0) \n min_x = max(min(mask_info[0]) - local_context_size, 0)\n max_x = max(mask_info[0]) + local_context_size\n min_y = max(min(mask_info[1]) - local_context_size, 0)\n max_y = max(mask_info[1]) + local_context_size\n \n orig_scene = orig_scene[min_x:max_x,min_y:max_y]\n orig_scene_no_mask = orig_scene_no_mask[min_x:max_x,min_y:max_y]\n mask_scene = mask_scene[min_x:max_x,min_y:max_y]\n \n dialation_mask = np.zeros(mask_scene.shape) + 255\n \n if dilation:\n dialation_mask = cv2.dilate(255-mask_scene, np.ones((local_context_size,local_context_size)))\n \n #implot(dialation_mask)\n #plt.imshow(dialation_mask, 'gray')\n \n for x in range(mask_scene.shape[0]):\n for y in range(mask_scene.shape[1]):\n if mask_scene[x, y] == 0:\n orig_scene[x, y, :] = 0\n orig_scene_no_mask[x,y,:] = 0\n if dilation:\n if dialation_mask[x,y] == 0:\n orig_scene[x, y, :] = 0\n \n return orig_scene, mask_scene, orig_scene_no_mask, dialation_mask","def image_erosion(filter_size=3, repeat=1):\n def img_op(image: np.ndarray,**kwargs):\n structure_shape = [1] * image.ndim\n structure_shape[0]=filter_size\n structure_shape[1] = filter_size\n for i in range(repeat):\n image =ndimage.morphology.grey_erosion(image,size=(filter_size,filter_size),structure=np.ones(tuple(structure_shape)))\n return clip(image,0,255)\n\n return img_op","def black(self, x):\n n = x.shape[0]\n count_arr = np.array([[0] * 28] * 28) # array to keep the count for all [i,j] coordinates\n # Base: i = j = 0, count_arr[i, j] = 0\n for i in range(1, n):\n for j in range(1, n):\n if x[i, j] > 0:\n count_arr[i, j] = count_arr[i, j - 1] + count_arr[i - 1, j] - count_arr[i - 1, j - 1] + 1\n else:\n count_arr[i, j] = count_arr[i, j - 1] + count_arr[i - 1, j] - count_arr[i - 1, j - 1]\n self.count_black = count_arr","def non_masked_indices(mask):\n\treturn np.nonzero(np.ravel(mask-1,order='C'))[0]","def mask_overlay(image, mask, color=(0, 1, 0)):\n mask = np.dstack((mask, mask, mask)) * np.array(color)\n weighted_sum = cv2.addWeighted(mask, 0.5, image, 0.5, 0.)\n img = image.copy()\n ind = mask[:, :, 1] > 0\n img[ind] = weighted_sum[ind] \n return img","def fill_region(image,mask,value=1):\n\tim = image.copy().ravel()\n\tif image.ndim > 2:\n\t\tim_h, im_w, im_ch = image.shape\n\telse:\n\t\tim_ch = 1\n\t\tim_h, im_w = self.image.shape\n\t# linear indices of masked pixels\n\tind = masked_indices(mask)\n\tfor i in ind:\n\t\tfor ch in range(im_ch):\n\t\t\tim.data[i*im_ch+ch] = value\n\treturn im.reshape(image.shape)","def _mask(self) -> np.ndarray:\n mask = np.ones(self.limits, dtype=bool)\n for ax, shape, limit in zip(\n range(1, len(self.limits)), self.shape, self.limits[1:]\n ):\n ax_mask = np.arange(limit) < np.expand_dims(shape, 1)\n new_shape = np.ones(len(self.limits), dtype=int)\n new_shape[0], new_shape[ax] = self.limits[0], limit\n mask = mask & ax_mask.reshape(*new_shape)\n return mask","def inflate_mask(mask):\n kernel = np.ones((12, 12), np.uint8)\n return cv2.dilate(mask, kernel, 1)"],"string":"[\n \"def Mask(self) -> int:\",\n \"def mask(self):\",\n \"def applymask(self,mask):\\n self.spec[mask==0]=np.nan\",\n \"def pixel2mask(image: np.ndarray, low: float, high: float) -> np.ndarray:\\n mask = image > low\\n labels = smeasure.label(mask, background=0)\\n for region in smeasure.regionprops(label_image=labels, intensity_image=image):\\n if region.max_intensity < high:\\n mask[region.coords[:, 0], region.coords[:, 1]] = 0\\n\\n return mask\",\n \"def mask_image(image):\\n pass\",\n \"def ignore_and_range(MAT, k=-9999.0):\\n MAT[MAT==k]=0\\n MAT = ((MAT-(MAT.min()))) / (MAT.max() - MAT.min())\\n MAT *= 255\\n \\n return MAT\",\n \"def mask_region(self, ypos, xpos, r):\\r\\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\\r\\n if (j - ypos) ** 2 + (i - xpos) ** 2 <= r ** 2 and 0 <= j<= self.shapes[0] - 1 and 0<= i <=self.shapes[1] - 1:\\r\\n j = int(j)\\r\\n i = int(i)\\r\\n self.masked[j, i] = 0\",\n \"def get_binary_mask(self,index):\\n mask = self.load_mask_png(index)\\n (rows,cols) = np.where(mask>0)[0:2] #pixels in mask disregarding the color\\n new_mask = np.zeros(shape=mask.shape[0:2], dtype=np.uint8)\\n new_mask[(rows,cols)] = 255\\n return new_mask\",\n \"def zero_one(im):\\n m = im.min()\\n im = (im - m) / (im.max() - m)\\n return im\",\n \"def mask(self):\\n mask = np.zeros((self.height, self.width))\\n pts = [\\n np.array(anno).reshape(-1, 2).round().astype(int)\\n for anno in self.segmentation\\n ]\\n mask = cv2.fillPoly(mask, pts, 1)\\n return mask\",\n \"def r_erosion(image,size,origin=-1):\\n return cv2.erode(image.astype(uint8), brick(size))\\n # return filters.minimum_filter(image,size,origin=0, mode='constant', cval=1)\",\n \"def dynamic_masking(image):\\n image = img_as_float(image)\\n background = gaussian_filter(median_filter(image,3),1)\\n image[background > threshold_otsu(background)/5.0] = 0.0\\n \\n return image\",\n \"def unmold_mask(mask, bbox, image_shape):\\n threshold = 0.5\\n y1, x1, y2, x2 = bbox\\n mask = scipy.misc.imresize(\\n mask, (y2 - y1, x2 - x1), interp='bilinear').astype(np.float32) / 255.0\\n mask = np.where(mask >= threshold, 1, 0).astype(np.uint8)\\n\\n # Put the mask in the right location.\\n full_mask = np.zeros(image_shape[:2], dtype=np.uint8)\\n full_mask[y1:y2, x1:x2] = mask\\n return full_mask\",\n \"def rb_erosion(image,size,origin=-1):\\n return cv2.erode(image.astype(uint8), brick(size))\\n # output = zeros(image.shape,'f')\\n # filters.uniform_filter(image,size,output=output,origin=0, mode='constant', cval=1)\\n # return array(output==1,'i')\",\n \"def mask(self):\\n\\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\\n\\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\\n\\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\\n\\n cv2.floodFill(image=mask,\\n mask=mask_with_border,\\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\\n newVal=constants.COLOR_WHITE_MONO)\\n\\n return mask\",\n \"def preprocess_mask(y):\\n y[y <= 255./2] = 0 # Needs to be in this order, otherwise 1 gets overwritten\\n y[y > 255./2] = 1\\n binary_mask = y.astype(np.uint8)\\n\\n return binary_mask\",\n \"def _clip(image):\\r\\n return np.clip(image, 0, 255).astype(np.uint8)\",\n \"def preprocess_mask(mask):\\n # Project values interval on [0.0; 1.0]\\n if mask.max() > 1:\\n mask[mask <= 127.5] = 0.\\n mask[mask > 127.5] = 1.\\n else:\\n mask[mask <= .5] = 0.\\n mask[mask > .5] = 1.\\n return mask\",\n \"def mask_img(img, mask):\\n masked_img = np.zeros(img.shape)\\n masked_img[mask] = img[mask]\\n return masked_img\",\n \"def apply_mask(components):\\n img = components[10]\\n mask = components[11]\\n if mask is not None:\\n img[:, :, 0] = img[:, :, 0] * mask\\n img[:, :, 1] = img[:, :, 1] * mask\\n img[:, :, 2] = img[:, :, 2] * mask\\n img[img == 0] = 128\\n return components\",\n \"def get_mask(total, begin, end):\\n mask = np.zeros([total]).astype(np.float32)\\n mask[begin:end] = 1\\n return np.array(mask, dtype=np.bool)\",\n \"def getMask(self):\\r\\n mask = np.array(self.array, dtype=np.float32)\\r\\n mask[mask == 0] = np.nan\\r\\n return mask\",\n \"def mask(self):\\n return np.ones((self.size, self.size))\",\n \"def negative_unlifted(pixmap):\\n negative = np.logical_not(pixmap).astype(int)\\n color = max(pixmap.max(), 1)\\n return [negative * color]\",\n \"def unmold_mask(mask, bbox, image_shape):\\n threshold = 0.5\\n y1, x1, y2, x2 = bbox\\n mask = resize(mask, (y2 - y1, x2 - x1))\\n mask = np.where(mask >= threshold, 1, 0).astype(np.bool)\\n\\n # Put the mask in the right location.\\n full_mask = np.zeros(image_shape[:2], dtype=np.bool)\\n full_mask[y1:y2, x1:x2] = mask\\n return full_mask\",\n \"def filterNotInRange(frame, min, max, colorMode):\\n\\n tempFrame = cv2.cvtColor(frame, colorMode)\\n\\n mask = cv2.inRange(tempFrame, min, max)\\n\\n filtered_frame = cv2.bitwise_and(frame, frame, mask=mask)\\n\\n return filtered_frame\",\n \"def fix_generate_mask(self):\\r\\n mask = np.zeros((self.width, self.height), np.uint8)\\r\\n size = int((self.width + self.height) * 0.01)\\r\\n if self.width < 32 or self.height < 32:\\r\\n raise Exception(\\\"Width and Height of mask must be at least 64!\\\")\\r\\n i = 0\\r\\n for _ in range(1, int(0.3 * self.width)):\\r\\n index_xline = random.sample(range(0, self.width), int(0.5 * self.width))\\r\\n x1 = index_xline[i]\\r\\n i += 1\\r\\n thickness = 1\\r\\n cv2.line(mask, (0, x1), (self.height - 1, x1), 1, thickness)\\r\\n\\r\\n return 1 - mask\",\n \"def zero_blind_range(data):\\n try:\\n start_i = data['first_data_bin']\\n except:\\n start_i = 0\\n data['data'][...,:start_i] = 0.0\",\n \"def rg_erosion(image,size,origin=0):\\n return cv2.erode(image, brick(size))\\n # return filters.minimum_filter(image,size,origin=origin, mode='constant', cval=1)\",\n \"def process_mask(self, image):\\n image = np.array(image)\\n image[image == 5] = 1 # set un-classified to undestroyed\\n return Image.fromarray(image)\",\n \"def set_transparent(img):\\n assert img.shape[-1] == 4\\n white_pix = np.all(img == [255, 255, 255, 255], axis=-1)\\n # print(white_pix)\\n img[white_pix, -1] = 0\\n # return img\",\n \"def sanitize_mask(orig_x, orig_y, mask):\\n contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\n\\n # Draw contours:\\n cv2.drawContours(mask, contours, 0, (0, 255, 0), 2)\\n # Calculate image moments of the detected contour\\n num_objects = (len(contours))\\n #threshold\\n threshold = 3\\n\\n center_list = []\\n # print(num_objects)\\n if num_objects > 1:\\n for item in range(num_objects):\\n M = cv2.moments(contours[item])\\n try:\\n center_x = round(M['m10'] / M['m00'])\\n center_y = round(M['m01'] / M['m00'])\\n center_list.append([center_y , center_x ])\\n except:\\n pass\\n\\n # initialize retmask\\n retmask = mask\\n if num_objects > 1:\\n for x, y in center_list:\\n if orig_x - threshold <= x <= orig_x + threshold and orig_y - threshold <= y <= orig_y + threshold:\\n pass\\n else:\\n def dfs_removal(px , py, mask):\\n R = len(mask)\\n C = len(mask[0])\\n if mask[px][py ] != 255: \\n return\\n mask[px][py] = 0\\n if 0 <= px - 1 and mask[px - 1][py ] == 255: dfs_removal(px - 1 , py , mask)\\n if px + 1 < R and mask[px + 1][py ] == 255: dfs_removal(px + 1 , py , mask)\\n if 0 <= py - 1 and mask[px][py - 1] == 255: dfs_removal(px, py -1 , mask)\\n if py + 1 < C and mask[px][py + 1] == 255: dfs_removal(px, py + 1 , mask)\\n\\n dfs_removal(x,y, mask)\\n\\n return retmask\",\n \"def unsharp_mask(img, size=3):\\n\\n # apply the averaging filter\\n avg = average(img, size)\\n\\n # subtract the average from the image, for a \\\"diference\\\" mask\\n int_img = np.asarray(img, np.int)\\n diff_mask = int_img - avg\\n\\n # Finally add the mask to the original image\\n sharp = int_img + diff_mask\\n\\n return np.asarray(np.clip(sharp, 0, 255), dtype=np.uint8)\",\n \"def zero_mask(self):\\n accum = 0\\n for i in range(self.data.itemsize):\\n accum += (0x55 << (i << 3))\\n return accum\",\n \"def drizzle_mask(source, dest, output):\\n if os.path.exists(output):\\n os.system('rm %s' % output)\\n coord_src = flatten_pixcoord(source)\\n print \\\"Transforming coordinates...\\\"\\n coord_dest = transform_pixcoord(source, dest)\\n hdr_dest = pyfits.getheader(dest)\\n mask_in = pyfits.getdata(source)\\n mask_out = np.zeros((hdr_dest['naxis1'], hdr_dest['naxis2']))\\n # Now this might take a lot of time... is there a more clever way?\\n print \\\"Start looping all the pixels, might take a while...\\\"\\n for i in range(coord_src.shape[0]):\\n x0, y0 = coord_src[i]\\n if mask_in[y0-1,x0-1] > 0:\\n x1, y1 = coord_dest[i]\\n mask_out[y1-1,x1-1] = 1\\n # write output\\n pyfits.append(output, data=mask_out, header=hdr_dest)\",\n \"def isolate_burned_pixels(array, upper, lower):\\n not_burned = numpy.logical_or(array <= lower,\\n array >= upper)\\n array[not_burned] = 0\\n return array\",\n \"def pos_mask(row: int, col: int) -> int:\\n assert 0 <= row < 8\\n assert 0 <= col < 8\\n return 0x8000000000000000 >> col >> row * 8\",\n \"def scan(self, mask):\",\n \"def test_offcenter(self):\\n actual = cm.ring_mask((5, 5), 1, 2, center=(2, 3))\\n expected = np.array([[False, False, False, True, False],\\n [False, False, True, False, True],\\n [False, True, False, False, False],\\n [False, False, True, False, True],\\n [False, False, False, True, False]])\\n self.assertIsNone(np.testing.assert_array_equal(actual, expected))\",\n \"def __mask(input, mask):\\n return cv2.bitwise_and(input, input, mask=mask)\",\n \"def mask_annular(m, bound):\\n rmin, rmax, cmin, cmax = bound\\n m[:rmin,:] = True\\n m[rmax:,:] = True\\n m[:,:cmin] = True\\n m[:,cmax:] = True\\n return m\",\n \"def _masked_edge(var,xac):\\n\\n if np.any(xac>0):\\n ind_gap = (xac==np.nanmin(xac[xac>0]))\\n if ind_gap.size==var.size:\\n if ind_gap.shape!=var.shape:\\n ind_gap = ind_gap.transpose()\\n var[ind_gap] = np.nan\\n elif ind_gap.size==var.shape[1]:\\n var[:,ind_gap] = np.nan\\n if np.any(xac<0):\\n ind_gap = (xac==np.nanmax(xac[xac<0]))\\n if ind_gap.size==var.size:\\n if ind_gap.shape!=var.shape:\\n ind_gap = ind_gap.transpose()\\n var[ind_gap] = np.nan\\n elif ind_gap.size==var.shape[1]:\\n var[:,ind_gap] = np.nan\\n\\n return var\",\n \"def reset_mask(self):\\n\\n self.mask = np.ones(self.dispersion.shape, dtype=bool)\",\n \"def negative(img): \\n for pixel in img:\\n x, y, col = pixel \\n r, g, b = col\\n \\n new_color = create_color(255 - r, 255 - g, 255 - b)\\n set_color(img, x, y, new_color)\",\n \"def get_none_zero_region(im, margin):\\n input_shape = im.shape\\n if(type(margin) is int ):\\n margin = [margin]*len(input_shape)\\n assert(len(input_shape) == len(margin))\\n indxes = np.nonzero(im)\\n idx_min = []\\n idx_max = []\\n for i in range(len(input_shape)):\\n idx_min.append(indxes[i].min())\\n idx_max.append(indxes[i].max())\\n\\n for i in range(len(input_shape)):\\n idx_min[i] = max(idx_min[i] - margin[i], 0)\\n idx_max[i] = min(idx_max[i] + margin[i], input_shape[i] - 1)\\n return idx_min, idx_max\",\n \"def setMask(self, mask):\\n try:\\n self.mask = mask\\n self.inds = na.nonzero(self.mask.flat)[0]\\n #print \\\"length of self.inds\\\",len(self.inds)\\n #print self.inds\\n self.dim = self.mask.shape[::-1]\\n #print self.mask.shape\\n return True\\n except Exception as error:\\n print(\\\"failed in setMask\\\", error)\",\n \"def fill_blind_pores(im):\\n holes = find_disconnected_voxels(im)\\n im[holes] = False\\n return im\",\n \"def get_mask(data):\\n # saturated CCD count\\n saturation_adu = 63000\\n\\n mask_sat = (data[:, 20:-20] >= saturation_adu)\\n\\n mask_bad = np.zeros_like(data[:, 20:-20], dtype=np.int16)\\n # currently no bad pixels in FOCES CCD\\n\\n mask = np.int16(mask_sat)*4 + np.int16(mask_bad)*2\\n\\n return mask\",\n \"def crop_to_nonzero(arrayin, mask=None):\\r\\n\\r\\n if type(arrayin) == np.ndarray :\\r\\n array = arrayin\\r\\n elif type(arrayin) == list :\\r\\n array = arrayin[0]\\r\\n\\r\\n if mask==None :\\r\\n mask = array\\r\\n #most left point \\r\\n for i in range(mask.shape[1]):\\r\\n tot = np.sum(np.abs(mask[:,i]))\\r\\n if tot > 0.0 :\\r\\n break\\r\\n left = i\\r\\n #most right point \\r\\n for i in range(mask.shape[1]-1,-1,-1):\\r\\n tot = np.sum(np.abs(mask[:,i]))\\r\\n if tot > 0.0 :\\r\\n break\\r\\n right = i\\r\\n #most up point \\r\\n for i in range(mask.shape[0]):\\r\\n tot = np.sum(np.abs(mask[i,:]))\\r\\n if tot > 0.0 :\\r\\n break\\r\\n top = i\\r\\n #most down point\\r\\n for i in range(mask.shape[0]-1,-1,-1):\\r\\n tot = np.sum(np.abs(mask[i,:]))\\r\\n if tot > 0.0 :\\r\\n break\\r\\n bottom = i\\r\\n if type(arrayin) == np.ndarray :\\r\\n arrayout = array[top:bottom+1,left:right+1]\\r\\n elif type(arrayin) == list :\\r\\n arrayout = []\\r\\n for i in arrayin :\\r\\n arrayout.append(i[top:bottom+1,left:right+1])\\r\\n return arrayout\",\n \"def sentinel2_(image):\\n nubes = image.select(\\\"QA60\\\")\\n opaque = tools.compute_bits_client(nubes, 10, 10, \\\"opaque\\\")\\n cirrus = tools.compute_bits_client(nubes, 11, 11, \\\"cirrus\\\")\\n mask = opaque.Or(cirrus)\\n result = image.updateMask(mask.Not())\\n return result\",\n \"def normalization_mask(img, mask):\\n zone1 = img[mask != 0]\\n zone2 = img[mask == 0]\\n zone1 = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\\n zone2 = (zone2 - zone2.min()) / (zone2.max() - zone2.min())\\n imge = img.copy()\\n imge[mask != 0] = zone1\\n imge[mask == 0] = zone2\\n return imge\",\n \"def fill_off(self, start=0, end=0):\\n self.fill_rgb(0, 0, 0, start, end)\",\n \"def remove_border_vals(img, x: torch.Tensor, y: torch.Tensor, c: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: \\r\\n\\r\\n new_x = img.shape[3] - 8\\r\\n new_y = img.shape[2] - 8\\r\\n \\r\\n mask = x.ge(8) & x.le(new_x) & y.ge(8) & y.le(new_y)\\r\\n x = torch.masked_select(x, mask)\\r\\n y = torch.masked_select(y, mask)\\r\\n c = torch.masked_select(c, mask)\\r\\n\\r\\n return x, y, c\",\n \"def get_sample_mask(self):\",\n \"def _generate_mask(self):\\r\\n mask = np.zeros((self.width, self.height), np.uint8)\\r\\n size = int((self.width + self.height) * 0.01)\\r\\n if self.width < 32 or self.height < 32:\\r\\n raise Exception(\\\"Width and Height of mask must be at least 64!\\\")\\r\\n for _ in range(randint(1,int(0.5*self.width))):\\r\\n x1 = randint(0, self.width-1)\\r\\n thickness = 1\\r\\n cv2.line(mask, (0, x1),(self.height-1, x1), 1, thickness)\\r\\n return 1 - mask\",\n \"def zero_to_nodata(base_raster):\\n target_raster = base_raster.copy()\\n target_raster[target_raster == 0] = _IC_NODATA\\n return target_raster\",\n \"def mask_incoherent(self):\\n self.MaskPrefix = 'i' + self.MaskPrefix\\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n mskFile = ig.Path[:-3] + 'msk'\\n coherence = roipy.tools.load_half(ig, 2, mskFile)\\n incoherent = ma.masked_less(coherence, self.Cothresh)\\n igram[incoherent.mask] = ma.masked\\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\\n print(mskFile)\\n\\n print('Done')\",\n \"def _mask(self, map_):\\n return None\",\n \"def setNoZeroColor():\\n dislin.nobgd()\",\n \"def mask(n):\\n if n >= 0:\\n return 2**n - 1\\n else:\\n return 0\",\n \"def mask(n):\\n if n >= 0:\\n return 2**n - 1\\n else:\\n return 0\",\n \"def mask_stump(img, mask=None, mask_only=True):\\n if img.ndim < 3:\\n print('better to pass the raw image')\\n channel = img\\n else:\\n channel = img[...,0]\\n\\n C = channel.copy()\\n\\n if mask is not None:\\n C[mask] = 0\\n elif ma.is_masked(img):\\n C[img.mask] = 0\\n mask = img.mask\\n else:\\n mask = np.zeros(img.shape, np.bool)\\n\\n thresh = (170/255)*C.max()\\n b = ndi.white_tophat(C > thresh, 90)\\n b = remove_small_objects(b, 1000)\\n #b = convex_hull_object(b)\\n b[mask] = 0\\n\\n # sort by size of object (largest first)\\n\\n# incl_count = 0 #objects used\\n# mags = sorted(list(range(1,n_labs+1)), key=lambda lb: np.sum(labs==lb),\\n# reverse=True)\\n# print(mags)\\n# for l in mags:\\n# # big things get weird\\n# if np.sum(b==l) > 5000:\\n# print('skipping very large object')\\n# # get rid of it, whatever\\n# plt.imshow(b==l)\\n# b[b==l] = 0\\n# else:\\n# incl_count += 1\\n#\\n# if incl_count > 4:\\n# print('only removing a few things here')\\n# b[b==l] = 0\\n#\\n# print('b after')\\n# plt.imshow(b)\\n# b = ndi.binary_dilation(b, disk(15))\\n#\\n if mask_only:\\n return b\\n\\n else:\\n # will add to existing mask\\n return ma.masked_array(img, mask=b)\",\n \"def color_thresh(orig_img, thresh_img):\\n new_img = orig_img\\n\\n for i in range(orig_img.shape[0]):\\n for j in range(orig_img.shape[1]):\\n if thresh_img[i,j] == 255:\\n new_img[i,j] = 0\\n\\n return new_img\",\n \"def apply_mask(im, mask, color=(1, 0, 0)):\\n masked = np.zeros(im.shape)\\n for x, y in mask: masked[x][y] = color\\n return masked\",\n \"def removeScale(self, img, _lower =[0,0,0], _upper=[127,127,127]):\\n lower = np.array(_lower)\\n upper = np.array(_upper)\\n mask = cv2.inRange(img, lower, upper)\\n res = cv2.bitwise_and(img, img, mask= mask)\\n return res\",\n \"def ice_unmasked(res='4x5', debug=False):\\n # Create a np.ma mask\\n m = np.logical_not((land_unmasked(res)*ocean_unmasked(res)))\\n if debug:\\n print((mask, mask.shape))\\n return m\",\n \"def __generate_mask(self):\\n mask = np.concatenate([np.ones(len(self.fixed[0])),\\n np.zeros(self.num_points),\\n np.ones(len(self.fixed[1]))])\\n return mask\",\n \"def _mask(self):\\n if self.__mask is None:\\n # need this to be *exactly* the numpy boolean False\\n return nomask\\n return self.__mask\",\n \"def clean_mask(mask, background=0):\\n kernels = [\\n np.array([[ 1, -1, -1], [-1, 1, -1], [-1, -1, -1]]), # top left standalone pixel\\n np.array([[-1, -1, 1], [-1, 1, -1], [-1, -1, -1]]), # top right standalone pixel\\n np.array([[-1, -1, -1], [-1, 1, -1], [ 1, -1, -1]]), # bottom left standalone pixel\\n np.array([[-1, -1, -1], [-1, 1, -1], [-1, -1, 1]]) # bottom right standalone pixel\\n ]\\n\\n proc_masks = [cv2.morphologyEx(mask, cv2.MORPH_HITMISS, kernel).astype(np.bool) for kernel in kernels]\\n\\n for proc_mask in proc_masks:\\n mask[proc_mask] = background\\n return mask\",\n \"def attention_mask(x):\\n mask = torch.zeros(len(x), len(x[0]))\\n for i in range(len(x)):\\n try:\\n index = np.where(x[i]==1)[0][0]\\n mask[i][index:] = -np.inf\\n except:\\n pass\\n return mask\",\n \"def _get_mask(self, anno, idx):\\n coco = self.coco\\n img_info = coco.loadImgs(self.img_ids[idx])[0]\\n\\n m = np.zeros((img_info['height'], img_info['width']), dtype=np.float32)\\n\\n for obj in anno:\\n if 'segmentation' in obj:\\n if obj['iscrowd']:\\n rle = pycocotools.mask.frPyObjects(obj['segmentation'],\\n img_info['height'],\\n img_info['width'])\\n m += pycocotools.mask.decode(rle)\\n elif obj['num_keypoints'] == 0:\\n rles = pycocotools.mask.frPyObjects(obj['segmentation'],\\n img_info['height'],\\n img_info['width'])\\n for rle in rles:\\n m += pycocotools.mask.decode(rle)\\n\\n return m < 0.5\",\n \"def get_mask(self, img):\\n raise NotImplementedError()\",\n \"def createmask(imagename,thres,outmask):\\n os.system(\\\"rm -rf \\\" + outmask)\\n immath(imagename = imagename,\\n mode = \\\"evalexpr\\\",\\n expr = \\\"iif(IM0 >= \\\" + str(thres) + \\\", 1.0, 0.0)\\\",\\n outfile = outmask)\\n imhead(imagename = outmask,\\n mode = \\\"del\\\",\\n hdkey = \\\"beammajor\\\")\",\n \"def threshold_mask(image, threshold):\\n image = image.copy()\\n if threshold == None:\\n threshold = skimage.filters.threshold_isodata(image)\\n image[image > threshold] = 255\\n image[image <= threshold] = 0\\n return image\",\n \"def cfmask_to_mask(raster):\\r\\n mask = raster.ReadAsArray()\\r\\n # A value of 0 is clear of clouds/water. Make all other values = 1.\\r\\n mask[mask != 0] = 1\\r\\n\\r\\n # That's it, just return the result...\\r\\n return mask\",\n \"def shrink_mask(self):\\n m = self._mask\\n if m.ndim and not m.any():\\n self._mask = nomask\\n return self\",\n \"def aerosols(self, mask: Mask):\\n raise NotImplementedError(\\\"Subclass must implement\\\")\",\n \"def calcmask(self, *args, **kwargs):\\n return _image.image_calcmask(self, *args, **kwargs)\",\n \"def _reset_mask(self, reset_to=False):\\n self.data.mask = reset_to\",\n \"def generate_mask(self, thresh=50, b_ground=None):\\n img = self.load_image()\\n thresh = np.zeros(img.shape, \\\"uint8\\\")\\n if b_ground is not None:\\n img = img - b_ground\\n thresh[img > 25] = 255\\n mask = ndimage.morphology.binary_dilation(thresh).astype(\\\"uint8\\\")\\n self.mask = 255*mask\",\n \"def _occlude_image(im, cR, cC, size_patch, stride):\\n im[cR:cR + stride, cC:cC + stride, :] = 127.5\\n occ_map = np.ones((im_target_size, im_target_size))\\n occ_map[cR:cR + stride, cC:cC + stride] = 0\\n return im, occ_map\",\n \"def generate_inpaint_mask(n_samples, n_colors, spatial_width):\\n mask = np.zeros((n_samples, n_colors, spatial_width, spatial_width), dtype=bool)\\n # simple mask -- just mask out half the image\\n mask[:,:,:,spatial_width/2:] = True\\n return mask.ravel()\",\n \"def flag_absolute(data):\\n data.mask = np.logical_or(data.mask, data > params.thr_max)\\n data.mask = np.logical_or(data.mask, data < params.thr_min)\\n return data.mask\",\n \"def vis_mask(img, mask, col, alpha=0.4):\\n\\n img = img.astype(np.float32)\\n idx = np.nonzero(mask)\\n\\n img[idx[0], idx[1], :] *= 1.0 - alpha\\n img[idx[0], idx[1], :] += alpha * col\\n\\n return img.astype(np.uint8)\",\n \"def get_no_cloud_mask(twc_col_p, wow, _buffer=3):\\n # set range limits for a one second measurement\\n # interval (=64 single measurements)\\n rng_limits = (1E-12, 0.1)\\n mask = np.zeros(twc_col_p.shape[0], dtype=np.int8)\\n\\n rng = np.max(twc_col_p, axis=1)-np.min(twc_col_p, axis=1)\\n mask[(rng > rng_limits[0]) &\\n (rng < rng_limits[1]) &\\n np.max(wow == 0, axis=1)] = 1\\n # add two second time buffer, so that all data two seconds before\\n # and after the estimated mask are also flagged as in cloud\\n ix = np.where(mask == 0)[0]\\n for i in range(_buffer*-1, _buffer+1):\\n ix = list(set(list(np.concatenate((np.array(ix), np.array(ix)+i)))))\\n # make sure that the indices do not exceed array dimensions\\n ix = np.clip(ix, 0, len(mask)-1)\\n mask[ix] = 0\\n return mask\",\n \"def threshold_mask(mask, threshold=0.5):\\n mask[np.where(mask >= threshold)] = 1.\\n mask[np.where(mask < threshold)] = 0.\\n return mask\",\n \"def mask_sonar_image(img, display_results=False):\\n lower_color_bounds = (40, 80, 0) # Filter out lower values (ie blue)\\n upper_color_bounds = (230, 250, 255) # Filter out too high values\\n mask = cv2.inRange(img, lower_color_bounds, upper_color_bounds)\\n\\n if display_results:\\n cv2.imshow(\\\"mask\\\", mask)\\n cv2.waitKey(0)\\n\\n return mask\",\n \"def get_mask(self):\\n\\t\\treturn pygame.mask.from_surface(self.img)\",\n \"def maskByModel(self, model, sigma=3, pixel_start=30, pixel_end=-10):\\n\\t\\tpixel = np.delete(np.arange(len(self.oriWave)),self.mask)[pixel_start: pixel_end]\\n\\t\\tcustom_mask2 = pixel[np.where(np.abs(self.flux-model.flux) > sigma*np.std(self.flux-model.flux))]\\n\\t\\tprint(custom_mask2)\\n\\t\\tcustom_mask2 = np.append(custom_mask2, np.array(self.mask))\\n\\t\\tcustom_mask2.sort()\\n\\t\\tcustom_mask2 = custom_mask2.tolist()\\n\\t\\tself.mask_custom(custom_mask2)\",\n \"def bad_pixel_mask(self):\\n from mkidpipeline.pipeline import PROBLEM_FLAGS # This must be here to prevent a circular import!\\n return self.flagged(PROBLEM_FLAGS)\",\n \"def mask_sparse(self, threshold=10):\\n self.MaskPrefix = 's' + self.MaskPrefix\\n print('Masking pixels that do not have at least {0} coherent values'.format(threshold))\\n # each pixel assigned an integer corresponding to # of igrams where coherent\\n # NOTE: save coverage map if it doesn't exist already\\n coverage = self.get_coverage()\\n sparse = ma.masked_less(coverage, threshold)\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n igram[sparse.mask] = ma.masked\\n self.save_ma(ig, igram)\\n print('Done')\",\n \"def shade_neighbours(x: int, y: int) -> None:\\r\\n if x > 0:\\r\\n safeboard[x-1, y] = 0\\r\\n if x < shape-1:\\r\\n safeboard[x+1, y] = 0\\r\\n if y > 0:\\r\\n safeboard[x, y-1] = 0\\r\\n if y < shape-1:\\r\\n safeboard[x, y+1] = 0\\r\\n safeboard[x, y] = 0\",\n \"def get_regions_mask(self, input):\",\n \"def get_masked_scene(orig, mask, local_context_size = 80, dilation=False):\\n orig_scene = orig.copy()\\n mask_scene = mask.copy()\\n orig_scene_no_mask = orig.copy()\\n \\n mask_info = np.where(mask_scene == 0) \\n min_x = max(min(mask_info[0]) - local_context_size, 0)\\n max_x = max(mask_info[0]) + local_context_size\\n min_y = max(min(mask_info[1]) - local_context_size, 0)\\n max_y = max(mask_info[1]) + local_context_size\\n \\n orig_scene = orig_scene[min_x:max_x,min_y:max_y]\\n orig_scene_no_mask = orig_scene_no_mask[min_x:max_x,min_y:max_y]\\n mask_scene = mask_scene[min_x:max_x,min_y:max_y]\\n \\n dialation_mask = np.zeros(mask_scene.shape) + 255\\n \\n if dilation:\\n dialation_mask = cv2.dilate(255-mask_scene, np.ones((local_context_size,local_context_size)))\\n \\n #implot(dialation_mask)\\n #plt.imshow(dialation_mask, 'gray')\\n \\n for x in range(mask_scene.shape[0]):\\n for y in range(mask_scene.shape[1]):\\n if mask_scene[x, y] == 0:\\n orig_scene[x, y, :] = 0\\n orig_scene_no_mask[x,y,:] = 0\\n if dilation:\\n if dialation_mask[x,y] == 0:\\n orig_scene[x, y, :] = 0\\n \\n return orig_scene, mask_scene, orig_scene_no_mask, dialation_mask\",\n \"def image_erosion(filter_size=3, repeat=1):\\n def img_op(image: np.ndarray,**kwargs):\\n structure_shape = [1] * image.ndim\\n structure_shape[0]=filter_size\\n structure_shape[1] = filter_size\\n for i in range(repeat):\\n image =ndimage.morphology.grey_erosion(image,size=(filter_size,filter_size),structure=np.ones(tuple(structure_shape)))\\n return clip(image,0,255)\\n\\n return img_op\",\n \"def black(self, x):\\n n = x.shape[0]\\n count_arr = np.array([[0] * 28] * 28) # array to keep the count for all [i,j] coordinates\\n # Base: i = j = 0, count_arr[i, j] = 0\\n for i in range(1, n):\\n for j in range(1, n):\\n if x[i, j] > 0:\\n count_arr[i, j] = count_arr[i, j - 1] + count_arr[i - 1, j] - count_arr[i - 1, j - 1] + 1\\n else:\\n count_arr[i, j] = count_arr[i, j - 1] + count_arr[i - 1, j] - count_arr[i - 1, j - 1]\\n self.count_black = count_arr\",\n \"def non_masked_indices(mask):\\n\\treturn np.nonzero(np.ravel(mask-1,order='C'))[0]\",\n \"def mask_overlay(image, mask, color=(0, 1, 0)):\\n mask = np.dstack((mask, mask, mask)) * np.array(color)\\n weighted_sum = cv2.addWeighted(mask, 0.5, image, 0.5, 0.)\\n img = image.copy()\\n ind = mask[:, :, 1] > 0\\n img[ind] = weighted_sum[ind] \\n return img\",\n \"def fill_region(image,mask,value=1):\\n\\tim = image.copy().ravel()\\n\\tif image.ndim > 2:\\n\\t\\tim_h, im_w, im_ch = image.shape\\n\\telse:\\n\\t\\tim_ch = 1\\n\\t\\tim_h, im_w = self.image.shape\\n\\t# linear indices of masked pixels\\n\\tind = masked_indices(mask)\\n\\tfor i in ind:\\n\\t\\tfor ch in range(im_ch):\\n\\t\\t\\tim.data[i*im_ch+ch] = value\\n\\treturn im.reshape(image.shape)\",\n \"def _mask(self) -> np.ndarray:\\n mask = np.ones(self.limits, dtype=bool)\\n for ax, shape, limit in zip(\\n range(1, len(self.limits)), self.shape, self.limits[1:]\\n ):\\n ax_mask = np.arange(limit) < np.expand_dims(shape, 1)\\n new_shape = np.ones(len(self.limits), dtype=int)\\n new_shape[0], new_shape[ax] = self.limits[0], limit\\n mask = mask & ax_mask.reshape(*new_shape)\\n return mask\",\n \"def inflate_mask(mask):\\n kernel = np.ones((12, 12), np.uint8)\\n return cv2.dilate(mask, kernel, 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7277648","0.70975006","0.6916187","0.67861253","0.6672735","0.6455906","0.6452693","0.6435973","0.63348085","0.63294333","0.6324877","0.63084173","0.6267788","0.6267649","0.6242802","0.62425005","0.6238908","0.6234164","0.6233499","0.61704344","0.6160483","0.6139268","0.6135453","0.61161685","0.611305","0.60981333","0.6096857","0.6096296","0.60920537","0.60914624","0.6090724","0.60756534","0.6075101","0.606726","0.6066316","0.6062973","0.6028302","0.6024988","0.60146356","0.60083216","0.59988916","0.5977226","0.59753835","0.59751064","0.59662014","0.59606886","0.59587073","0.5949288","0.5934097","0.5933841","0.5930434","0.59272987","0.59268516","0.59143883","0.59142965","0.5905282","0.5904103","0.59029937","0.59005845","0.58998775","0.58998775","0.5899851","0.58992743","0.58988506","0.58770084","0.5857374","0.58478004","0.5842727","0.58403504","0.5835159","0.5833337","0.58254886","0.58232796","0.5818903","0.5807542","0.5803843","0.58024246","0.5789288","0.57884234","0.5787903","0.5783568","0.5781355","0.57780534","0.5775046","0.575316","0.5751599","0.5747408","0.5744451","0.5739213","0.5738492","0.5738319","0.5738188","0.57377356","0.57292724","0.57224303","0.5722021","0.5720718","0.5720341","0.57192296","0.5719082","0.57154596"],"string":"[\n \"0.7277648\",\n \"0.70975006\",\n \"0.6916187\",\n \"0.67861253\",\n \"0.6672735\",\n \"0.6455906\",\n \"0.6452693\",\n \"0.6435973\",\n \"0.63348085\",\n \"0.63294333\",\n \"0.6324877\",\n \"0.63084173\",\n \"0.6267788\",\n \"0.6267649\",\n \"0.6242802\",\n \"0.62425005\",\n \"0.6238908\",\n \"0.6234164\",\n \"0.6233499\",\n \"0.61704344\",\n \"0.6160483\",\n \"0.6139268\",\n \"0.6135453\",\n \"0.61161685\",\n \"0.611305\",\n \"0.60981333\",\n \"0.6096857\",\n \"0.6096296\",\n \"0.60920537\",\n \"0.60914624\",\n \"0.6090724\",\n \"0.60756534\",\n \"0.6075101\",\n \"0.606726\",\n \"0.6066316\",\n \"0.6062973\",\n \"0.6028302\",\n \"0.6024988\",\n \"0.60146356\",\n \"0.60083216\",\n \"0.59988916\",\n \"0.5977226\",\n \"0.59753835\",\n \"0.59751064\",\n \"0.59662014\",\n \"0.59606886\",\n \"0.59587073\",\n \"0.5949288\",\n \"0.5934097\",\n \"0.5933841\",\n \"0.5930434\",\n \"0.59272987\",\n \"0.59268516\",\n \"0.59143883\",\n \"0.59142965\",\n \"0.5905282\",\n \"0.5904103\",\n \"0.59029937\",\n \"0.59005845\",\n \"0.58998775\",\n \"0.58998775\",\n \"0.5899851\",\n \"0.58992743\",\n \"0.58988506\",\n \"0.58770084\",\n \"0.5857374\",\n \"0.58478004\",\n \"0.5842727\",\n \"0.58403504\",\n \"0.5835159\",\n \"0.5833337\",\n \"0.58254886\",\n \"0.58232796\",\n \"0.5818903\",\n \"0.5807542\",\n \"0.5803843\",\n \"0.58024246\",\n \"0.5789288\",\n \"0.57884234\",\n \"0.5787903\",\n \"0.5783568\",\n \"0.5781355\",\n \"0.57780534\",\n \"0.5775046\",\n \"0.575316\",\n \"0.5751599\",\n \"0.5747408\",\n \"0.5744451\",\n \"0.5739213\",\n \"0.5738492\",\n \"0.5738319\",\n \"0.5738188\",\n \"0.57377356\",\n \"0.57292724\",\n \"0.57224303\",\n \"0.5722021\",\n \"0.5720718\",\n \"0.5720341\",\n \"0.57192296\",\n \"0.5719082\",\n \"0.57154596\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88999,"cells":{"query":{"kind":"string","value":"read camera txt file"},"document":{"kind":"string","value":"def load_cam(file, interval_scale=1, max_d = None):\n cam = np.zeros((2, 4, 4))\n words = file.read().split()\n # read extrinsic\n for i in range(0, 4):\n for j in range(0, 4):\n extrinsic_index = 4 * i + j + 1\n cam[0][i][j] = words[extrinsic_index]\n\n # read intrinsic\n for i in range(0, 3):\n for j in range(0, 3):\n intrinsic_index = 3 * i + j + 18\n cam[1][i][j] = words[intrinsic_index]\n \n if len(words) == 29:\n cam[1][3][0] = words[27]\n cam[1][3][1] = float(words[28]) * interval_scale\n if max_d is None:\n cam[1][3][2] = FLAGS.max_d\n else:\n cam[1][3][2] = max_d\n cam[1][3][3] = cam[1][3][0] + cam[1][3][1] * cam[1][3][2]\n elif len(words) == 30:\n cam[1][3][0] = words[27]\n cam[1][3][1] = float(words[28]) * interval_scale\n cam[1][3][2] = words[29]\n cam[1][3][3] = cam[1][3][0] + cam[1][3][1] * cam[1][3][2]\n elif len(words) == 31:\n cam[1][3][0] = words[27]\n cam[1][3][1] = float(words[28]) * interval_scale\n cam[1][3][2] = words[29]\n cam[1][3][3] = words[30]\n else:\n cam[1][3][0] = 0\n cam[1][3][1] = 0\n cam[1][3][2] = 0\n cam[1][3][3] = 0\n return cam"},"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 cam_read(filename):\n f = open(filename,'rb')\n check = np.fromfile(f,dtype=np.float32,count=1)[0]\n assert check == TAG_FLOAT, ' cam_read:: Wrong tag in flow file (should be: {0}, is: {1}). Big-endian machine? '.format(TAG_FLOAT,check)\n M = np.fromfile(f,dtype='float64',count=9).reshape((3,3))\n N = np.fromfile(f,dtype='float64',count=12).reshape((3,4))\n return M,N","def readText(self, filename, firstLine = 0, lastLine = None):\n \n assert filename.endswith('.txt')\n file = open(filename, 'r')\n self.samples = []\n\n li = 0\n while li < firstLine:\n if not file.readline():\n return\n li += 1\n\n while lastLine == None or li < lastLine:\n line = file.readline()\n if not line:\n return\n li += 1\n line = line.strip()\n if line:\n columns = line.split('|')\n if columns[1] == 'client-fps':\n self.samples.append(Sample(line, columns))","def read_map_file(path):\r\n with open(path) as f:\r\n dir_name = os.path.dirname(path)\r\n img = cv2.imread(dir_name + '/' + f.readline().strip())\r\n assert img.shape[0] > 0 and img.shape[1] > 0, 'Can not open image file'\r\n meter_per_pixel = float(f.readline().strip())\r\n ori_str = f.readline().strip().split()\r\n origin = np.array([int(ori_str[0]), int(ori_str[1])])\r\n init_heading = float(ori_str[2])\r\n return img, meter_per_pixel, origin, init_heading","def _read_file(self):\n extension = self.path.split('.')[-1]\n if extension!='avi':\n raise Exception(\"Invalid Format\")\n\n return cv2.VideoCapture(self.path)","def read(cls):\n x_i=\"vas.txt\"\n with open(x_i, 'r')as txt_file:\n file = txt_file.read()\n return file","def load_camera_data(file_name):\n assert os.path.isfile(file_name), \"Invalid file {}\".format(file_name)\n import sintel_io\n\n intrinsic, extrinsic = sintel_io.cam_read(file_name)\n return intrinsic, extrinsic","def file_reader(filename = 'conv_params'):\n\n with open(filename) as f:\n info = f.readlines()\n info = [i.strip() for i in info] # each element in info is a string of a line from the file\n info = [i.split() for i in info] # split each whitespace delimited element into a list of lists\n info = [[i.split('-') for i in j] for j in info] # note info is 3 layers deep\n\n info[2] = info[2][0] # makes default E just a single string of the number\n info[3] = info[3][0]\n\n return info","def read_poses_for_camera(record_path, camera_name):\n\n # Resolve pose.txt file path for camera\n poses_path = os.path.join(record_path, camera_name, 'pose.txt')\n if os.path.exists(poses_path):\n poses = read_poses_dict(poses_path)\n else:\n # Sample type dataset (aka zpark-sample)\n poses_path = os.path.join(record_path, camera_name + '.txt')\n poses = read_poses_dict_6(poses_path)\n return poses","def read(self, filename):\n pass","def read(self, filename):\n pass","def read_text(filename):\n with open(filename, 'r') as f:\n com = f.readline()[0]\n wavelength, flux = np.loadtxt(filename, unpack=True,\n usecols=(0, 1), comments=com)\n return wavelength, flux","def read1(cls):\n x_i = \"vas.txt\"\n with open(x_i, 'r')as txt_file:\n file = txt_file.readlines()\n return file","def readtxt(obslog):\n\n logger = log.getLogger('obslog.readtxt')\n\n if not os.path.exists(obslog):\n logger.error('Cannot access %s', obslog)\n raise SystemExit\n\n logger.info('Reading %s', obslog)\n\n with open(obslog) as f: # Since we will have to go through the data twice, read the whole file at once.\n data = f.readlines()\n\n header = ['Observation ID', 'Data Labels', 'File Numbers', 'Dataset UT', 'Target Name', 'Filters', 'Slit',\n 'Grating/Wavelength', 'Camera/Prism', 'ExpTime/LNR/Coadds', 'ACQ']\n\n pattern = dict() # Enforce formatting rules to avoid parsing comments as data:\n pattern['Observation ID'] = re.compile(r'^G[NS]-[0-9]{4}[AB]-([CQ]|DD|FT|LP|SV)-[0-9]{0,3}-[0-9]+$')\n pattern['Data Labels'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\n pattern['File Numbers'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\n pattern['Dataset UT'] = re.compile(r'^[0-9]{2}:[0-9]{2}:[0-9]{2}$') # 09:58:15\n pattern['Target Name'] = re.compile(r'[a-zA-Z0-9_-]+') # Match any string\n pattern['Filters'] = re.compile(r'[A-Z0-9\\-]+') # H, XD, H2, X, J, H\n pattern['Slit'] = re.compile(r'[a-zA-Z0-9]+') # 0.675, ACQ, LgPin\n pattern['Grating/Wavelength'] = re.compile(r'[0-9]{2,3}/[0-9]\\.[0-9]{2}') # 32/1.65, 111/1.68\n pattern['Camera/Prism'] = re.compile(r'[A-Z]{2}/[A-Z]{3}') # LB/MIR, SB/SXD\n pattern['ExpTime/LNR/Coadds'] = re.compile(r'[0-9]+\\.[0-9]/[0-9]+/[0-9]+') # 0.2/1/25, 300.0/32/1\n pattern['ACQ'] = re.compile(r'^Y*$') # Y or ''\n\n indx = {}\n for line in data:\n if 'Electronic Observing Log' in line:\n date = line.split()[-1][7:]\n logger.debug('Log date: %s', date)\n if line[0:14] == 'Observation ID': # This defines the start of the header row\n for h in header:\n indx[h] = line.find(h) # Find where each column starts\n break # No need to go farther\n\n width = {} # Find the width of each row\n for i in range(len(header) - 1): # This requires that 'header' be an ordered array (not a dictionary)\n width[header[i]] = indx[header[i + 1]] - indx[header[i]]\n width[header[i+1]] = 1 # The ACQ field is either 'Y' or blank\n\n val = {}\n match = {}\n info = {}\n for line in data:\n logger.debug('\\n%s', line)\n files = []\n for h in header:\n val[h] = line[indx[h]: indx[h] + width[h]].strip()\n match[h] = re.match(pattern[h], val[h])\n logger.debug('%s: \"%s\" %s' % (h, val[h], match[h]))\n\n # Maybe throw a warning if only match 1 fails; indicating a likely bad pattern specification?\n\n if None in match.values():\n logger.debug('Failed to match all patterns -> This is a comment')\n continue\n\n if '-' in val['File Numbers']:\n start, stop = val['File Numbers'].split('-')\n for i in range(int(start), int(stop)+1):\n files.append(i)\n else:\n files.append(int(val['File Numbers']))\n\n for filenum in files:\n f = 'N%sS%04d.fits' % (date, filenum)\n logger.debug('File: %s', f)\n info[f] = {}\n for h in [header[0]] + header[3:]: # Skip 'Data Labels' and \"File Numbers'\n info[f][h] = val[h]\n\n logger.debug('info: %s', info)\n return info","def read_file(self,file_name):\r\n data = np.genfromtxt(file_name)\r\n return data;","def readogle(filename, **kw):\n \n # 2008-12-21 18:53 IJC: Created\n\n f = open(filename, 'r')\n raw = f.readlines()\n f.close()\n\n nstars = len(raw)\n\n raw2 = array([line.split() for line in raw])\n ra = raw2[:,1]\n dec = raw2[:,2]\n xref = raw2[:,3]\n yref = raw2[:,4]\n vmag = raw2[:,5]\n imag = raw2[:,7]\n \n xref = [map(float, [x]) for x in xref]\n yref = [map(float, [y]) for y in yref]\n vmag = [map(float, [v]) for v in vmag]\n imag = [map(float, [i]) for i in imag]\n\n return (ra, dec, xref, yref, vmag, imag)","def readImages(self):\r\n\r\n #Read the file camera.csv for the image file name\r\n lines = [line.strip() for line in open(self.cameraFile)]\r\n i = 0;\r\n\tself.centers = []\r\n\tself.lefts = []\r\n\tself.rights = []\r\n\r\n for line in lines:\r\n info = line.split(',')\r\n \r\n\r\n if info[0] == 'seq':\r\n i += 1\r\n continue\r\n \r\n if info[4] == 'left_camera':\r\n self.lefts.append(info)\r\n if info[4] == 'center_camera':\r\n self.centers.append(info)\r\n if info[4] == 'right_camera':\r\n self.rights.append(info)\r\n i += 1\r\n\r\n print \"Total Frames: %d \" % (len(self.centers))","def read(self, src):\n self.read_mesh(src)\n self.read_data(src)","def readViewerOutputFile(lines, debug=False):\n x = []; y = []\n pixel = ''\n xunits = 'unknown'\n intensityUnits = 'unknown'\n for line in lines:\n if (line[0] == '#'): \n if (line.find('pixel') > 0):\n pixel = line.split('[[')[1].split(']]')[0]\n elif (line.find('xLabel') > 0):\n xunits = line.split()[-1]\n if (debug):\n print \"Read xunits = \", xunits\n elif (line.find('yLabel') > 0):\n tokens = line.split()\n if (len(tokens) == 2):\n intensityUnits = tokens[1]\n else:\n intensityUnits = tokens[1] + ' (' + tokens[2] + ')'\n continue\n tokens = line.split()\n if (len(tokens) < 2): \n continue\n x.append(float(tokens[0]))\n y.append(float(tokens[1]))\n return(np.array(x), np.array(y), xunits, intensityUnits)","def read_kitti_Tr_velo_to_cam(filename):\n\n with open(filename) as f:\n for line in f:\n data = line.split(' ')\n if data[0] == 'Tr_velo_to_cam:':\n calib = np.array([float(x) for x in data[1:13]])\n calib = calib.reshape(3, 4)\n return _extend_matrix(calib)\n\n raise Exception(\n 'Could not find entry for P2 in calib file {}'.format(filename))","def read(path):","def read_filename(self, filename):\r\n self.text_lines = task3.read_text_file(filename)","def _parse_txt(path, n_channels):\n f = open(path)\n lines = f.readlines()\n f.close()\n\n geom = np.zeros((0, 2))\n\n for i, line in zip(range(n_channels), lines):\n line = line.replace('\\r', '')\n line = line.replace('\\n', '')\n row = line.split(' ')\n geom = np.vstack((geom, row[:2])).astype('float')\n\n return geom","def read_from_file(self, filename: str) -> None:","def read_txt_file(txt_file):\n\n img_paths = []\n with open(txt_file, 'r') as f:\n lines = f.readlines()\n for line in lines:\n line = line.strip()\n items = line.split(' ')\n img_paths.append(items[0])\n return img_paths","def Read_Rcwa_Matlab(Path) : \n x,y=[],[]\n fs = open(Path, 'r') \n while 1: \n txt = fs.readline()\n if txt =='': \n break\n x.append(float(txt[0:25]))\n y.append(float(txt[29:-2])) \n fs.close()\n return x,y","def Read_txt_Image(Name):\r\n\ttry:\r\n\t\twith open(Name, 'r') as f: #If the file already exists\r\n\t\t\tx = f.readlines() #Readd all the rows and put them in a list\r\n\texcept: \r\n\t\twith open(Name, 'w') as f: #If the file does not exist\r\n\t\t\tx = [] #Create an empty list\r\n\treturn x #This is the list that contains all the information for the file\r","def load_rational_camera_from_txt(cam_fname):\n\n from ._vpgl import _read_rational_camera_from_txt\n\n cam = _read_rational_camera_from_txt(cam_fname)\n if cam:\n return cam\n else:\n raise ValueError(\"Invalid camera file <{}>\".format(cam_fname))","def read_psd_from_txt(filename):\n data = loadtxt(filename)\n return data","def read_camera(self):\n _, frame = self.camera.read()\n return self.mirror(frame)","def readTheFile(path, gui):\n global names\n global SAMPLES_PARTS\n file = open(path, 'r')\n names = file.readline().split()\n names = names[5:]\n SAMPLES_PARTS = [0, 0]\n for name in names:\n if \"Acute\" in name:\n SAMPLES_PARTS[0] += 1\n elif \"Chall\" in name:\n SAMPLES_PARTS[1] += 1\n SAMPLES_PARTS[1] += SAMPLES_PARTS[0]\n line = file.readline()\n data = []\n counter = 1\n gui.write_to_output(\"\\n\")\n while line != '':\n if counter % 1000 == 0:\n gui.write_to_output(\"Done reading \" + str(counter) + \" lines\\n\", overwrite=True)\n counter += 1\n columns = line.split()\n reads = np.array([float(x) for x in columns[5:]])\n name = columns[0]\n chrm = columns[1]\n if chrm == \"chrM\":\n line = file.readline()\n continue\n start = int(columns[2])\n end = int(columns[3])\n if abs(end - start) > 500:\n line = file.readline()\n continue\n strand = columns[4]\n data.append(Gene(name, reads, np.array([start, end]).astype(np.int), strand, chrm))\n line = file.readline()\n gui.write_to_output(\"Done reading \" + str(counter) + \" lines...Now sorting...\\n\", overwrite=True)\n return list(sorted(data, key=lambda x: x.getName()))","def readFT(self,file=\"out__1.ft\"):","def read():\n # TODO","def readfile(file, sub_im, cr):\n\n root, ext = os.path.splitext(file)\n\n if ext == '.tif':\n print('Reading tiff image:', file)\n par = readpar(root + '.mli.par')\n data = readtiff(file, sub_im, cr)\n\n else: # must be GAMMA flat binary float format\n print('Reading flat binary image', file)\n par = readpar(root + ext + '.par')\n data = readmli(file, par, sub_im, cr)\n\n # extract relevant metadata\n rho_r = float(par['range_pixel_spacing'].split()[0])\n rho_a = float(par['azimuth_pixel_spacing'].split()[0])\n theta = float(par['incidence_angle'].split()[0])\n\n return data, rho_r, rho_a, theta","def read_file(path_to_file):\n 8","def parse_txt_file(txtfile):\n array = np.genfromtxt(txtfile)\n return array","def file_parser(file_name):\n h = 480\n w = 640\n out = []\n with open(file_name, 'r') as f:\n line_num = 1\n for line in f:\n if line_num < 17:\n # Read to where data starts\n line_num += 1\n continue\n elif line_num > 74:\n break\n # print(list(map(int, line.strip().split(\" \"))))\n vals = line.split()\n # print(list(\"\".join(line)))\n # print(line.split())\n assert(float(vals[2]) < 640)\n assert(float(vals[3]) < 480)\n point = [float(vals[2]) * w, float(vals[3]) * h]\n # print(point)\n out.append(point)\n line_num += 1\n\n out.append([0,0])\n out.append([w-1, 0])\n out.append([0, h-1])\n out.append([w-1, h-2])\n return out","def readFastaFile(filename):","def _read_data(self, txtfile):\n data_string = open(txtfile,'r').read()\n return data_string","def _read_input_file(self, path: Path):\n img = cv2.imread(str(path))\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # shape: (H, W, C)\n return img","def read_reference():\n global reference\n reference = cv2.imread(REFERENCE)\n print(reference)\n print(reference.shape)","def Read_RMCA_basic(Complete_Path):\n fid = open(Complete_Path,'r')\n S = []\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n S.append(float(line))\n #R.append(float(line[27:-2]))\n return np.array(S)","def readtext(tpath):\r\n t1=tpath\r\n i = []\r\n #check whether text existed\r\n if os.path.exists(t1):\r\n t2=os.path.split(t1)[0]\r\n #print(t2)\r\n with open(tpath) as f:\r\n lines=f.readlines()\r\n for line in lines:\r\n # get all the image names in the text file\r\n line=line.split('\\n')[0]\r\n #generate images' absolute path\r\n line=t2+'/'+line\r\n i.append(line)\r\n f.close()\r\n return i\r\n else:\r\n print(i)\r\n return False","def test_file_read():\n expected = [\"scorevideo LOG\\n\", \"File: log.mat\"]\n with open(TEST_RES + \"/file_read.txt\", 'r') as file:\n actual = file.readlines()\n assert expected == actual","def open_and_read_file(file_path):\n text_data = open(file_path).read()\n # print text_data\n return text_data","def readmovie(addr, ftype='xyz', frameformat='aio'):\n \n f = open(addr, 'r')\n allcoords = []\n \n if ftype == 'xyz':\n \n while True:\n \n try:\n natoms = int(f.readline())\n f.readline()\n atoms, coords = [], []\n \n for x in range(natoms):\n line = f.readline().split()\n atoms.append(line[0])\n coords.append(line[1:])\n \n allcoords.append(coords)\n \n except:\n \n break\n \n # Assemble the read coordinates into a dictionary\n nframes = len(allcoords)\n out = {}\n out['atoms'] = atoms\n \n if frameformat == 'aio':\n out['frames'] = np.asarray(allcoords, dtype='float64')\n elif frameformat == 'sep':\n for i in range(nframes):\n out[str(i)] = np.asarray(allcoords[i], dtype='float64')\n \n return out","def read_file(self, currentIndex):\n handle = open(\"Program Files\\\\\" + str(currentIndex) + \".tvInfo\", \"r\")\n data = handle.read() #reading description\n handle.close()\n return data","def readVideo(self):\n vid = cv2.VideoCapture(self.fname)\n imgstack = []\n # grab = True\n grab, img = vid.read()\n while grab:\n imgstack.append(\n Frame(\n cv2.cvtColor(img, cv2.COLOR_BGR2GRAY),\n self.starttime\n + datetime.timedelta(seconds=self.frame_dt * self.length),\n )\n )\n self.length += 1\n grab, img = vid.read()\n self.frames = imgstack","def read_file(file_name):\n fits_file = fits.open(file_name)\n\n header = fits_file[0].header\n image_data = fits_file[1].data\n\n segmentation_data = fits_file[2].data\n\n header_keywords = {'CRVAL3': 0, 'CRPIX3': 0, 'CD3_3': 0}\n # clause to differentiate between CDELT3 and CD3_3\n\n for hdr_key, hdr_value in header_keywords.items():\n # finding required header values\n hdr_value = header[hdr_key]\n header_keywords[hdr_key] = hdr_value\n\n return header_keywords, image_data, segmentation_data","def read_file(file):\n if opts.input_type == 'fits':\n data = fileio.read_fits(file)\n else:\n data = fileio.read_ascii(file)\n c_id = data[0,:]\n g_num = np.array(range(len(c_id)), dtype = 'int')\n g_id = data[3,:]\n g_ra = np.array(data[4,:], dtype = 'float')\n g_dec = np.array(data[5,:], dtype = 'float')\n g_z = np.array(data[6,:], dtype = 'float')\n return c_id, g_num, g_id, g_ra, g_dec, g_z","def read_file(self, currentIndex):\n handle = open(\"Program Files\\\\TvInfo\\\\\" + str(currentIndex) + \".tvInfo\", \"r\")\n data = handle.read() #reading description\n handle.close()\n return data","def read_file(self):\n try:\n with open(self.file_name, 'r') as ach_file:\n file_contents = ach_file.read().replace('\\n', '').replace('\\r', '')\n\n self._parse_ach_file(file_contents)\n except FileNotFoundError as err:\n print(\"File does not exist -> \" + str(err))","def readImage(self, path, tt=1):\n return cv2.imread( path, tt)","def Read_RMCA_out(Complete_Path):\n fid = open(Complete_Path,'r')\n L,R = [],[]\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n L.append(float(line[:25]))\n R.append(float(line[27:-2]))\n return np.array(L),np.array(R)","def read_file(self, fullname):\n\n data = np.genfromtxt(fullname, dtype=None, names=True, skip_header=0)\n return data","def readfile(self, path, filename):\n # The DataStudio software uses ISO-8859-1 encoding (especially for the degree sign in temperature files)\n file = open(path + filename, encoding=\"iso-8859-1\")\n rowlist = file.readlines()\n\n title = rowlist[0].strip(\"\\n\")\n labels = rowlist[1].strip(\"\\n\").split(sep=\"\\t\")\n\n data = np.zeros((len(rowlist)-2, 2))\n\n for i in range(2, len(rowlist)):\n columns = rowlist[i].split(sep=\"\\t\")\n data[i-2, 0] = float(columns[0].replace(\",\", \".\"))\n data[i-2, 1] = float(columns[1].replace(\",\", \".\"))\n\n return data, title, labels","def _read_datafile(self,path):\n \tlabels, images = [], []\n \twith gzip.GzipFile(path) as f:\n \t for line in f:\n \t vals = line.strip().split()\n \t labels.append(float(vals[0]))\n \t images.append([float(val) for val in vals[1:]])\n \tlabels = np.array(labels, dtype=np.int32)\n \tlabels[labels == 10] = 0 # fix weird 0 labels\n \timages = np.array(images, dtype=np.float32).reshape(-1, 16, 16, 1)\n \timages = (images + 1) / 2\n \treturn images, labels","def loadLogo():\n #On charge le fichier logo\n f = open('ASCII.art', 'rb')\n #On recupere les lignes\n lines = f.readlines() \n #On ferme le fichier\n f.close()\n return lines","def read_file(filename):\n reads = []\n labels = []\n\n with open(filename) as f:\n content = f.readlines()\n\n for line in content:\n _, read, label = re.sub('[null\\t\\n\\[\\]\\\"]', '', line).replace(' ', '').split(',')\n reads.append(read)\n labels.append(label)\n \n return reads, labels","def do_readsourcefile(self, file_name):\r\n self.file_name = file_name\r\n f = open(self.file_name, \"r\")\r\n print(f.read())\r\n f.close()","def read_spe(spefilename, verbose=False):\n \n # open SPE file as binary input\n spe = open(spefilename, \"rb\")\n \n # Header length is a fixed number\n nBytesInHeader = 4100\n\n # Read the entire header\n header = spe.read(nBytesInHeader)\n \n # version of WinView used\n swversion = struct.unpack_from(\"16s\", header, offset=688)[0]\n \n # version of header used\n # Eventually, need to adjust the header unpacking\n # based on the headerVersion. \n headerVersion = struct.unpack_from(\"f\", header, offset=1992)[0]\n \n # which camera controller was used?\n controllerVersion = struct.unpack_from(\"h\", header, offset=0)[0]\n if verbose:\n print (\"swversion = \", swversion)\n print (\"headerVersion = \", headerVersion)\n print (\"controllerVersion = \", controllerVersion)\n \n # Date of the observation\n # (format is DDMONYYYY e.g. 27Jan2009)\n date = struct.unpack_from(\"9s\", header, offset=20)[0]\n \n # Exposure time (float)\n exp_sec = struct.unpack_from(\"f\", header, offset=10)[0]\n \n # Intensifier gain\n pimaxGain = struct.unpack_from(\"h\", header, offset=148)[0]\n\n # Not sure which \"gain\" this is\n gain = struct.unpack_from(\"H\", header, offset=198)[0]\n \n # Data type (0=float, 1=long integer, 2=integer, 3=unsigned int)\n data_type = struct.unpack_from(\"h\", header, offset=108)[0]\n\n comments = struct.unpack_from(\"400s\", header, offset=200)[0]\n\n # CCD Chip Temperature (Degrees C)\n detectorTemperature = struct.unpack_from(\"f\", header, offset=36)[0]\n\n # The following get read but are not used\n # (this part is only lightly tested...)\n analogGain = struct.unpack_from(\"h\", header, offset=4092)[0]\n noscan = struct.unpack_from(\"h\", header, offset=34)[0]\n pimaxUsed = struct.unpack_from(\"h\", header, offset=144)[0]\n pimaxMode = struct.unpack_from(\"h\", header, offset=146)[0]\n\n ########### here's from Kasey\n #int avgexp 2 number of accumulations per scan (why don't they call this \"accumulations\"?)\n #TODO: this isn't actually accumulations, so fix it... \n accumulations = struct.unpack_from(\"h\", header, offset=668)[0]\n if accumulations == -1:\n # if > 32767, set to -1 and \n # see lavgexp below (668) \n #accumulations = struct.unpack_from(\"l\", header, offset=668)[0]\n # or should it be DWORD, NumExpAccums (1422): Number of Time experiment accumulated \n accumulations = struct.unpack_from(\"l\", header, offset=1422)[0]\n \n \"\"\"Start of X Calibration Structure (although I added things to it that I thought were relevant,\n like the center wavelength...\"\"\"\n xcalib = {}\n \n #SHORT SpecAutoSpectroMode 70 T/F Spectrograph Used\n xcalib['SpecAutoSpectroMode'] = bool( struct.unpack_from(\"h\", header, offset=70)[0] )\n\n #float SpecCenterWlNm # 72 Center Wavelength in Nm\n xcalib['SpecCenterWlNm'] = struct.unpack_from(\"f\", header, offset=72)[0]\n \n #SHORT SpecGlueFlag 76 T/F File is Glued\n xcalib['SpecGlueFlag'] = bool( struct.unpack_from(\"h\", header, offset=76)[0] )\n\n #float SpecGlueStartWlNm 78 Starting Wavelength in Nm\n xcalib['SpecGlueStartWlNm'] = struct.unpack_from(\"f\", header, offset=78)[0]\n\n #float SpecGlueEndWlNm 82 Starting Wavelength in Nm\n xcalib['SpecGlueEndWlNm'] = struct.unpack_from(\"f\", header, offset=82)[0]\n\n #float SpecGlueMinOvrlpNm 86 Minimum Overlap in Nm\n xcalib['SpecGlueMinOvrlpNm'] = struct.unpack_from(\"f\", header, offset=86)[0]\n\n #float SpecGlueFinalResNm 90 Final Resolution in Nm\n xcalib['SpecGlueFinalResNm'] = struct.unpack_from(\"f\", header, offset=90)[0]\n\n # short BackGrndApplied 150 1 if background subtraction done\n xcalib['BackgroundApplied'] = struct.unpack_from(\"h\", header, offset=150)[0]\n BackgroundApplied=False\n if xcalib['BackgroundApplied']==1: BackgroundApplied=True\n\n # float SpecGrooves 650 Spectrograph Grating Grooves\n xcalib['SpecGrooves'] = struct.unpack_from(\"f\", header, offset=650)[0]\n\n # short flatFieldApplied 706 1 if flat field was applied.\n xcalib['flatFieldApplied'] = struct.unpack_from(\"h\", header, offset=706)[0]\n flatFieldApplied=False\n if xcalib['flatFieldApplied']==1: flatFieldApplied=True\n \n #double offset # 3000 offset for absolute data scaling */\n xcalib['offset'] = struct.unpack_from(\"d\", header, offset=3000)[0]\n\n #double factor # 3008 factor for absolute data scaling */\n xcalib['factor'] = struct.unpack_from(\"d\", header, offset=3008)[0]\n \n #char current_unit # 3016 selected scaling unit */\n xcalib['current_unit'] = struct.unpack_from(\"c\", header, offset=3016)[0]\n\n #char reserved1 # 3017 reserved */\n xcalib['reserved1'] = struct.unpack_from(\"c\", header, offset=3017)[0]\n\n #char string[40] # 3018 special string for scaling */\n xcalib['string'] = struct.unpack_from(\"40c\", header, offset=3018)\n \n #char reserved2[40] # 3058 reserved */\n xcalib['reserved2'] = struct.unpack_from(\"40c\", header, offset=3058)\n\n #char calib_valid # 3098 flag if calibration is valid */\n xcalib['calib_valid'] = struct.unpack_from(\"c\", header, offset=3098)[0]\n\n #char input_unit # 3099 current input units for */\n xcalib['input_unit'] = struct.unpack_from(\"c\", header, offset=3099)[0]\n \"\"\"/* \"calib_value\" */\"\"\"\n\n #char polynom_unit # 3100 linear UNIT and used */\n xcalib['polynom_unit'] = struct.unpack_from(\"c\", header, offset=3100)[0]\n \"\"\"/* in the \"polynom_coeff\" */\"\"\"\n\n #char polynom_order # 3101 ORDER of calibration POLYNOM */\n xcalib['polynom_order'] = struct.unpack_from(\"c\", header, offset=3101)[0]\n\n #char calib_count # 3102 valid calibration data pairs */\n xcalib['calib_count'] = struct.unpack_from(\"c\", header, offset=3102)[0]\n\n #double pixel_position[10];/* 3103 pixel pos. of calibration data */\n xcalib['pixel_position'] = struct.unpack_from(\"10d\", header, offset=3103)\n\n #double calib_value[10] # 3183 calibration VALUE at above pos */\n xcalib['calib_value'] = struct.unpack_from(\"10d\", header, offset=3183)\n\n #double polynom_coeff[6] # 3263 polynom COEFFICIENTS */\n xcalib['polynom_coeff'] = struct.unpack_from(\"6d\", header, offset=3263)\n\n #double laser_position # 3311 laser wavenumber for relativ WN */\n xcalib['laser_position'] = struct.unpack_from(\"d\", header, offset=3311)[0]\n\n #char reserved3 # 3319 reserved */\n xcalib['reserved3'] = struct.unpack_from(\"c\", header, offset=3319)[0]\n\n #unsigned char new_calib_flag # 3320 If set to 200, valid label below */\n #xcalib['calib_value'] = struct.unpack_from(\"BYTE\", header, offset=3320)[0] # how to do this?\n\n #char calib_label[81] # 3321 Calibration label (NULL term'd) */\n xcalib['calib_label'] = struct.unpack_from(\"81c\", header, offset=3321)\n\n #char expansion[87] # 3402 Calibration Expansion area */\n xcalib['expansion'] = struct.unpack_from(\"87c\", header, offset=3402)\n ########### end of Kasey's addition\n\n if verbose:\n print (\"date = [\"+date+\"]\")\n print (\"exp_sec = \", exp_sec)\n print (\"pimaxGain = \", pimaxGain)\n print (\"gain (?) = \", gain)\n print (\"data_type = \", data_type)\n print (\"comments = [\"+comments+\"]\")\n print (\"analogGain = \", analogGain)\n print (\"noscan = \", noscan)\n print (\"detectorTemperature [C] = \", detectorTemperature)\n print (\"pimaxUsed = \", pimaxUsed)\n\n # Determine the data type format string for\n # upcoming struct.unpack_from() calls\n if data_type == 0:\n # float (4 bytes)\n dataTypeStr = \"f\" #untested\n bytesPerPixel = 4\n dtype = \"float32\"\n elif data_type == 1:\n # long (4 bytes)\n dataTypeStr = \"l\" #untested\n bytesPerPixel = 4\n dtype = \"int32\"\n elif data_type == 2:\n # short (2 bytes)\n dataTypeStr = \"h\" #untested\n bytesPerPixel = 2\n dtype = \"int32\"\n elif data_type == 3: \n # unsigned short (2 bytes)\n dataTypeStr = \"H\" # 16 bits in python on intel mac\n bytesPerPixel = 2\n dtype = \"int32\" # for numpy.array().\n # other options include:\n # IntN, UintN, where N = 8,16,32 or 64\n # and Float32, Float64, Complex64, Complex128\n # but need to verify that pyfits._ImageBaseHDU.ImgCode cna handle it\n # right now, ImgCode must be float32, float64, int16, int32, int64 or uint8\n else:\n print (\"unknown data type\")\n print (\"returning...\")\n sys.exit()\n \n # Number of pixels on x-axis and y-axis\n nx = struct.unpack_from(\"H\", header, offset=42)[0]\n ny = struct.unpack_from(\"H\", header, offset=656)[0]\n \n # Number of image frames in this SPE file\n nframes = struct.unpack_from(\"l\", header, offset=1446)[0]\n\n if verbose:\n print (\"nx, ny, nframes = \", nx, \", \", ny, \", \", nframes)\n \n npixels = nx*ny\n npixStr = str(npixels)\n fmtStr = npixStr+dataTypeStr\n if verbose:\n print (\"fmtStr = \", fmtStr)\n \n # How many bytes per image?\n nbytesPerFrame = npixels*bytesPerPixel\n if verbose:\n print (\"nbytesPerFrame = \", nbytesPerFrame)\n\n # Create a dictionary that holds some header information\n # and contains a placeholder for the image data\n spedict = {'data':[], # can have more than one image frame per SPE file\n 'IGAIN':pimaxGain,\n 'EXPOSURE':exp_sec,\n 'SPEFNAME':spefilename,\n 'OBSDATE':date,\n 'CHIPTEMP':detectorTemperature,\n 'COMMENTS':comments,\n 'XCALIB':xcalib,\n 'ACCUMULATIONS':accumulations,\n 'FLATFIELD':flatFieldApplied,\n 'BACKGROUND':BackgroundApplied\n }\n \n # Now read in the image data\n # Loop over each image frame in the image\n if verbose:\n print (\"Reading image frames number \"),\n for ii in range(nframes):\n iistr = str(ii)\n data = spe.read(nbytesPerFrame)\n if verbose:\n print (iistr,\" \",)\n \n # read pixel values into a 1-D numpy array. the \"=\" forces it to use\n # standard python datatype size (4bytes for 'l') rather than native\n # (which on 64bit is 8bytes for 'l', for example).\n # See http://docs.python.org/library/struct.html\n dataArr = np.array(struct.unpack_from(\"=\"+fmtStr, data, offset=0),\n dtype=dtype)\n\n # Resize array to nx by ny pixels\n # notice order... (y,x)\n dataArr.resize((ny, nx))\n #print dataArr.shape\n\n # Push this image frame data onto the end of the list of images\n # but first cast the datatype to float (if it's not already)\n # this isn't necessary, but shouldn't hurt and could save me\n # from doing integer math when i really meant floating-point...\n spedict['data'].append( dataArr.astype(float) )\n\n if verbose:\n print (\"\")\n \n return spedict","def read_file(self, *args, **kwargs):\n if self.detector == \"FACET\":\n return self.read_facet(self.filename)\n elif self.detector == \"OpenFace\":\n return self.read_openface(self.filename)\n elif self.detector == \"Affectiva\":\n return self.read_affectiva(self.filename)\n elif self.detector == \"Feat\":\n return self.read_feat(self.filename)\n else:\n print(\"Must specifiy which detector [Feat, FACET, OpenFace, or Affectiva]\")","def return_file_read(_):\n return [\"scorevideo LOG\", \"File: log.mat\"]","def readFlow(fn):\n with open(fn, 'rb') as f:\n magic = np.fromfile(f, np.float32, count=1)\n if 202021.25 != magic:\n print('Magic number incorrect. Invalid .flo file')\n return None\n else:\n w = np.fromfile(f, np.int32, count=1)\n h = np.fromfile(f, np.int32, count=1)\n # print 'Reading %d x %d flo file\\n' % (w, h)\n data = np.fromfile(f, np.float32, count=2*int(w)*int(h))\n # Reshape data into 3D array (columns, rows, bands)\n # The reshape here is for visualization, the original code is (w,h,2)\n return np.resize(data, (int(h), int(w), 2))","def file_read(file_name):\n \n #open specified file in read mode\n in_file = open(file_name, \"r\")\n \n #create data lists\n sp_length_v3 = []\n sp_period_v3 = [] \n\n #save header to string and split into list\n header_string = in_file.readline()\n header_v3 = header_string.split()\n \n #save revelent data to respective lists\n for line in in_file:\n values = line.split()\n sp_length_v3.append(float(values[1]))\n sp_period_v3.append(float(values[2]))\n \n #close the file\n in_file.close()\n \n #return 3D lists of lists containing data\n ans = [sp_length_v3, sp_period_v3, header_v3]\n \n return ans","def read_file(testing_file):\n samples = []\n with open(testing_file, 'r') as in_file:\n for line in in_file:\n info = line.strip('\\n').split()\n samples.append((info[0], info[1]))\n return samples","def readin():\r\n nodes = np.loadtxt('Vnodes.txt', ndmin=2)\r\n mats = np.loadtxt('Vmater.txt', ndmin=2)\r\n elements = np.loadtxt('Veles.txt', ndmin=2)\r\n loads = np.loadtxt('Vloads.txt', ndmin=2)\r\n return nodes, mats, elements, loads","def openfile(filename):\n Data = np.genfromtxt(filename, delimiter = \",\")\n data = [[]]\n for i in range(np.shape(Data)[0]):\n #Stores information row-by-row\n data.append(Data[i][0:])\n return data","def read_text_file(str_name_file: str):\n content: str = ''\n with open(str_name_file, mode=\"r\", encoding='utf-8') as file:\n print(\"file being read: \" + str_name_file + \"\\n\")\n content = file.read()\n return content","def read(self):\n\n with open(self.path, 'r') as to_read:\n reader = csv.reader(to_read)\n _ = reader.next()\n camera_vals = []\n velocities = []\n for row in reader:\n camera_vals.append(row[:len(camera_headers)])\n velocities.append(row[len(camera_headers):][0])\n velocities = [[int(x) for x in string] for string in velocities]\n camera_vals = camera_vals[::downsample_constant]\n velocities = velocities[::downsample_constant]\n return (\n [[float(x) for x in row] for row in camera_vals],\n velocities\n )","def read_raw(rawfile, shape, dtype=np.uint16, kind='middleton'):\n\n # -- alert\n print(\"READ_RAW: reading {0}...\".format(rawfile))\n\n\n # -- read file\n if kind=='middleton':\n return np.fromfile(open(rawfile),dtype) \\\n .reshape(shape[2],shape[0],shape[1])[:,:,::-1] \\\n .transpose(1,2,0) \\\n .astype(float)","def read_projection_image(self, fname):\r\n\r\n if self.fileExt == 'dm4':\r\n file = dm.FileDM(fname)\r\n alphaTag = '.ImageList.2.ImageTags.Microscope Info.'\\\r\n 'Stage Position.Stage Alpha'\r\n return (file.getDataset(0)['data'], file.allTags[alphaTag])\r\n elif self.fileExt == 'ser':\r\n file = ser.SerReader(fname)\r\n return (file['data'], file['metadata']['Stage A [deg]'])\r\n # Stage Alpha isn't stored in metadata for dm3 or tif\r\n elif self.fileExt == 'dm3':\r\n # Parse fname for stage alpha\r\n file = dm.FileDM(fname)\r\n\r\n match = 'degrees'\r\n tags = fname.split('_')\r\n\r\n angle = [tag for tag in tags if match in tag][0]\r\n angleInd = angle.find(match)\r\n return (file.getDataset(0)['data'], float(angle[:angleInd]))","def read_txt(path):\n mz = []\n i = []\n with open(path) as f:\n for line in f:\n line = line.split()\n mz.append(float(line[0]))\n i.append(float(line[1]))\n return mz, i","def load_data(file_to_read):\n\n data = np.recfromtxt(file_to_read)\n data = np.asarray(data)\n\n return data","def load_vo_txt_raw(*, fname, sampling='1M'):\n # Set the day of month for time series depending on the MF sampling rate\n if sampling == '1M':\n day = 15\n elif sampling == '4M':\n day = 1\n\n # Positions given in degrees - co-latitude (0 to 180), longitude (\n df = pd.read_csv(fname, sep=\"\\s+\", header=14,\n names=[\"theta\", \"phi\", \"Year\", \"Month\", \"Time\", \"r\",\n \"Br\", \"Btheta\", \"Y\", \"sigma_r\", \"sigma_theta\",\n \"sigma_phi\", \"N_data\"], usecols=range(13))\n\n df[\"mjd2000\"] = mjd2000(df[\"Year\"], df[\"Month\"], day)\n df[\"dyear\"] = mjd_to_dyear(df[\"mjd2000\"], leap_year=True)\n df[\"X\"] = -df[\"Btheta\"] # -theta component\n df[\"Z\"] = -df[\"Br\"] # -radial component\n df.drop(columns=[\"Btheta\", \"Br\"], inplace=True)\n # To 00:00 on 1st or 15th each month\n # Multiplication by 10000 and 100 are needed to convert to datetime\n # (see documentation for pandas.datetime)\n df[\"date\"] = pd.to_datetime(df[\"Year\"]*10000+df[\"Month\"]*100+day,\n format=\"%Y%m%d\")\n\n return df","def loadtrkfile(T_filename, threshold_short_streamlines=10.0):\r\n print(\"Loading %s\" % T_filename)\r\n T, hdr = trackvis.read(T_filename, as_generator=False)\r\n T = np.array([s[0] for s in T], dtype=np.object)\r\n \r\n\r\n \r\n return T, hdr","def readpil3d(self):\r\n\r\n # Read the data in as an array.\r\n res = np.loadtxt(self.name, delimiter=' ')\r\n\r\n # Split into useful chunks\r\n self.pos = res[:, 0:3] # Grid point locations\r\n self.Pn = res[:, 3:4] # Normal pressure [Pa]\r\n self.flux = res[:, -1] # Flux\r","def read_positions():\n return np.genfromtxt(\"POSITIONS.OUT\").transpose()","def read_from(self, filename):\n self.x, self.y = np.loadtxt(filename, unpack=True, usecols=(0, 1))","def read_file(file):\n f = open(file, 'r')\n print(f.read())","def read_rcm(self, rcmFilename = \"tsunami.rcm\"):\n file_in = open(rcmFilename,\"r\").readlines()","def read(self, filename):\n raise NotImplementedError","def read(self, filename): # real signature unknown; restored from __doc__\n pass","def Read_t_file(file_name):\n t=[]\n \n with open(file_name,'r') as reader:\n temp=reader.readline().strip().split()[-1].split('-')\n t.append(temp[0])\n t.append(temp[1])\n for line in reader.readlines():\n t.append(line.strip().split()[-1].split('-')[-1])\n \n return np.array(t,dtype=np.float32)","def read_file(self,fname):\n try:\n self.raw=spiketrain.read_file(fname)\n except Exception:\n self.raw=None\n raise","def read_file(self, file_path): \n logging.info('Lendo arquivo de {0}'.format(file_path))\n file_with_tags = open(file_path, \"r\", encoding='utf-8')\n return file_with_tags.readlines()","def read_file(log_file):\n\t\tfile = open(log_file, 'r')\n\t\tresult = []\n\t\twhile 1:\n\t\t\tcontent = file.readline()\n\t\t\tif not content:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tdata = content.split(\"\\003\")\n\t\t\t\tif len(data) == 13:\n\t\t\t\t\ttrack = {\n\t\t\t\t\t\t\t 'device_no' : long(data[0][3:]), 'sim' : data[1], 'type':int(data[2]), 'gps_time' : MongoTrack.time_trans(data[3]),\n\t\t\t\t\t\t\t 'valid' : data[4], 'loc':{'long' : float(data[5]), 'lat' : float(data[6]) }, 'altitude' : float(data[7]),\n\t\t\t\t\t\t\t 'speed' : float(data[8]), 'course' : float(data[9]), 'km' : float(data[10]), 'para' : float(data[11]),\n\t\t\t\t\t\t\t 'rtime' : MongoTrack.time_trans(data[12].strip())\n\t\t\t\t\t\t\t}\n\t\t\t\t\tresult.append(track)\n\t\tfile.close()\n\t\treturn result","def display_seqres_seq():\n \n import os\n choice = input('Enter the name of the file: ')\n filepath = os.path.join('/home/njesh/python-mini-project-JaneNjeri/Data', choice)\n with open(filepath, 'r') as file:\n for line in file:\n if line[:6] == 'SEQRES':\n line_split = line.split()[4:]\n print(line_split)\n return file","def _read_from_file(self, filename):\n ff = fits.open(filename)\n # Load the normalized intensity\n self.norm_int = ff[0].data\n # Load the other parameters\n self.lam = ff[1].data['lam']\n self.lam_unit = ff[1].columns['lam'].unit\n self.theta = ff[2].data['theta']\n self.taux = ff[3].data['taux']\n # Set halo type\n self.description = filename","def get_textimage(fname):\n \tfrom string import atoi,atof\n \tinfile = open(fname)\n\tlines = infile.readlines()\n\tinfile.close()\n\tdata = lines[0].split()\n\tnx = atoi(data[0])\n\tny = atoi(data[1])\n\tnz = atoi(data[2])\n\te = EMData()\n\te.set_size(nx, ny, nz)\n\te.to_zero()\n\tfor line in lines[1:]:\n\t\tdata = line.split()\n\t\tix = atoi(data[0])\n\t\tiy = atoi(data[1])\n\t\tiz = atoi(data[2])\n\t\tval = atof(data[3])\n\t\te[ix,iy,iz] = val\n\treturn e","def readInput(in_file_name):\n in_file = open(in_file_name, 'r')\n positions = []\n samples = []\n M = []; P = [];\n MC = []; PC = [];\n while True:\n line = in_file.readline()\n if not line: break\n if line[0] == '#': continue #skip comment\n line = line.rstrip('\\n').split('\\t')\n \n #genomic positions and allele support in plasma samples\n positions.append(int(line[0]))\n samples.append(tuple(map(int, line[1:5])))\n \n #maternal and paternal alleles\n M.append(tuple(line[5:7]))\n MC.append(tuple(map(float, line[7:9])))\n \n P.append(tuple(line[9:11]))\n PC.append(tuple(map(float, line[11:13]))) \n \n in_file.close()\n return positions, samples, M, P, MC, PC","def simple_text_reader(text_file):\n with open(text_file, 'rt') as file:\n data = file.read()\n return data","def load_text(path):\n\n with open(path) as f:\n read_text = f.read().splitlines()\n \n return np.array(read_text)","def read_flow(filename):\n with open(filename, 'rb') as f:\n magic = np.fromfile(f, np.float32, count=1)\n if 202021.25 != magic:\n print('Magic number incorrect. Invalid .flo file')\n else:\n w = np.fromfile(f, np.int32, count=1)\n h = np.fromfile(f, np.int32, count=1)\n data = np.fromfile(f, np.float32, count=int(2*w*h))\n # Reshape data into 3D array (columns, rows, bands)\n return np.resize(data, (h[0], w[0], 2))","def read_text_file(text_file):\n try:\n with open(text_file, \"rb\") as f:\n text = tf.compat.as_str(f.read()) \n except Exception as e:\n print(\"Unable to open\", text_file, \":\", e)\n raise\n return text","def open_raw(path):\r\n raw_file_reader = RawFileReader.RawFileReaderAdapter.FileFactory(path)\r\n raw_file_reader.SelectInstrument(Business.Device.UV, 1)\r\n return raw_file_reader","def read_file(self):\n # This is quite ugly but works for now.\n self.header = read_csv(self.file_name, delim_whitespace=True,\n header=TrackData.header_line,\n nrows=1).to_dict(orient='index')[0]\n self.data = read_csv(self.file_name, delim_whitespace=True, \n header=TrackData.data_line)","def read_input_file(self):\n\n # Check if input file exists in current directory, if not kill process\n if not os.path.isfile('./visualise.inpt'):\n print('Cannot find input file \"visualise.inpt\" in current directory')\n sys.exit()\n\n # Read input file and analysis options and parameters\n print('Reading input file')\n with open('visualise.inpt','r') as f:\n f.readline()\n self.prefix = f.readline().split()[0]\n f.readline()\n f.readline()\n self.frame = int(f.readline().split()[0])\n f.readline()\n f.readline()\n self.vis_particles = int(f.readline().split()[0])\n self.vis_vortype = int(f.readline().split()[0])\n self.vis_cellcolour = int(f.readline().split()[0])\n self.vis_save = int(f.readline().split()[0])","def open_and_read_file(file_path):\n\n source_material = open(file_path).read()\n return source_material","def open_file_path(self, file_path):\n\n\t\ttext = []\n\t\twith open(file_path, \"r\") as f:\n\t\t\tfor line in f:\n\t\t\t\ttext.append(line)\n\n\t\tself.raw = text","def read(self):\n # open the .SPE file\n with open(self._input_file_path, 'rb') as f:\n lines = f.readlines()\n # Create an empty dictionary for the metadata\n metadata_dictionary = {}\n\n # Search through the file for the needed metadata\n metadata_dictionary['date_acquired'] = re.search(b'date=\"(.*?)\"', lines[1])[1].decode('ANSI') \n metadata_dictionary['width'] = int(re.search(b'width=\"(.*?)\"', lines[1])[1])\n metadata_dictionary['height'] = int(re.search(b'height=\"(.*?)\"', lines[1])[1])\n metadata_dictionary['size'] = metadata_dictionary['width']*metadata_dictionary['height']\n metadata_dictionary['exposure_time'] = int(re.search(b'<ExposureTime type=\"Double\">(.*?)</ExposureTime>', lines[1])[1])\n metadata_dictionary['excitation_wavelength'] = float(re.search(b'laserLine=\"(.*?)\"',lines[1])[1])\n metadata_dictionary['center_wavelength'] = float(re.search(b'<CenterWavelength type=\"Double\">(.*?)</CenterWavelength>',lines[1])[1])\n metadata_dictionary['orientation'] = re.search(b'orientation=\"(.*?)\"',lines[1])[1].decode('ANSI')\n\n # Get the wavelength and intensity\n wavelength_string = re.search(b'<Wavelength xml:space=\"preserve\">(.*?)</Wavelength>',lines[1])[1].decode('utf-8')\n wavelength = np.array(wavelength_string.split(','), dtype=np.float64)\n\n f.seek(4100)\n intensity = np.fromfile(f,dtype=np.float32,count=metadata_dictionary['size'])\n\n raman_shift_wavenumbers = 1e7*(1/metadata_dictionary['excitation_wavelength'] - 1/wavelength)\n\n f.close()\n \n # create the sidpy dataset\n data_set = Dataset.from_array(intensity, name='Raman Spectra')\n\n data_set.data_type = 'spectrum'\n data_set.units = 'counts'\n data_set.quantity = 'Intensity'\n\n # set dimensions\n data_set.set_dimension(0, Dimension(raman_shift_wavenumbers, name='Raman Shift',\n units = 'cm-1',\n quantity='Raman shift',\n dimension_type='spectral'))\n data_set.set_dimension(1, Dimension(intensity, name='Intensity',\n units = 'counts',\n quantity='intensity',\n dimension_type='spectral')) \n\n data_set.metadata = metadata_dictionary\n\n return data_set"],"string":"[\n \"def cam_read(filename):\\n f = open(filename,'rb')\\n check = np.fromfile(f,dtype=np.float32,count=1)[0]\\n assert check == TAG_FLOAT, ' cam_read:: Wrong tag in flow file (should be: {0}, is: {1}). Big-endian machine? '.format(TAG_FLOAT,check)\\n M = np.fromfile(f,dtype='float64',count=9).reshape((3,3))\\n N = np.fromfile(f,dtype='float64',count=12).reshape((3,4))\\n return M,N\",\n \"def readText(self, filename, firstLine = 0, lastLine = None):\\n \\n assert filename.endswith('.txt')\\n file = open(filename, 'r')\\n self.samples = []\\n\\n li = 0\\n while li < firstLine:\\n if not file.readline():\\n return\\n li += 1\\n\\n while lastLine == None or li < lastLine:\\n line = file.readline()\\n if not line:\\n return\\n li += 1\\n line = line.strip()\\n if line:\\n columns = line.split('|')\\n if columns[1] == 'client-fps':\\n self.samples.append(Sample(line, columns))\",\n \"def read_map_file(path):\\r\\n with open(path) as f:\\r\\n dir_name = os.path.dirname(path)\\r\\n img = cv2.imread(dir_name + '/' + f.readline().strip())\\r\\n assert img.shape[0] > 0 and img.shape[1] > 0, 'Can not open image file'\\r\\n meter_per_pixel = float(f.readline().strip())\\r\\n ori_str = f.readline().strip().split()\\r\\n origin = np.array([int(ori_str[0]), int(ori_str[1])])\\r\\n init_heading = float(ori_str[2])\\r\\n return img, meter_per_pixel, origin, init_heading\",\n \"def _read_file(self):\\n extension = self.path.split('.')[-1]\\n if extension!='avi':\\n raise Exception(\\\"Invalid Format\\\")\\n\\n return cv2.VideoCapture(self.path)\",\n \"def read(cls):\\n x_i=\\\"vas.txt\\\"\\n with open(x_i, 'r')as txt_file:\\n file = txt_file.read()\\n return file\",\n \"def load_camera_data(file_name):\\n assert os.path.isfile(file_name), \\\"Invalid file {}\\\".format(file_name)\\n import sintel_io\\n\\n intrinsic, extrinsic = sintel_io.cam_read(file_name)\\n return intrinsic, extrinsic\",\n \"def file_reader(filename = 'conv_params'):\\n\\n with open(filename) as f:\\n info = f.readlines()\\n info = [i.strip() for i in info] # each element in info is a string of a line from the file\\n info = [i.split() for i in info] # split each whitespace delimited element into a list of lists\\n info = [[i.split('-') for i in j] for j in info] # note info is 3 layers deep\\n\\n info[2] = info[2][0] # makes default E just a single string of the number\\n info[3] = info[3][0]\\n\\n return info\",\n \"def read_poses_for_camera(record_path, camera_name):\\n\\n # Resolve pose.txt file path for camera\\n poses_path = os.path.join(record_path, camera_name, 'pose.txt')\\n if os.path.exists(poses_path):\\n poses = read_poses_dict(poses_path)\\n else:\\n # Sample type dataset (aka zpark-sample)\\n poses_path = os.path.join(record_path, camera_name + '.txt')\\n poses = read_poses_dict_6(poses_path)\\n return poses\",\n \"def read(self, filename):\\n pass\",\n \"def read(self, filename):\\n pass\",\n \"def read_text(filename):\\n with open(filename, 'r') as f:\\n com = f.readline()[0]\\n wavelength, flux = np.loadtxt(filename, unpack=True,\\n usecols=(0, 1), comments=com)\\n return wavelength, flux\",\n \"def read1(cls):\\n x_i = \\\"vas.txt\\\"\\n with open(x_i, 'r')as txt_file:\\n file = txt_file.readlines()\\n return file\",\n \"def readtxt(obslog):\\n\\n logger = log.getLogger('obslog.readtxt')\\n\\n if not os.path.exists(obslog):\\n logger.error('Cannot access %s', obslog)\\n raise SystemExit\\n\\n logger.info('Reading %s', obslog)\\n\\n with open(obslog) as f: # Since we will have to go through the data twice, read the whole file at once.\\n data = f.readlines()\\n\\n header = ['Observation ID', 'Data Labels', 'File Numbers', 'Dataset UT', 'Target Name', 'Filters', 'Slit',\\n 'Grating/Wavelength', 'Camera/Prism', 'ExpTime/LNR/Coadds', 'ACQ']\\n\\n pattern = dict() # Enforce formatting rules to avoid parsing comments as data:\\n pattern['Observation ID'] = re.compile(r'^G[NS]-[0-9]{4}[AB]-([CQ]|DD|FT|LP|SV)-[0-9]{0,3}-[0-9]+$')\\n pattern['Data Labels'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\\n pattern['File Numbers'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\\n pattern['Dataset UT'] = re.compile(r'^[0-9]{2}:[0-9]{2}:[0-9]{2}$') # 09:58:15\\n pattern['Target Name'] = re.compile(r'[a-zA-Z0-9_-]+') # Match any string\\n pattern['Filters'] = re.compile(r'[A-Z0-9\\\\-]+') # H, XD, H2, X, J, H\\n pattern['Slit'] = re.compile(r'[a-zA-Z0-9]+') # 0.675, ACQ, LgPin\\n pattern['Grating/Wavelength'] = re.compile(r'[0-9]{2,3}/[0-9]\\\\.[0-9]{2}') # 32/1.65, 111/1.68\\n pattern['Camera/Prism'] = re.compile(r'[A-Z]{2}/[A-Z]{3}') # LB/MIR, SB/SXD\\n pattern['ExpTime/LNR/Coadds'] = re.compile(r'[0-9]+\\\\.[0-9]/[0-9]+/[0-9]+') # 0.2/1/25, 300.0/32/1\\n pattern['ACQ'] = re.compile(r'^Y*$') # Y or ''\\n\\n indx = {}\\n for line in data:\\n if 'Electronic Observing Log' in line:\\n date = line.split()[-1][7:]\\n logger.debug('Log date: %s', date)\\n if line[0:14] == 'Observation ID': # This defines the start of the header row\\n for h in header:\\n indx[h] = line.find(h) # Find where each column starts\\n break # No need to go farther\\n\\n width = {} # Find the width of each row\\n for i in range(len(header) - 1): # This requires that 'header' be an ordered array (not a dictionary)\\n width[header[i]] = indx[header[i + 1]] - indx[header[i]]\\n width[header[i+1]] = 1 # The ACQ field is either 'Y' or blank\\n\\n val = {}\\n match = {}\\n info = {}\\n for line in data:\\n logger.debug('\\\\n%s', line)\\n files = []\\n for h in header:\\n val[h] = line[indx[h]: indx[h] + width[h]].strip()\\n match[h] = re.match(pattern[h], val[h])\\n logger.debug('%s: \\\"%s\\\" %s' % (h, val[h], match[h]))\\n\\n # Maybe throw a warning if only match 1 fails; indicating a likely bad pattern specification?\\n\\n if None in match.values():\\n logger.debug('Failed to match all patterns -> This is a comment')\\n continue\\n\\n if '-' in val['File Numbers']:\\n start, stop = val['File Numbers'].split('-')\\n for i in range(int(start), int(stop)+1):\\n files.append(i)\\n else:\\n files.append(int(val['File Numbers']))\\n\\n for filenum in files:\\n f = 'N%sS%04d.fits' % (date, filenum)\\n logger.debug('File: %s', f)\\n info[f] = {}\\n for h in [header[0]] + header[3:]: # Skip 'Data Labels' and \\\"File Numbers'\\n info[f][h] = val[h]\\n\\n logger.debug('info: %s', info)\\n return info\",\n \"def read_file(self,file_name):\\r\\n data = np.genfromtxt(file_name)\\r\\n return data;\",\n \"def readogle(filename, **kw):\\n \\n # 2008-12-21 18:53 IJC: Created\\n\\n f = open(filename, 'r')\\n raw = f.readlines()\\n f.close()\\n\\n nstars = len(raw)\\n\\n raw2 = array([line.split() for line in raw])\\n ra = raw2[:,1]\\n dec = raw2[:,2]\\n xref = raw2[:,3]\\n yref = raw2[:,4]\\n vmag = raw2[:,5]\\n imag = raw2[:,7]\\n \\n xref = [map(float, [x]) for x in xref]\\n yref = [map(float, [y]) for y in yref]\\n vmag = [map(float, [v]) for v in vmag]\\n imag = [map(float, [i]) for i in imag]\\n\\n return (ra, dec, xref, yref, vmag, imag)\",\n \"def readImages(self):\\r\\n\\r\\n #Read the file camera.csv for the image file name\\r\\n lines = [line.strip() for line in open(self.cameraFile)]\\r\\n i = 0;\\r\\n\\tself.centers = []\\r\\n\\tself.lefts = []\\r\\n\\tself.rights = []\\r\\n\\r\\n for line in lines:\\r\\n info = line.split(',')\\r\\n \\r\\n\\r\\n if info[0] == 'seq':\\r\\n i += 1\\r\\n continue\\r\\n \\r\\n if info[4] == 'left_camera':\\r\\n self.lefts.append(info)\\r\\n if info[4] == 'center_camera':\\r\\n self.centers.append(info)\\r\\n if info[4] == 'right_camera':\\r\\n self.rights.append(info)\\r\\n i += 1\\r\\n\\r\\n print \\\"Total Frames: %d \\\" % (len(self.centers))\",\n \"def read(self, src):\\n self.read_mesh(src)\\n self.read_data(src)\",\n \"def readViewerOutputFile(lines, debug=False):\\n x = []; y = []\\n pixel = ''\\n xunits = 'unknown'\\n intensityUnits = 'unknown'\\n for line in lines:\\n if (line[0] == '#'): \\n if (line.find('pixel') > 0):\\n pixel = line.split('[[')[1].split(']]')[0]\\n elif (line.find('xLabel') > 0):\\n xunits = line.split()[-1]\\n if (debug):\\n print \\\"Read xunits = \\\", xunits\\n elif (line.find('yLabel') > 0):\\n tokens = line.split()\\n if (len(tokens) == 2):\\n intensityUnits = tokens[1]\\n else:\\n intensityUnits = tokens[1] + ' (' + tokens[2] + ')'\\n continue\\n tokens = line.split()\\n if (len(tokens) < 2): \\n continue\\n x.append(float(tokens[0]))\\n y.append(float(tokens[1]))\\n return(np.array(x), np.array(y), xunits, intensityUnits)\",\n \"def read_kitti_Tr_velo_to_cam(filename):\\n\\n with open(filename) as f:\\n for line in f:\\n data = line.split(' ')\\n if data[0] == 'Tr_velo_to_cam:':\\n calib = np.array([float(x) for x in data[1:13]])\\n calib = calib.reshape(3, 4)\\n return _extend_matrix(calib)\\n\\n raise Exception(\\n 'Could not find entry for P2 in calib file {}'.format(filename))\",\n \"def read(path):\",\n \"def read_filename(self, filename):\\r\\n self.text_lines = task3.read_text_file(filename)\",\n \"def _parse_txt(path, n_channels):\\n f = open(path)\\n lines = f.readlines()\\n f.close()\\n\\n geom = np.zeros((0, 2))\\n\\n for i, line in zip(range(n_channels), lines):\\n line = line.replace('\\\\r', '')\\n line = line.replace('\\\\n', '')\\n row = line.split(' ')\\n geom = np.vstack((geom, row[:2])).astype('float')\\n\\n return geom\",\n \"def read_from_file(self, filename: str) -> None:\",\n \"def read_txt_file(txt_file):\\n\\n img_paths = []\\n with open(txt_file, 'r') as f:\\n lines = f.readlines()\\n for line in lines:\\n line = line.strip()\\n items = line.split(' ')\\n img_paths.append(items[0])\\n return img_paths\",\n \"def Read_Rcwa_Matlab(Path) : \\n x,y=[],[]\\n fs = open(Path, 'r') \\n while 1: \\n txt = fs.readline()\\n if txt =='': \\n break\\n x.append(float(txt[0:25]))\\n y.append(float(txt[29:-2])) \\n fs.close()\\n return x,y\",\n \"def Read_txt_Image(Name):\\r\\n\\ttry:\\r\\n\\t\\twith open(Name, 'r') as f: #If the file already exists\\r\\n\\t\\t\\tx = f.readlines() #Readd all the rows and put them in a list\\r\\n\\texcept: \\r\\n\\t\\twith open(Name, 'w') as f: #If the file does not exist\\r\\n\\t\\t\\tx = [] #Create an empty list\\r\\n\\treturn x #This is the list that contains all the information for the file\\r\",\n \"def load_rational_camera_from_txt(cam_fname):\\n\\n from ._vpgl import _read_rational_camera_from_txt\\n\\n cam = _read_rational_camera_from_txt(cam_fname)\\n if cam:\\n return cam\\n else:\\n raise ValueError(\\\"Invalid camera file <{}>\\\".format(cam_fname))\",\n \"def read_psd_from_txt(filename):\\n data = loadtxt(filename)\\n return data\",\n \"def read_camera(self):\\n _, frame = self.camera.read()\\n return self.mirror(frame)\",\n \"def readTheFile(path, gui):\\n global names\\n global SAMPLES_PARTS\\n file = open(path, 'r')\\n names = file.readline().split()\\n names = names[5:]\\n SAMPLES_PARTS = [0, 0]\\n for name in names:\\n if \\\"Acute\\\" in name:\\n SAMPLES_PARTS[0] += 1\\n elif \\\"Chall\\\" in name:\\n SAMPLES_PARTS[1] += 1\\n SAMPLES_PARTS[1] += SAMPLES_PARTS[0]\\n line = file.readline()\\n data = []\\n counter = 1\\n gui.write_to_output(\\\"\\\\n\\\")\\n while line != '':\\n if counter % 1000 == 0:\\n gui.write_to_output(\\\"Done reading \\\" + str(counter) + \\\" lines\\\\n\\\", overwrite=True)\\n counter += 1\\n columns = line.split()\\n reads = np.array([float(x) for x in columns[5:]])\\n name = columns[0]\\n chrm = columns[1]\\n if chrm == \\\"chrM\\\":\\n line = file.readline()\\n continue\\n start = int(columns[2])\\n end = int(columns[3])\\n if abs(end - start) > 500:\\n line = file.readline()\\n continue\\n strand = columns[4]\\n data.append(Gene(name, reads, np.array([start, end]).astype(np.int), strand, chrm))\\n line = file.readline()\\n gui.write_to_output(\\\"Done reading \\\" + str(counter) + \\\" lines...Now sorting...\\\\n\\\", overwrite=True)\\n return list(sorted(data, key=lambda x: x.getName()))\",\n \"def readFT(self,file=\\\"out__1.ft\\\"):\",\n \"def read():\\n # TODO\",\n \"def readfile(file, sub_im, cr):\\n\\n root, ext = os.path.splitext(file)\\n\\n if ext == '.tif':\\n print('Reading tiff image:', file)\\n par = readpar(root + '.mli.par')\\n data = readtiff(file, sub_im, cr)\\n\\n else: # must be GAMMA flat binary float format\\n print('Reading flat binary image', file)\\n par = readpar(root + ext + '.par')\\n data = readmli(file, par, sub_im, cr)\\n\\n # extract relevant metadata\\n rho_r = float(par['range_pixel_spacing'].split()[0])\\n rho_a = float(par['azimuth_pixel_spacing'].split()[0])\\n theta = float(par['incidence_angle'].split()[0])\\n\\n return data, rho_r, rho_a, theta\",\n \"def read_file(path_to_file):\\n 8\",\n \"def parse_txt_file(txtfile):\\n array = np.genfromtxt(txtfile)\\n return array\",\n \"def file_parser(file_name):\\n h = 480\\n w = 640\\n out = []\\n with open(file_name, 'r') as f:\\n line_num = 1\\n for line in f:\\n if line_num < 17:\\n # Read to where data starts\\n line_num += 1\\n continue\\n elif line_num > 74:\\n break\\n # print(list(map(int, line.strip().split(\\\" \\\"))))\\n vals = line.split()\\n # print(list(\\\"\\\".join(line)))\\n # print(line.split())\\n assert(float(vals[2]) < 640)\\n assert(float(vals[3]) < 480)\\n point = [float(vals[2]) * w, float(vals[3]) * h]\\n # print(point)\\n out.append(point)\\n line_num += 1\\n\\n out.append([0,0])\\n out.append([w-1, 0])\\n out.append([0, h-1])\\n out.append([w-1, h-2])\\n return out\",\n \"def readFastaFile(filename):\",\n \"def _read_data(self, txtfile):\\n data_string = open(txtfile,'r').read()\\n return data_string\",\n \"def _read_input_file(self, path: Path):\\n img = cv2.imread(str(path))\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # shape: (H, W, C)\\n return img\",\n \"def read_reference():\\n global reference\\n reference = cv2.imread(REFERENCE)\\n print(reference)\\n print(reference.shape)\",\n \"def Read_RMCA_basic(Complete_Path):\\n fid = open(Complete_Path,'r')\\n S = []\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n S.append(float(line))\\n #R.append(float(line[27:-2]))\\n return np.array(S)\",\n \"def readtext(tpath):\\r\\n t1=tpath\\r\\n i = []\\r\\n #check whether text existed\\r\\n if os.path.exists(t1):\\r\\n t2=os.path.split(t1)[0]\\r\\n #print(t2)\\r\\n with open(tpath) as f:\\r\\n lines=f.readlines()\\r\\n for line in lines:\\r\\n # get all the image names in the text file\\r\\n line=line.split('\\\\n')[0]\\r\\n #generate images' absolute path\\r\\n line=t2+'/'+line\\r\\n i.append(line)\\r\\n f.close()\\r\\n return i\\r\\n else:\\r\\n print(i)\\r\\n return False\",\n \"def test_file_read():\\n expected = [\\\"scorevideo LOG\\\\n\\\", \\\"File: log.mat\\\"]\\n with open(TEST_RES + \\\"/file_read.txt\\\", 'r') as file:\\n actual = file.readlines()\\n assert expected == actual\",\n \"def open_and_read_file(file_path):\\n text_data = open(file_path).read()\\n # print text_data\\n return text_data\",\n \"def readmovie(addr, ftype='xyz', frameformat='aio'):\\n \\n f = open(addr, 'r')\\n allcoords = []\\n \\n if ftype == 'xyz':\\n \\n while True:\\n \\n try:\\n natoms = int(f.readline())\\n f.readline()\\n atoms, coords = [], []\\n \\n for x in range(natoms):\\n line = f.readline().split()\\n atoms.append(line[0])\\n coords.append(line[1:])\\n \\n allcoords.append(coords)\\n \\n except:\\n \\n break\\n \\n # Assemble the read coordinates into a dictionary\\n nframes = len(allcoords)\\n out = {}\\n out['atoms'] = atoms\\n \\n if frameformat == 'aio':\\n out['frames'] = np.asarray(allcoords, dtype='float64')\\n elif frameformat == 'sep':\\n for i in range(nframes):\\n out[str(i)] = np.asarray(allcoords[i], dtype='float64')\\n \\n return out\",\n \"def read_file(self, currentIndex):\\n handle = open(\\\"Program Files\\\\\\\\\\\" + str(currentIndex) + \\\".tvInfo\\\", \\\"r\\\")\\n data = handle.read() #reading description\\n handle.close()\\n return data\",\n \"def readVideo(self):\\n vid = cv2.VideoCapture(self.fname)\\n imgstack = []\\n # grab = True\\n grab, img = vid.read()\\n while grab:\\n imgstack.append(\\n Frame(\\n cv2.cvtColor(img, cv2.COLOR_BGR2GRAY),\\n self.starttime\\n + datetime.timedelta(seconds=self.frame_dt * self.length),\\n )\\n )\\n self.length += 1\\n grab, img = vid.read()\\n self.frames = imgstack\",\n \"def read_file(file_name):\\n fits_file = fits.open(file_name)\\n\\n header = fits_file[0].header\\n image_data = fits_file[1].data\\n\\n segmentation_data = fits_file[2].data\\n\\n header_keywords = {'CRVAL3': 0, 'CRPIX3': 0, 'CD3_3': 0}\\n # clause to differentiate between CDELT3 and CD3_3\\n\\n for hdr_key, hdr_value in header_keywords.items():\\n # finding required header values\\n hdr_value = header[hdr_key]\\n header_keywords[hdr_key] = hdr_value\\n\\n return header_keywords, image_data, segmentation_data\",\n \"def read_file(file):\\n if opts.input_type == 'fits':\\n data = fileio.read_fits(file)\\n else:\\n data = fileio.read_ascii(file)\\n c_id = data[0,:]\\n g_num = np.array(range(len(c_id)), dtype = 'int')\\n g_id = data[3,:]\\n g_ra = np.array(data[4,:], dtype = 'float')\\n g_dec = np.array(data[5,:], dtype = 'float')\\n g_z = np.array(data[6,:], dtype = 'float')\\n return c_id, g_num, g_id, g_ra, g_dec, g_z\",\n \"def read_file(self, currentIndex):\\n handle = open(\\\"Program Files\\\\\\\\TvInfo\\\\\\\\\\\" + str(currentIndex) + \\\".tvInfo\\\", \\\"r\\\")\\n data = handle.read() #reading description\\n handle.close()\\n return data\",\n \"def read_file(self):\\n try:\\n with open(self.file_name, 'r') as ach_file:\\n file_contents = ach_file.read().replace('\\\\n', '').replace('\\\\r', '')\\n\\n self._parse_ach_file(file_contents)\\n except FileNotFoundError as err:\\n print(\\\"File does not exist -> \\\" + str(err))\",\n \"def readImage(self, path, tt=1):\\n return cv2.imread( path, tt)\",\n \"def Read_RMCA_out(Complete_Path):\\n fid = open(Complete_Path,'r')\\n L,R = [],[]\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n L.append(float(line[:25]))\\n R.append(float(line[27:-2]))\\n return np.array(L),np.array(R)\",\n \"def read_file(self, fullname):\\n\\n data = np.genfromtxt(fullname, dtype=None, names=True, skip_header=0)\\n return data\",\n \"def readfile(self, path, filename):\\n # The DataStudio software uses ISO-8859-1 encoding (especially for the degree sign in temperature files)\\n file = open(path + filename, encoding=\\\"iso-8859-1\\\")\\n rowlist = file.readlines()\\n\\n title = rowlist[0].strip(\\\"\\\\n\\\")\\n labels = rowlist[1].strip(\\\"\\\\n\\\").split(sep=\\\"\\\\t\\\")\\n\\n data = np.zeros((len(rowlist)-2, 2))\\n\\n for i in range(2, len(rowlist)):\\n columns = rowlist[i].split(sep=\\\"\\\\t\\\")\\n data[i-2, 0] = float(columns[0].replace(\\\",\\\", \\\".\\\"))\\n data[i-2, 1] = float(columns[1].replace(\\\",\\\", \\\".\\\"))\\n\\n return data, title, labels\",\n \"def _read_datafile(self,path):\\n \\tlabels, images = [], []\\n \\twith gzip.GzipFile(path) as f:\\n \\t for line in f:\\n \\t vals = line.strip().split()\\n \\t labels.append(float(vals[0]))\\n \\t images.append([float(val) for val in vals[1:]])\\n \\tlabels = np.array(labels, dtype=np.int32)\\n \\tlabels[labels == 10] = 0 # fix weird 0 labels\\n \\timages = np.array(images, dtype=np.float32).reshape(-1, 16, 16, 1)\\n \\timages = (images + 1) / 2\\n \\treturn images, labels\",\n \"def loadLogo():\\n #On charge le fichier logo\\n f = open('ASCII.art', 'rb')\\n #On recupere les lignes\\n lines = f.readlines() \\n #On ferme le fichier\\n f.close()\\n return lines\",\n \"def read_file(filename):\\n reads = []\\n labels = []\\n\\n with open(filename) as f:\\n content = f.readlines()\\n\\n for line in content:\\n _, read, label = re.sub('[null\\\\t\\\\n\\\\[\\\\]\\\\\\\"]', '', line).replace(' ', '').split(',')\\n reads.append(read)\\n labels.append(label)\\n \\n return reads, labels\",\n \"def do_readsourcefile(self, file_name):\\r\\n self.file_name = file_name\\r\\n f = open(self.file_name, \\\"r\\\")\\r\\n print(f.read())\\r\\n f.close()\",\n \"def read_spe(spefilename, verbose=False):\\n \\n # open SPE file as binary input\\n spe = open(spefilename, \\\"rb\\\")\\n \\n # Header length is a fixed number\\n nBytesInHeader = 4100\\n\\n # Read the entire header\\n header = spe.read(nBytesInHeader)\\n \\n # version of WinView used\\n swversion = struct.unpack_from(\\\"16s\\\", header, offset=688)[0]\\n \\n # version of header used\\n # Eventually, need to adjust the header unpacking\\n # based on the headerVersion. \\n headerVersion = struct.unpack_from(\\\"f\\\", header, offset=1992)[0]\\n \\n # which camera controller was used?\\n controllerVersion = struct.unpack_from(\\\"h\\\", header, offset=0)[0]\\n if verbose:\\n print (\\\"swversion = \\\", swversion)\\n print (\\\"headerVersion = \\\", headerVersion)\\n print (\\\"controllerVersion = \\\", controllerVersion)\\n \\n # Date of the observation\\n # (format is DDMONYYYY e.g. 27Jan2009)\\n date = struct.unpack_from(\\\"9s\\\", header, offset=20)[0]\\n \\n # Exposure time (float)\\n exp_sec = struct.unpack_from(\\\"f\\\", header, offset=10)[0]\\n \\n # Intensifier gain\\n pimaxGain = struct.unpack_from(\\\"h\\\", header, offset=148)[0]\\n\\n # Not sure which \\\"gain\\\" this is\\n gain = struct.unpack_from(\\\"H\\\", header, offset=198)[0]\\n \\n # Data type (0=float, 1=long integer, 2=integer, 3=unsigned int)\\n data_type = struct.unpack_from(\\\"h\\\", header, offset=108)[0]\\n\\n comments = struct.unpack_from(\\\"400s\\\", header, offset=200)[0]\\n\\n # CCD Chip Temperature (Degrees C)\\n detectorTemperature = struct.unpack_from(\\\"f\\\", header, offset=36)[0]\\n\\n # The following get read but are not used\\n # (this part is only lightly tested...)\\n analogGain = struct.unpack_from(\\\"h\\\", header, offset=4092)[0]\\n noscan = struct.unpack_from(\\\"h\\\", header, offset=34)[0]\\n pimaxUsed = struct.unpack_from(\\\"h\\\", header, offset=144)[0]\\n pimaxMode = struct.unpack_from(\\\"h\\\", header, offset=146)[0]\\n\\n ########### here's from Kasey\\n #int avgexp 2 number of accumulations per scan (why don't they call this \\\"accumulations\\\"?)\\n #TODO: this isn't actually accumulations, so fix it... \\n accumulations = struct.unpack_from(\\\"h\\\", header, offset=668)[0]\\n if accumulations == -1:\\n # if > 32767, set to -1 and \\n # see lavgexp below (668) \\n #accumulations = struct.unpack_from(\\\"l\\\", header, offset=668)[0]\\n # or should it be DWORD, NumExpAccums (1422): Number of Time experiment accumulated \\n accumulations = struct.unpack_from(\\\"l\\\", header, offset=1422)[0]\\n \\n \\\"\\\"\\\"Start of X Calibration Structure (although I added things to it that I thought were relevant,\\n like the center wavelength...\\\"\\\"\\\"\\n xcalib = {}\\n \\n #SHORT SpecAutoSpectroMode 70 T/F Spectrograph Used\\n xcalib['SpecAutoSpectroMode'] = bool( struct.unpack_from(\\\"h\\\", header, offset=70)[0] )\\n\\n #float SpecCenterWlNm # 72 Center Wavelength in Nm\\n xcalib['SpecCenterWlNm'] = struct.unpack_from(\\\"f\\\", header, offset=72)[0]\\n \\n #SHORT SpecGlueFlag 76 T/F File is Glued\\n xcalib['SpecGlueFlag'] = bool( struct.unpack_from(\\\"h\\\", header, offset=76)[0] )\\n\\n #float SpecGlueStartWlNm 78 Starting Wavelength in Nm\\n xcalib['SpecGlueStartWlNm'] = struct.unpack_from(\\\"f\\\", header, offset=78)[0]\\n\\n #float SpecGlueEndWlNm 82 Starting Wavelength in Nm\\n xcalib['SpecGlueEndWlNm'] = struct.unpack_from(\\\"f\\\", header, offset=82)[0]\\n\\n #float SpecGlueMinOvrlpNm 86 Minimum Overlap in Nm\\n xcalib['SpecGlueMinOvrlpNm'] = struct.unpack_from(\\\"f\\\", header, offset=86)[0]\\n\\n #float SpecGlueFinalResNm 90 Final Resolution in Nm\\n xcalib['SpecGlueFinalResNm'] = struct.unpack_from(\\\"f\\\", header, offset=90)[0]\\n\\n # short BackGrndApplied 150 1 if background subtraction done\\n xcalib['BackgroundApplied'] = struct.unpack_from(\\\"h\\\", header, offset=150)[0]\\n BackgroundApplied=False\\n if xcalib['BackgroundApplied']==1: BackgroundApplied=True\\n\\n # float SpecGrooves 650 Spectrograph Grating Grooves\\n xcalib['SpecGrooves'] = struct.unpack_from(\\\"f\\\", header, offset=650)[0]\\n\\n # short flatFieldApplied 706 1 if flat field was applied.\\n xcalib['flatFieldApplied'] = struct.unpack_from(\\\"h\\\", header, offset=706)[0]\\n flatFieldApplied=False\\n if xcalib['flatFieldApplied']==1: flatFieldApplied=True\\n \\n #double offset # 3000 offset for absolute data scaling */\\n xcalib['offset'] = struct.unpack_from(\\\"d\\\", header, offset=3000)[0]\\n\\n #double factor # 3008 factor for absolute data scaling */\\n xcalib['factor'] = struct.unpack_from(\\\"d\\\", header, offset=3008)[0]\\n \\n #char current_unit # 3016 selected scaling unit */\\n xcalib['current_unit'] = struct.unpack_from(\\\"c\\\", header, offset=3016)[0]\\n\\n #char reserved1 # 3017 reserved */\\n xcalib['reserved1'] = struct.unpack_from(\\\"c\\\", header, offset=3017)[0]\\n\\n #char string[40] # 3018 special string for scaling */\\n xcalib['string'] = struct.unpack_from(\\\"40c\\\", header, offset=3018)\\n \\n #char reserved2[40] # 3058 reserved */\\n xcalib['reserved2'] = struct.unpack_from(\\\"40c\\\", header, offset=3058)\\n\\n #char calib_valid # 3098 flag if calibration is valid */\\n xcalib['calib_valid'] = struct.unpack_from(\\\"c\\\", header, offset=3098)[0]\\n\\n #char input_unit # 3099 current input units for */\\n xcalib['input_unit'] = struct.unpack_from(\\\"c\\\", header, offset=3099)[0]\\n \\\"\\\"\\\"/* \\\"calib_value\\\" */\\\"\\\"\\\"\\n\\n #char polynom_unit # 3100 linear UNIT and used */\\n xcalib['polynom_unit'] = struct.unpack_from(\\\"c\\\", header, offset=3100)[0]\\n \\\"\\\"\\\"/* in the \\\"polynom_coeff\\\" */\\\"\\\"\\\"\\n\\n #char polynom_order # 3101 ORDER of calibration POLYNOM */\\n xcalib['polynom_order'] = struct.unpack_from(\\\"c\\\", header, offset=3101)[0]\\n\\n #char calib_count # 3102 valid calibration data pairs */\\n xcalib['calib_count'] = struct.unpack_from(\\\"c\\\", header, offset=3102)[0]\\n\\n #double pixel_position[10];/* 3103 pixel pos. of calibration data */\\n xcalib['pixel_position'] = struct.unpack_from(\\\"10d\\\", header, offset=3103)\\n\\n #double calib_value[10] # 3183 calibration VALUE at above pos */\\n xcalib['calib_value'] = struct.unpack_from(\\\"10d\\\", header, offset=3183)\\n\\n #double polynom_coeff[6] # 3263 polynom COEFFICIENTS */\\n xcalib['polynom_coeff'] = struct.unpack_from(\\\"6d\\\", header, offset=3263)\\n\\n #double laser_position # 3311 laser wavenumber for relativ WN */\\n xcalib['laser_position'] = struct.unpack_from(\\\"d\\\", header, offset=3311)[0]\\n\\n #char reserved3 # 3319 reserved */\\n xcalib['reserved3'] = struct.unpack_from(\\\"c\\\", header, offset=3319)[0]\\n\\n #unsigned char new_calib_flag # 3320 If set to 200, valid label below */\\n #xcalib['calib_value'] = struct.unpack_from(\\\"BYTE\\\", header, offset=3320)[0] # how to do this?\\n\\n #char calib_label[81] # 3321 Calibration label (NULL term'd) */\\n xcalib['calib_label'] = struct.unpack_from(\\\"81c\\\", header, offset=3321)\\n\\n #char expansion[87] # 3402 Calibration Expansion area */\\n xcalib['expansion'] = struct.unpack_from(\\\"87c\\\", header, offset=3402)\\n ########### end of Kasey's addition\\n\\n if verbose:\\n print (\\\"date = [\\\"+date+\\\"]\\\")\\n print (\\\"exp_sec = \\\", exp_sec)\\n print (\\\"pimaxGain = \\\", pimaxGain)\\n print (\\\"gain (?) = \\\", gain)\\n print (\\\"data_type = \\\", data_type)\\n print (\\\"comments = [\\\"+comments+\\\"]\\\")\\n print (\\\"analogGain = \\\", analogGain)\\n print (\\\"noscan = \\\", noscan)\\n print (\\\"detectorTemperature [C] = \\\", detectorTemperature)\\n print (\\\"pimaxUsed = \\\", pimaxUsed)\\n\\n # Determine the data type format string for\\n # upcoming struct.unpack_from() calls\\n if data_type == 0:\\n # float (4 bytes)\\n dataTypeStr = \\\"f\\\" #untested\\n bytesPerPixel = 4\\n dtype = \\\"float32\\\"\\n elif data_type == 1:\\n # long (4 bytes)\\n dataTypeStr = \\\"l\\\" #untested\\n bytesPerPixel = 4\\n dtype = \\\"int32\\\"\\n elif data_type == 2:\\n # short (2 bytes)\\n dataTypeStr = \\\"h\\\" #untested\\n bytesPerPixel = 2\\n dtype = \\\"int32\\\"\\n elif data_type == 3: \\n # unsigned short (2 bytes)\\n dataTypeStr = \\\"H\\\" # 16 bits in python on intel mac\\n bytesPerPixel = 2\\n dtype = \\\"int32\\\" # for numpy.array().\\n # other options include:\\n # IntN, UintN, where N = 8,16,32 or 64\\n # and Float32, Float64, Complex64, Complex128\\n # but need to verify that pyfits._ImageBaseHDU.ImgCode cna handle it\\n # right now, ImgCode must be float32, float64, int16, int32, int64 or uint8\\n else:\\n print (\\\"unknown data type\\\")\\n print (\\\"returning...\\\")\\n sys.exit()\\n \\n # Number of pixels on x-axis and y-axis\\n nx = struct.unpack_from(\\\"H\\\", header, offset=42)[0]\\n ny = struct.unpack_from(\\\"H\\\", header, offset=656)[0]\\n \\n # Number of image frames in this SPE file\\n nframes = struct.unpack_from(\\\"l\\\", header, offset=1446)[0]\\n\\n if verbose:\\n print (\\\"nx, ny, nframes = \\\", nx, \\\", \\\", ny, \\\", \\\", nframes)\\n \\n npixels = nx*ny\\n npixStr = str(npixels)\\n fmtStr = npixStr+dataTypeStr\\n if verbose:\\n print (\\\"fmtStr = \\\", fmtStr)\\n \\n # How many bytes per image?\\n nbytesPerFrame = npixels*bytesPerPixel\\n if verbose:\\n print (\\\"nbytesPerFrame = \\\", nbytesPerFrame)\\n\\n # Create a dictionary that holds some header information\\n # and contains a placeholder for the image data\\n spedict = {'data':[], # can have more than one image frame per SPE file\\n 'IGAIN':pimaxGain,\\n 'EXPOSURE':exp_sec,\\n 'SPEFNAME':spefilename,\\n 'OBSDATE':date,\\n 'CHIPTEMP':detectorTemperature,\\n 'COMMENTS':comments,\\n 'XCALIB':xcalib,\\n 'ACCUMULATIONS':accumulations,\\n 'FLATFIELD':flatFieldApplied,\\n 'BACKGROUND':BackgroundApplied\\n }\\n \\n # Now read in the image data\\n # Loop over each image frame in the image\\n if verbose:\\n print (\\\"Reading image frames number \\\"),\\n for ii in range(nframes):\\n iistr = str(ii)\\n data = spe.read(nbytesPerFrame)\\n if verbose:\\n print (iistr,\\\" \\\",)\\n \\n # read pixel values into a 1-D numpy array. the \\\"=\\\" forces it to use\\n # standard python datatype size (4bytes for 'l') rather than native\\n # (which on 64bit is 8bytes for 'l', for example).\\n # See http://docs.python.org/library/struct.html\\n dataArr = np.array(struct.unpack_from(\\\"=\\\"+fmtStr, data, offset=0),\\n dtype=dtype)\\n\\n # Resize array to nx by ny pixels\\n # notice order... (y,x)\\n dataArr.resize((ny, nx))\\n #print dataArr.shape\\n\\n # Push this image frame data onto the end of the list of images\\n # but first cast the datatype to float (if it's not already)\\n # this isn't necessary, but shouldn't hurt and could save me\\n # from doing integer math when i really meant floating-point...\\n spedict['data'].append( dataArr.astype(float) )\\n\\n if verbose:\\n print (\\\"\\\")\\n \\n return spedict\",\n \"def read_file(self, *args, **kwargs):\\n if self.detector == \\\"FACET\\\":\\n return self.read_facet(self.filename)\\n elif self.detector == \\\"OpenFace\\\":\\n return self.read_openface(self.filename)\\n elif self.detector == \\\"Affectiva\\\":\\n return self.read_affectiva(self.filename)\\n elif self.detector == \\\"Feat\\\":\\n return self.read_feat(self.filename)\\n else:\\n print(\\\"Must specifiy which detector [Feat, FACET, OpenFace, or Affectiva]\\\")\",\n \"def return_file_read(_):\\n return [\\\"scorevideo LOG\\\", \\\"File: log.mat\\\"]\",\n \"def readFlow(fn):\\n with open(fn, 'rb') as f:\\n magic = np.fromfile(f, np.float32, count=1)\\n if 202021.25 != magic:\\n print('Magic number incorrect. Invalid .flo file')\\n return None\\n else:\\n w = np.fromfile(f, np.int32, count=1)\\n h = np.fromfile(f, np.int32, count=1)\\n # print 'Reading %d x %d flo file\\\\n' % (w, h)\\n data = np.fromfile(f, np.float32, count=2*int(w)*int(h))\\n # Reshape data into 3D array (columns, rows, bands)\\n # The reshape here is for visualization, the original code is (w,h,2)\\n return np.resize(data, (int(h), int(w), 2))\",\n \"def file_read(file_name):\\n \\n #open specified file in read mode\\n in_file = open(file_name, \\\"r\\\")\\n \\n #create data lists\\n sp_length_v3 = []\\n sp_period_v3 = [] \\n\\n #save header to string and split into list\\n header_string = in_file.readline()\\n header_v3 = header_string.split()\\n \\n #save revelent data to respective lists\\n for line in in_file:\\n values = line.split()\\n sp_length_v3.append(float(values[1]))\\n sp_period_v3.append(float(values[2]))\\n \\n #close the file\\n in_file.close()\\n \\n #return 3D lists of lists containing data\\n ans = [sp_length_v3, sp_period_v3, header_v3]\\n \\n return ans\",\n \"def read_file(testing_file):\\n samples = []\\n with open(testing_file, 'r') as in_file:\\n for line in in_file:\\n info = line.strip('\\\\n').split()\\n samples.append((info[0], info[1]))\\n return samples\",\n \"def readin():\\r\\n nodes = np.loadtxt('Vnodes.txt', ndmin=2)\\r\\n mats = np.loadtxt('Vmater.txt', ndmin=2)\\r\\n elements = np.loadtxt('Veles.txt', ndmin=2)\\r\\n loads = np.loadtxt('Vloads.txt', ndmin=2)\\r\\n return nodes, mats, elements, loads\",\n \"def openfile(filename):\\n Data = np.genfromtxt(filename, delimiter = \\\",\\\")\\n data = [[]]\\n for i in range(np.shape(Data)[0]):\\n #Stores information row-by-row\\n data.append(Data[i][0:])\\n return data\",\n \"def read_text_file(str_name_file: str):\\n content: str = ''\\n with open(str_name_file, mode=\\\"r\\\", encoding='utf-8') as file:\\n print(\\\"file being read: \\\" + str_name_file + \\\"\\\\n\\\")\\n content = file.read()\\n return content\",\n \"def read(self):\\n\\n with open(self.path, 'r') as to_read:\\n reader = csv.reader(to_read)\\n _ = reader.next()\\n camera_vals = []\\n velocities = []\\n for row in reader:\\n camera_vals.append(row[:len(camera_headers)])\\n velocities.append(row[len(camera_headers):][0])\\n velocities = [[int(x) for x in string] for string in velocities]\\n camera_vals = camera_vals[::downsample_constant]\\n velocities = velocities[::downsample_constant]\\n return (\\n [[float(x) for x in row] for row in camera_vals],\\n velocities\\n )\",\n \"def read_raw(rawfile, shape, dtype=np.uint16, kind='middleton'):\\n\\n # -- alert\\n print(\\\"READ_RAW: reading {0}...\\\".format(rawfile))\\n\\n\\n # -- read file\\n if kind=='middleton':\\n return np.fromfile(open(rawfile),dtype) \\\\\\n .reshape(shape[2],shape[0],shape[1])[:,:,::-1] \\\\\\n .transpose(1,2,0) \\\\\\n .astype(float)\",\n \"def read_projection_image(self, fname):\\r\\n\\r\\n if self.fileExt == 'dm4':\\r\\n file = dm.FileDM(fname)\\r\\n alphaTag = '.ImageList.2.ImageTags.Microscope Info.'\\\\\\r\\n 'Stage Position.Stage Alpha'\\r\\n return (file.getDataset(0)['data'], file.allTags[alphaTag])\\r\\n elif self.fileExt == 'ser':\\r\\n file = ser.SerReader(fname)\\r\\n return (file['data'], file['metadata']['Stage A [deg]'])\\r\\n # Stage Alpha isn't stored in metadata for dm3 or tif\\r\\n elif self.fileExt == 'dm3':\\r\\n # Parse fname for stage alpha\\r\\n file = dm.FileDM(fname)\\r\\n\\r\\n match = 'degrees'\\r\\n tags = fname.split('_')\\r\\n\\r\\n angle = [tag for tag in tags if match in tag][0]\\r\\n angleInd = angle.find(match)\\r\\n return (file.getDataset(0)['data'], float(angle[:angleInd]))\",\n \"def read_txt(path):\\n mz = []\\n i = []\\n with open(path) as f:\\n for line in f:\\n line = line.split()\\n mz.append(float(line[0]))\\n i.append(float(line[1]))\\n return mz, i\",\n \"def load_data(file_to_read):\\n\\n data = np.recfromtxt(file_to_read)\\n data = np.asarray(data)\\n\\n return data\",\n \"def load_vo_txt_raw(*, fname, sampling='1M'):\\n # Set the day of month for time series depending on the MF sampling rate\\n if sampling == '1M':\\n day = 15\\n elif sampling == '4M':\\n day = 1\\n\\n # Positions given in degrees - co-latitude (0 to 180), longitude (\\n df = pd.read_csv(fname, sep=\\\"\\\\s+\\\", header=14,\\n names=[\\\"theta\\\", \\\"phi\\\", \\\"Year\\\", \\\"Month\\\", \\\"Time\\\", \\\"r\\\",\\n \\\"Br\\\", \\\"Btheta\\\", \\\"Y\\\", \\\"sigma_r\\\", \\\"sigma_theta\\\",\\n \\\"sigma_phi\\\", \\\"N_data\\\"], usecols=range(13))\\n\\n df[\\\"mjd2000\\\"] = mjd2000(df[\\\"Year\\\"], df[\\\"Month\\\"], day)\\n df[\\\"dyear\\\"] = mjd_to_dyear(df[\\\"mjd2000\\\"], leap_year=True)\\n df[\\\"X\\\"] = -df[\\\"Btheta\\\"] # -theta component\\n df[\\\"Z\\\"] = -df[\\\"Br\\\"] # -radial component\\n df.drop(columns=[\\\"Btheta\\\", \\\"Br\\\"], inplace=True)\\n # To 00:00 on 1st or 15th each month\\n # Multiplication by 10000 and 100 are needed to convert to datetime\\n # (see documentation for pandas.datetime)\\n df[\\\"date\\\"] = pd.to_datetime(df[\\\"Year\\\"]*10000+df[\\\"Month\\\"]*100+day,\\n format=\\\"%Y%m%d\\\")\\n\\n return df\",\n \"def loadtrkfile(T_filename, threshold_short_streamlines=10.0):\\r\\n print(\\\"Loading %s\\\" % T_filename)\\r\\n T, hdr = trackvis.read(T_filename, as_generator=False)\\r\\n T = np.array([s[0] for s in T], dtype=np.object)\\r\\n \\r\\n\\r\\n \\r\\n return T, hdr\",\n \"def readpil3d(self):\\r\\n\\r\\n # Read the data in as an array.\\r\\n res = np.loadtxt(self.name, delimiter=' ')\\r\\n\\r\\n # Split into useful chunks\\r\\n self.pos = res[:, 0:3] # Grid point locations\\r\\n self.Pn = res[:, 3:4] # Normal pressure [Pa]\\r\\n self.flux = res[:, -1] # Flux\\r\",\n \"def read_positions():\\n return np.genfromtxt(\\\"POSITIONS.OUT\\\").transpose()\",\n \"def read_from(self, filename):\\n self.x, self.y = np.loadtxt(filename, unpack=True, usecols=(0, 1))\",\n \"def read_file(file):\\n f = open(file, 'r')\\n print(f.read())\",\n \"def read_rcm(self, rcmFilename = \\\"tsunami.rcm\\\"):\\n file_in = open(rcmFilename,\\\"r\\\").readlines()\",\n \"def read(self, filename):\\n raise NotImplementedError\",\n \"def read(self, filename): # real signature unknown; restored from __doc__\\n pass\",\n \"def Read_t_file(file_name):\\n t=[]\\n \\n with open(file_name,'r') as reader:\\n temp=reader.readline().strip().split()[-1].split('-')\\n t.append(temp[0])\\n t.append(temp[1])\\n for line in reader.readlines():\\n t.append(line.strip().split()[-1].split('-')[-1])\\n \\n return np.array(t,dtype=np.float32)\",\n \"def read_file(self,fname):\\n try:\\n self.raw=spiketrain.read_file(fname)\\n except Exception:\\n self.raw=None\\n raise\",\n \"def read_file(self, file_path): \\n logging.info('Lendo arquivo de {0}'.format(file_path))\\n file_with_tags = open(file_path, \\\"r\\\", encoding='utf-8')\\n return file_with_tags.readlines()\",\n \"def read_file(log_file):\\n\\t\\tfile = open(log_file, 'r')\\n\\t\\tresult = []\\n\\t\\twhile 1:\\n\\t\\t\\tcontent = file.readline()\\n\\t\\t\\tif not content:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = content.split(\\\"\\\\003\\\")\\n\\t\\t\\t\\tif len(data) == 13:\\n\\t\\t\\t\\t\\ttrack = {\\n\\t\\t\\t\\t\\t\\t\\t 'device_no' : long(data[0][3:]), 'sim' : data[1], 'type':int(data[2]), 'gps_time' : MongoTrack.time_trans(data[3]),\\n\\t\\t\\t\\t\\t\\t\\t 'valid' : data[4], 'loc':{'long' : float(data[5]), 'lat' : float(data[6]) }, 'altitude' : float(data[7]),\\n\\t\\t\\t\\t\\t\\t\\t 'speed' : float(data[8]), 'course' : float(data[9]), 'km' : float(data[10]), 'para' : float(data[11]),\\n\\t\\t\\t\\t\\t\\t\\t 'rtime' : MongoTrack.time_trans(data[12].strip())\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tresult.append(track)\\n\\t\\tfile.close()\\n\\t\\treturn result\",\n \"def display_seqres_seq():\\n \\n import os\\n choice = input('Enter the name of the file: ')\\n filepath = os.path.join('/home/njesh/python-mini-project-JaneNjeri/Data', choice)\\n with open(filepath, 'r') as file:\\n for line in file:\\n if line[:6] == 'SEQRES':\\n line_split = line.split()[4:]\\n print(line_split)\\n return file\",\n \"def _read_from_file(self, filename):\\n ff = fits.open(filename)\\n # Load the normalized intensity\\n self.norm_int = ff[0].data\\n # Load the other parameters\\n self.lam = ff[1].data['lam']\\n self.lam_unit = ff[1].columns['lam'].unit\\n self.theta = ff[2].data['theta']\\n self.taux = ff[3].data['taux']\\n # Set halo type\\n self.description = filename\",\n \"def get_textimage(fname):\\n \\tfrom string import atoi,atof\\n \\tinfile = open(fname)\\n\\tlines = infile.readlines()\\n\\tinfile.close()\\n\\tdata = lines[0].split()\\n\\tnx = atoi(data[0])\\n\\tny = atoi(data[1])\\n\\tnz = atoi(data[2])\\n\\te = EMData()\\n\\te.set_size(nx, ny, nz)\\n\\te.to_zero()\\n\\tfor line in lines[1:]:\\n\\t\\tdata = line.split()\\n\\t\\tix = atoi(data[0])\\n\\t\\tiy = atoi(data[1])\\n\\t\\tiz = atoi(data[2])\\n\\t\\tval = atof(data[3])\\n\\t\\te[ix,iy,iz] = val\\n\\treturn e\",\n \"def readInput(in_file_name):\\n in_file = open(in_file_name, 'r')\\n positions = []\\n samples = []\\n M = []; P = [];\\n MC = []; PC = [];\\n while True:\\n line = in_file.readline()\\n if not line: break\\n if line[0] == '#': continue #skip comment\\n line = line.rstrip('\\\\n').split('\\\\t')\\n \\n #genomic positions and allele support in plasma samples\\n positions.append(int(line[0]))\\n samples.append(tuple(map(int, line[1:5])))\\n \\n #maternal and paternal alleles\\n M.append(tuple(line[5:7]))\\n MC.append(tuple(map(float, line[7:9])))\\n \\n P.append(tuple(line[9:11]))\\n PC.append(tuple(map(float, line[11:13]))) \\n \\n in_file.close()\\n return positions, samples, M, P, MC, PC\",\n \"def simple_text_reader(text_file):\\n with open(text_file, 'rt') as file:\\n data = file.read()\\n return data\",\n \"def load_text(path):\\n\\n with open(path) as f:\\n read_text = f.read().splitlines()\\n \\n return np.array(read_text)\",\n \"def read_flow(filename):\\n with open(filename, 'rb') as f:\\n magic = np.fromfile(f, np.float32, count=1)\\n if 202021.25 != magic:\\n print('Magic number incorrect. Invalid .flo file')\\n else:\\n w = np.fromfile(f, np.int32, count=1)\\n h = np.fromfile(f, np.int32, count=1)\\n data = np.fromfile(f, np.float32, count=int(2*w*h))\\n # Reshape data into 3D array (columns, rows, bands)\\n return np.resize(data, (h[0], w[0], 2))\",\n \"def read_text_file(text_file):\\n try:\\n with open(text_file, \\\"rb\\\") as f:\\n text = tf.compat.as_str(f.read()) \\n except Exception as e:\\n print(\\\"Unable to open\\\", text_file, \\\":\\\", e)\\n raise\\n return text\",\n \"def open_raw(path):\\r\\n raw_file_reader = RawFileReader.RawFileReaderAdapter.FileFactory(path)\\r\\n raw_file_reader.SelectInstrument(Business.Device.UV, 1)\\r\\n return raw_file_reader\",\n \"def read_file(self):\\n # This is quite ugly but works for now.\\n self.header = read_csv(self.file_name, delim_whitespace=True,\\n header=TrackData.header_line,\\n nrows=1).to_dict(orient='index')[0]\\n self.data = read_csv(self.file_name, delim_whitespace=True, \\n header=TrackData.data_line)\",\n \"def read_input_file(self):\\n\\n # Check if input file exists in current directory, if not kill process\\n if not os.path.isfile('./visualise.inpt'):\\n print('Cannot find input file \\\"visualise.inpt\\\" in current directory')\\n sys.exit()\\n\\n # Read input file and analysis options and parameters\\n print('Reading input file')\\n with open('visualise.inpt','r') as f:\\n f.readline()\\n self.prefix = f.readline().split()[0]\\n f.readline()\\n f.readline()\\n self.frame = int(f.readline().split()[0])\\n f.readline()\\n f.readline()\\n self.vis_particles = int(f.readline().split()[0])\\n self.vis_vortype = int(f.readline().split()[0])\\n self.vis_cellcolour = int(f.readline().split()[0])\\n self.vis_save = int(f.readline().split()[0])\",\n \"def open_and_read_file(file_path):\\n\\n source_material = open(file_path).read()\\n return source_material\",\n \"def open_file_path(self, file_path):\\n\\n\\t\\ttext = []\\n\\t\\twith open(file_path, \\\"r\\\") as f:\\n\\t\\t\\tfor line in f:\\n\\t\\t\\t\\ttext.append(line)\\n\\n\\t\\tself.raw = text\",\n \"def read(self):\\n # open the .SPE file\\n with open(self._input_file_path, 'rb') as f:\\n lines = f.readlines()\\n # Create an empty dictionary for the metadata\\n metadata_dictionary = {}\\n\\n # Search through the file for the needed metadata\\n metadata_dictionary['date_acquired'] = re.search(b'date=\\\"(.*?)\\\"', lines[1])[1].decode('ANSI') \\n metadata_dictionary['width'] = int(re.search(b'width=\\\"(.*?)\\\"', lines[1])[1])\\n metadata_dictionary['height'] = int(re.search(b'height=\\\"(.*?)\\\"', lines[1])[1])\\n metadata_dictionary['size'] = metadata_dictionary['width']*metadata_dictionary['height']\\n metadata_dictionary['exposure_time'] = int(re.search(b'<ExposureTime type=\\\"Double\\\">(.*?)</ExposureTime>', lines[1])[1])\\n metadata_dictionary['excitation_wavelength'] = float(re.search(b'laserLine=\\\"(.*?)\\\"',lines[1])[1])\\n metadata_dictionary['center_wavelength'] = float(re.search(b'<CenterWavelength type=\\\"Double\\\">(.*?)</CenterWavelength>',lines[1])[1])\\n metadata_dictionary['orientation'] = re.search(b'orientation=\\\"(.*?)\\\"',lines[1])[1].decode('ANSI')\\n\\n # Get the wavelength and intensity\\n wavelength_string = re.search(b'<Wavelength xml:space=\\\"preserve\\\">(.*?)</Wavelength>',lines[1])[1].decode('utf-8')\\n wavelength = np.array(wavelength_string.split(','), dtype=np.float64)\\n\\n f.seek(4100)\\n intensity = np.fromfile(f,dtype=np.float32,count=metadata_dictionary['size'])\\n\\n raman_shift_wavenumbers = 1e7*(1/metadata_dictionary['excitation_wavelength'] - 1/wavelength)\\n\\n f.close()\\n \\n # create the sidpy dataset\\n data_set = Dataset.from_array(intensity, name='Raman Spectra')\\n\\n data_set.data_type = 'spectrum'\\n data_set.units = 'counts'\\n data_set.quantity = 'Intensity'\\n\\n # set dimensions\\n data_set.set_dimension(0, Dimension(raman_shift_wavenumbers, name='Raman Shift',\\n units = 'cm-1',\\n quantity='Raman shift',\\n dimension_type='spectral'))\\n data_set.set_dimension(1, Dimension(intensity, name='Intensity',\\n units = 'counts',\\n quantity='intensity',\\n dimension_type='spectral')) \\n\\n data_set.metadata = metadata_dictionary\\n\\n return data_set\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6273761","0.61905116","0.6149404","0.6120383","0.60943437","0.5985097","0.59676677","0.59638536","0.5951896","0.5951896","0.5945563","0.5891649","0.5891006","0.5866269","0.58474845","0.58314574","0.5801502","0.5800049","0.5794519","0.5760646","0.57478744","0.57452154","0.5743817","0.57337284","0.57117975","0.57080877","0.5700953","0.5691606","0.5685672","0.5678224","0.56609136","0.5652193","0.5650529","0.56462246","0.5645752","0.5640332","0.56086457","0.55942255","0.55932087","0.55650955","0.555005","0.554915","0.55393386","0.55391914","0.5536656","0.5524903","0.5523767","0.5521882","0.5510069","0.55071354","0.5506406","0.5492292","0.5450791","0.5444848","0.5430038","0.5428273","0.54279536","0.54206854","0.5417177","0.5410681","0.54093593","0.53960603","0.5394686","0.5392058","0.53906405","0.5383545","0.53799266","0.5370428","0.5366553","0.53641856","0.53621066","0.53570664","0.53562886","0.5352819","0.53498405","0.5345698","0.53415644","0.5340221","0.53368485","0.5322195","0.5317925","0.53174436","0.53045064","0.53008157","0.53003544","0.528735","0.5286328","0.52855873","0.52768123","0.52742887","0.5270357","0.5267214","0.5266795","0.52625567","0.5261629","0.52517605","0.52445227","0.52428275","0.5242502","0.5238842"],"string":"[\n \"0.6273761\",\n \"0.61905116\",\n \"0.6149404\",\n \"0.6120383\",\n \"0.60943437\",\n \"0.5985097\",\n \"0.59676677\",\n \"0.59638536\",\n \"0.5951896\",\n \"0.5951896\",\n \"0.5945563\",\n \"0.5891649\",\n \"0.5891006\",\n \"0.5866269\",\n \"0.58474845\",\n \"0.58314574\",\n \"0.5801502\",\n \"0.5800049\",\n \"0.5794519\",\n \"0.5760646\",\n \"0.57478744\",\n \"0.57452154\",\n \"0.5743817\",\n \"0.57337284\",\n \"0.57117975\",\n \"0.57080877\",\n \"0.5700953\",\n \"0.5691606\",\n \"0.5685672\",\n \"0.5678224\",\n \"0.56609136\",\n \"0.5652193\",\n \"0.5650529\",\n \"0.56462246\",\n \"0.5645752\",\n \"0.5640332\",\n \"0.56086457\",\n \"0.55942255\",\n \"0.55932087\",\n \"0.55650955\",\n \"0.555005\",\n \"0.554915\",\n \"0.55393386\",\n \"0.55391914\",\n \"0.5536656\",\n \"0.5524903\",\n \"0.5523767\",\n \"0.5521882\",\n \"0.5510069\",\n \"0.55071354\",\n \"0.5506406\",\n \"0.5492292\",\n \"0.5450791\",\n \"0.5444848\",\n \"0.5430038\",\n \"0.5428273\",\n \"0.54279536\",\n \"0.54206854\",\n \"0.5417177\",\n \"0.5410681\",\n \"0.54093593\",\n \"0.53960603\",\n \"0.5394686\",\n \"0.5392058\",\n \"0.53906405\",\n \"0.5383545\",\n \"0.53799266\",\n \"0.5370428\",\n \"0.5366553\",\n \"0.53641856\",\n \"0.53621066\",\n \"0.53570664\",\n \"0.53562886\",\n \"0.5352819\",\n \"0.53498405\",\n \"0.5345698\",\n \"0.53415644\",\n \"0.5340221\",\n \"0.53368485\",\n \"0.5322195\",\n \"0.5317925\",\n \"0.53174436\",\n \"0.53045064\",\n \"0.53008157\",\n \"0.53003544\",\n \"0.528735\",\n \"0.5286328\",\n \"0.52855873\",\n \"0.52768123\",\n \"0.52742887\",\n \"0.5270357\",\n \"0.5267214\",\n \"0.5266795\",\n \"0.52625567\",\n \"0.5261629\",\n \"0.52517605\",\n \"0.52445227\",\n \"0.52428275\",\n \"0.5242502\",\n \"0.5238842\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52473044"},"document_rank":{"kind":"string","value":"96"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":889,"numItemsPerPage":100,"numTotalItems":95772,"offset":88900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTgwMTk0OSwianRpIjoiMTBkOTNlMDMtMWU4My00MTM4LTgzODUtZTYxYTA4YTNjMTE2Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU4MDU1NDksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.-eBFKXJ8XbV_AOaPSlGVf3FBtvrNg7uOmnAXXlMxHQtaKlRNXJntEwbUl0VbT0ckh8iAlwsv_EmpKOhZsfJoCg","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 |
|---|---|---|---|---|---|---|
return a filtered signal; low pass filter | def filt_lp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,
order=5) -> np.ndarray:
nyq = 0.5 * Ss
normal_cutoff = Cfs / nyq
b, a = butter(order, normal_cutoff, btype='low', analog=False)
return lfilter(b, a, sig) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lowpass_filter(self, data, reset=False):\n data = np.asarray(data)\n if self._lowpass_sos is not None:\n if self._lowpass_state is None or reset:\n self.lowpass_filter_reset(data)\n data, self._lowpass_state = scipy.signal.sosfilt(\n self._lowpass_sos, data, zi=self._lowpass_sta... | [
"0.77988434",
"0.75619775",
"0.7557733",
"0.75412995",
"0.7457959",
"0.7273586",
"0.72515476",
"0.7229122",
"0.71059245",
"0.7071824",
"0.70714056",
"0.7000615",
"0.68335736",
"0.6817223",
"0.6754172",
"0.67400444",
"0.6702155",
"0.6678992",
"0.6666621",
"0.6623568",
"0.66213... | 0.6293112 | 44 |
return a filtered signal; high pass filter | def filt_hp(sig: np.ndarray, Ss: int, Cfs: int, Cfs1: None,
order=5) -> np.ndarray:
nyq = 0.5 * Ss
normal_cutoff = Cfs / nyq
b, a = butter(order, normal_cutoff, btype='high', analog=False)
return lfilter(b, a, sig) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def highpass_filter(self, data, reset=False):\n data = np.asarray(data)\n if self._highpass_sos is not None:\n if self._highpass_state is None or reset:\n self.highpass_filter_reset(data)\n data, self._highpass_state = scipy.signal.sosfilt(\n self._highpass_sos, data, zi=self._highp... | [
"0.7774473",
"0.7378576",
"0.706243",
"0.70044225",
"0.67968166",
"0.6795389",
"0.6783317",
"0.6739167",
"0.67341006",
"0.6733994",
"0.66774994",
"0.6654014",
"0.66108674",
"0.6609167",
"0.6607635",
"0.65914875",
"0.65901077",
"0.65812695",
"0.6576423",
"0.6562273",
"0.655813... | 0.6301917 | 33 |
return a filtered signal; band pass filter | def filt_bp(sig: np.ndarray, Ss: int, Cfs0: int, Cfs1: None,
order=5) -> np.ndarray:
nyq = 0.5 * Ss
normal_cutoff1 = Cfs0 / nyq
normal_cutoff2 = Cfs1 / nyq
b, a = butter(order, (normal_cutoff1, normal_cutoff2),
btype='band',
analog=False)
return lfilte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_fir_filter(passband, fs, order=183, weights=[5.75, 1., 5.75], mask=[0, 1, 0]):\n # return remez(order, passband, mask, weights, Hz=fs), 1.\n return remez(order, passband, mask, Hz=fs), 1.",
"def bandpass_filter(data, lowcut, highcut, fs=2000, numtaps=255):\n nyq = fs / 2\n\n # design filter\... | [
"0.7324347",
"0.7298562",
"0.7221127",
"0.72196114",
"0.7194418",
"0.7182365",
"0.7160815",
"0.709657",
"0.70529634",
"0.70239526",
"0.6996266",
"0.6928782",
"0.6902879",
"0.68974304",
"0.68689305",
"0.6687426",
"0.6683397",
"0.6678169",
"0.66576636",
"0.6615789",
"0.660077",... | 0.62631494 | 47 |
Get the primitive roots of the modulo | def PrimitiveRoots(self, modulo):
modRange = range(1, modulo)
required = {x for x in modRange if fractions.gcd(x, modulo)}
return [g for g in modRange if required == {pow(g, powers, modulo) for powers in modRange}] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_generator(modulus):\n return sympy.ntheory.primitive_root(modulus)",
"def primitive_root(n):\n if n == 2:\n return 1\n phi = euler_phi(n)\n phi_divisors = factorize(phi)\n for g in range(2, n + 1):\n if gcd(g, n) != 1:\n continue\n for d, _ in phi_divisors:... | [
"0.6900234",
"0.6570498",
"0.6545125",
"0.6443999",
"0.63940936",
"0.6374898",
"0.63004357",
"0.63003904",
"0.6290598",
"0.62899435",
"0.625735",
"0.62297606",
"0.6209194",
"0.61932445",
"0.60664463",
"0.5981598",
"0.5971845",
"0.5878766",
"0.58545893",
"0.5851274",
"0.584104... | 0.8176876 | 0 |
Send a string securely | def sendStr(self, socket, string, bufferSize=1024):
return self.send(socket, string.encode(), bufferSize) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sendToClient(plaintext):\n signature = userKeys.signUsingPrivateKey(plaintext)\n encryptedText = userKeys.encrypt(plaintext, contactKey)\n s.send(encryptedText)\n time.sleep(1)\n s.send(signature)",
"def sendString(self, data):\n self.transport.write(pack(\"!i\",len(... | [
"0.66090614",
"0.6591021",
"0.64761496",
"0.64339596",
"0.6391974",
"0.614747",
"0.6142503",
"0.61386234",
"0.6135998",
"0.61228913",
"0.6088763",
"0.6076449",
"0.6070305",
"0.60699373",
"0.60325074",
"0.5996709",
"0.59754217",
"0.58853626",
"0.58497566",
"0.5830384",
"0.5820... | 0.6278206 | 5 |
Receive a string securely | def recvStr(self, socket, bufferSize=1024):
return self.recv(socket, bufferSize).decode() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_request_string(string, format=FORMAT_PEM):\n bio = BIO.MemoryBuffer(string)\n return load_request_bio(bio, format)",
"def make_secure_val(string):\n\n return \"%s|%s\" % (string, hash_str(string))",
"def load_request_der_string(string):\n bio = BIO.MemoryBuffer(string)\n return load_req... | [
"0.59533936",
"0.5811541",
"0.56815565",
"0.56761354",
"0.5635763",
"0.5612197",
"0.5547765",
"0.5547765",
"0.54540926",
"0.5437279",
"0.5437094",
"0.5435814",
"0.5407238",
"0.5357738",
"0.53528774",
"0.5325348",
"0.53104746",
"0.5238935",
"0.52323365",
"0.5226999",
"0.522462... | 0.533402 | 15 |
Perform a key exchange with the given server to make a shared secret | def ExchangeClient(self, socket, bufferSize=4096):
self.SharedPrime = number.bytes_to_long(socket.recv(bufferSize))
socket.send(self.Ack)
self.SharedBase = number.bytes_to_long(socket.recv(bufferSize))
socket.send(self.Ack)
key = self.RandKey() #client secret
com... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_server(wrapping_key_public):\n secret = os.urandom(32)\n logging.info(f'secret: {hexlify(secret)}')\n\n ref_path = 'server-secret-for-reference.bin'\n logging.debug(f'creating {ref_path}')\n with open(ref_path, 'wb') as f:\n f.write(secret)\n\n # generate IV\n iv = os.urandom(12)... | [
"0.70041174",
"0.6704637",
"0.6459529",
"0.63826007",
"0.6247185",
"0.6241411",
"0.6192971",
"0.6180967",
"0.61089927",
"0.6052764",
"0.6042717",
"0.60315335",
"0.5924363",
"0.585214",
"0.5838512",
"0.5737452",
"0.5730667",
"0.56727517",
"0.56534064",
"0.56533796",
"0.5636214... | 0.56482506 | 20 |
Perform a key exchange with the given client to make a shared secret | def ExchangeServer(self, socket, bufferSize=4096):
self.SharedPrime, self.SharedBase = self.RandomPrime()
socket.send(number.long_to_bytes(self.SharedPrime))
socket.recv(bufferSize)
socket.send(number.long_to_bytes(self.SharedBase))
socket.recv(bufferSize)
key = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shared_key(private_key,public_key):\n\treturn private_key.exchange(public_key)",
"def do_server(wrapping_key_public):\n secret = os.urandom(32)\n logging.info(f'secret: {hexlify(secret)}')\n\n ref_path = 'server-secret-for-reference.bin'\n logging.debug(f'creating {ref_path}')\n with open(ref_... | [
"0.66158164",
"0.644604",
"0.63088894",
"0.6096652",
"0.59875745",
"0.59282756",
"0.5803291",
"0.5783874",
"0.57682276",
"0.574353",
"0.56681067",
"0.5610454",
"0.56031257",
"0.5511368",
"0.5487431",
"0.5479129",
"0.5458488",
"0.54581076",
"0.5444761",
"0.5406141",
"0.5405146... | 0.54456997 | 18 |
Initiate a server unit test in conjuction with the client unit test | def UnitTestServer(self):
print('--server--')
print('server pid is ' + str(os.getpid()))
try:
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('', 25692))
s.listen(1)
c, addr = s.accept() #get client s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self.c = Client(host=\"localhost\")",
"def setUp(self):\n\t\tself.conn = Client([\"127.0.0.1:11211\"], debug = 1)",
"def setUp(self):\n self.loop = asyncio.new_event_loop()\n asyncio.set_event_loop(None)\n self.server = KytosServer(TEST_ADDRESS, KytosServerProtoco... | [
"0.7822149",
"0.7642992",
"0.76374215",
"0.7559873",
"0.7514837",
"0.7514837",
"0.74274445",
"0.7421756",
"0.7407248",
"0.7393341",
"0.73756444",
"0.7344193",
"0.7252163",
"0.7243478",
"0.71754915",
"0.7159595",
"0.7117442",
"0.7117442",
"0.7117442",
"0.7117442",
"0.7103456",... | 0.6791403 | 41 |
Initiate a client unit test in conjuction with the server unit test | def UnitTestClient(self):
print('\n--client')
print('client pid is ' + str(os.getpid()))
try:
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.connect((socket.gethostbyname('localhost'), 25692))
self.ExchangeClient(s)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n self.c = Client(host=\"localhost\")",
"def test_for_client():",
"def setUp(self):\n\t\tself.conn = Client([\"127.0.0.1:11211\"], debug = 1)",
"def setUp(self):\n self.client_socket = open_client_socket()",
"def setUp(self):\n self.client_socket = open_client_socket()... | [
"0.8213718",
"0.80244344",
"0.80109507",
"0.79769665",
"0.79769665",
"0.7970332",
"0.7669021",
"0.7669021",
"0.7669021",
"0.7669021",
"0.756248",
"0.7551135",
"0.73318714",
"0.7314016",
"0.7276855",
"0.7262563",
"0.72312695",
"0.7216074",
"0.7203983",
"0.7195504",
"0.7164154"... | 0.0 | -1 |
Run a unit test to ensure that key exchange communications are working | def UnitTest():
print('--Running key exchange unit test--')
server = DiffieHellman()
t0 = threading.Thread(target=server.UnitTestServer)
t0.start()
time.sleep(0.1)
logname = 'dhlog'
with open(logname, 'w') as stdout:
subprocess.call(['python', 'keyExch... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n\n self.private_key = self.get_new_key()\n self.public_key = self.private_key.public_key()\n\n self.pem_private_key = self.private_key.private_bytes(\n serialization.Encoding.PEM,\n serialization.PrivateFormat.PKCS8,\n serialization.NoEncrypti... | [
"0.68959457",
"0.6768567",
"0.6740749",
"0.67402774",
"0.6681738",
"0.6668606",
"0.6642968",
"0.6633357",
"0.6619077",
"0.6554481",
"0.6428186",
"0.63924134",
"0.6349333",
"0.63427824",
"0.6338166",
"0.6320229",
"0.63075775",
"0.62685555",
"0.6263551",
"0.62614954",
"0.624999... | 0.72412264 | 0 |
Damages segmentation masks by random transformations. | def damage_masks(labels, shift=True, scale=True, rotate=True, dilate=True):
def _damage_masks_np(labels_):
return damage_masks_np(labels_, shift, scale, rotate, dilate)
damaged_masks = tf.py_func(_damage_masks_np, [labels], tf.int32,
name='damage_masks')
damaged_masks.set_shape(la... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bg_mask(query_imgs, method):\n print(\"Obtaining masks\")\n segmentation_method = get_method(method)\n return [segmentation_method(img) for img in query_imgs]",
"def mask_the_images(working_path,set_name):\n\n file_list=glob('/media/talhassid/My Passport/haimTal/test_images_0b8afe447b5f1a2c405f41... | [
"0.6190193",
"0.6122746",
"0.60014516",
"0.5992799",
"0.5963751",
"0.58870125",
"0.5827479",
"0.57591707",
"0.57511514",
"0.5717484",
"0.57092875",
"0.5707633",
"0.57019264",
"0.568458",
"0.56777894",
"0.5674505",
"0.56664747",
"0.56642354",
"0.56143486",
"0.560032",
"0.55961... | 0.5273855 | 59 |
Performs the actual mask damaging in numpy. | def damage_masks_np(labels, shift=True, scale=True, rotate=True, dilate=True):
unique_labels = np.unique(labels)
unique_labels = np.setdiff1d(unique_labels, [0])
# Shuffle to get random depth ordering when combining together.
np.random.shuffle(unique_labels)
damaged_labels = np.zeros_like(labels)
for l in u... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_mask(self, array):\n # assert that the array and Mask.data are of the same size\n assert array.shape == self.shape, \"array and mask should be of the same shape\"\n\n array_copy = array.copy()\n\n # Applying mask\n # apply func_true where Mask.data is True\n arra... | [
"0.6378913",
"0.6319546",
"0.62407255",
"0.62120646",
"0.6204231",
"0.6188625",
"0.6123729",
"0.6117613",
"0.60972047",
"0.6078417",
"0.60769355",
"0.60468847",
"0.5975676",
"0.59668505",
"0.59560007",
"0.59537953",
"0.59433216",
"0.5912248",
"0.5910191",
"0.59040207",
"0.590... | 0.0 | -1 |
Performs mask damaging in numpy for a single object. | def _damage_single_object_mask(mask, shift, scale, rotate, dilate):
# For now we just do shifting and scaling. Better would be Affine or thin
# spline plate transformations.
if shift:
mask = _shift_mask(mask)
if scale:
mask = _scale_mask(mask)
if rotate:
mask = _rotate_mask(mask)
if dilate:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_mask(self, array):\n # assert that the array and Mask.data are of the same size\n assert array.shape == self.shape, \"array and mask should be of the same shape\"\n\n array_copy = array.copy()\n\n # Applying mask\n # apply func_true where Mask.data is True\n arra... | [
"0.6581553",
"0.645084",
"0.64089704",
"0.624001",
"0.62089777",
"0.6206625",
"0.6106563",
"0.61044997",
"0.60834694",
"0.6082419",
"0.60604167",
"0.60547453",
"0.6044454",
"0.60163283",
"0.59976715",
"0.59909415",
"0.59805685",
"0.5972587",
"0.58964914",
"0.58889",
"0.586071... | 0.6550946 | 1 |
Damages a mask for a single object by randomly shifting it in numpy. | def _shift_mask(mask, max_shift_factor=0.05):
nzy, nzx, _ = mask.nonzero()
h = nzy.max() - nzy.min()
w = nzx.max() - nzx.min()
size = np.sqrt(h * w)
offset = np.random.uniform(-size * max_shift_factor, size * max_shift_factor,
2)
shifted_mask = interpolation.shift(np.squeeze(mas... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _damage_single_object_mask(mask, shift, scale, rotate, dilate):\n # For now we just do shifting and scaling. Better would be Affine or thin\n # spline plate transformations.\n if shift:\n mask = _shift_mask(mask)\n if scale:\n mask = _scale_mask(mask)\n if rotate:\n mask = _rotate_mask(mask)\n i... | [
"0.6778533",
"0.60825586",
"0.60205495",
"0.5973601",
"0.5953498",
"0.5917967",
"0.59039605",
"0.5888028",
"0.58462554",
"0.5841398",
"0.57965106",
"0.5739158",
"0.57294834",
"0.5720012",
"0.56666315",
"0.5633807",
"0.55948806",
"0.55791575",
"0.5567478",
"0.5564043",
"0.5555... | 0.5330294 | 32 |
Damages a mask for a single object by randomly scaling it in numpy. | def _scale_mask(mask, scale_amount=0.025):
nzy, nzx, _ = mask.nonzero()
cy = 0.5 * (nzy.max() - nzy.min())
cx = 0.5 * (nzx.max() - nzx.min())
scale_factor = np.random.uniform(1.0 - scale_amount, 1.0 + scale_amount)
shift = transform.SimilarityTransform(translation=[-cx, -cy])
inv_shift = transform.Similarit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _damage_single_object_mask(mask, shift, scale, rotate, dilate):\n # For now we just do shifting and scaling. Better would be Affine or thin\n # spline plate transformations.\n if shift:\n mask = _shift_mask(mask)\n if scale:\n mask = _scale_mask(mask)\n if rotate:\n mask = _rotate_mask(mask)\n i... | [
"0.6585455",
"0.59778154",
"0.5851471",
"0.57898265",
"0.5720597",
"0.5643955",
"0.5597096",
"0.54800975",
"0.5447898",
"0.5433099",
"0.5421635",
"0.5365141",
"0.5350452",
"0.5305155",
"0.53041595",
"0.526097",
"0.5259611",
"0.52520066",
"0.523572",
"0.5234661",
"0.5216299",
... | 0.5919484 | 2 |
Damages a mask for a single object by randomly rotating it in numpy. | def _rotate_mask(mask, max_rot_degrees=3.0):
cy = 0.5 * mask.shape[0]
cx = 0.5 * mask.shape[1]
rot_degrees = np.random.uniform(-max_rot_degrees, max_rot_degrees)
shift = transform.SimilarityTransform(translation=[-cx, -cy])
inv_shift = transform.SimilarityTransform(translation=[cx, cy])
r = transform.Simila... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def randomize_voxel_mask(vol, mask, ref='fg'):\n\n # Initialization\n o_vol = np.copy(vol)\n\n # Finding 'bg' and reference\n bg_ids = np.where(mask == False)\n if ref == 'fg':\n ref_ids = np.where(mask)\n else:\n ref_ids = np.where(mask == False)\n\n # Randomization\n rnd_ids... | [
"0.6264214",
"0.59360576",
"0.5834285",
"0.58224565",
"0.5721481",
"0.5679718",
"0.5654434",
"0.55939865",
"0.55292684",
"0.55275834",
"0.5499133",
"0.54703903",
"0.5460102",
"0.543918",
"0.5406599",
"0.5371623",
"0.53477293",
"0.5328869",
"0.52776635",
"0.52681917",
"0.52578... | 0.5170334 | 28 |
Damages a mask for a single object by dilating it in numpy. | def _dilate_mask(mask, dilation_radius=5):
disk = morphology.disk(dilation_radius, dtype=np.bool)
dilated_mask = morphology.binary_dilation(
np.squeeze(mask, axis=2), selem=disk)[..., np.newaxis]
return dilated_mask | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _damage_single_object_mask(mask, shift, scale, rotate, dilate):\n # For now we just do shifting and scaling. Better would be Affine or thin\n # spline plate transformations.\n if shift:\n mask = _shift_mask(mask)\n if scale:\n mask = _scale_mask(mask)\n if rotate:\n mask = _rotate_mask(mask)\n i... | [
"0.7115775",
"0.63289875",
"0.6086381",
"0.5870329",
"0.5732645",
"0.5727857",
"0.56703866",
"0.5649035",
"0.5612683",
"0.55999976",
"0.55900395",
"0.5562102",
"0.55520886",
"0.55458033",
"0.5525944",
"0.5514964",
"0.548503",
"0.54686165",
"0.54550576",
"0.54230964",
"0.54163... | 0.5612863 | 8 |
Returns the current quorum configuration, i.e. config[i] May return if p_i is not a participant or BOTTOM during the process of a configuration reset | def get_config(self):
if self.allow_reco():
return self.chs_config()
else:
return self.get_config_j(self.id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config():\n \n logger.info('Reading current configuration...')\n dburl = dbconn.DbURL()\n array = gparray.GpArray.initFromCatalog(dburl, utility=True)\n \n master_hostname = array.master.getSegmentHostName()\n master_port = array.master.getSegmentPort()\n \n cmd = pg.ReadPostmast... | [
"0.6242041",
"0.6049767",
"0.60446256",
"0.598099",
"0.5942673",
"0.5942673",
"0.5852599",
"0.5801146",
"0.57961076",
"0.5724765",
"0.5715988",
"0.5701836",
"0.56410754",
"0.5633207",
"0.56322837",
"0.5620723",
"0.56143135",
"0.5612343",
"0.5583728",
"0.5523893",
"0.5521681",... | 0.57858795 | 9 |
Returns the current quorum configuration (config[i]) to application Returns config[i] when no reconfiguration occurs or no agreement on proposal. Once participants agree on proposal, returns proposal set U current configuration. | def get_config_app(self):
if self.degree(self.id) in [0, 1, 2]:
return self.get_config_j(self.id)
else:
return list(set(self.get_config_j(self.id)) | set(self.get_prp_j(self.id)[1])) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config(self):\n if self.allow_reco():\n return self.chs_config()\n else:\n return self.get_config_j(self.id)",
"def configuration(self) -> Optional[pulumi.Input['BrokerConfigurationArgs']]:\n return pulumi.get(self, \"configuration\")",
"def configuration(self... | [
"0.6239466",
"0.60387367",
"0.60387367",
"0.5956868",
"0.59504783",
"0.5895645",
"0.58602935",
"0.582811",
"0.5820163",
"0.58134586",
"0.5805068",
"0.58021927",
"0.57909834",
"0.5775168",
"0.5733354",
"0.5731225",
"0.573007",
"0.57178",
"0.5675857",
"0.56626356",
"0.5660312",... | 0.6082164 | 1 |
Interface for RecMA to request configuration update Used to replace the configuration by the RecMA module. Proposed set must be nonempty and not the same as current conf. | def estab(self, s):
logger.info("Running estab(set) with set:", s)
if self.allow_reco() and (set(s) not in [set(), set(self.get_config_j(self.id))]):
logger.info("estab() allowed!")
self.prp[self.id] = (1, s)
self.alll[self.id] = False
self.all_seen = set(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conf_update(self):\n pass",
"def update_config(self):\n if self.integration is None:\n return\n self.enabled = self.integration.has_option(self.get_config_name())\n self.pedantic = self.integration.configuration.get_bool(\n 'filter.mrproper')",
"def fusion_... | [
"0.65515244",
"0.63368267",
"0.6274681",
"0.6227749",
"0.60530394",
"0.60136694",
"0.6009625",
"0.5905762",
"0.58097386",
"0.57259136",
"0.57189995",
"0.5709922",
"0.5694562",
"0.5694562",
"0.56567484",
"0.56441706",
"0.5640051",
"0.55936855",
"0.55668706",
"0.55619437",
"0.5... | 0.0 | -1 |
Interface for Joining mechanism to request a join for p_i. | def participate(self):
if self.allow_reco():
self.config[self.id] = self.chs_config() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def join ( self ) :\n raise AbstractMethodException( self , \"join\" )",
"def join(self):\n pass",
"def join(ctx, network, force):\n return join_wrapper(ctx.obj['client'], network, force)",
"def join(self):\n if self._join_command is not None:\n return\n\n if self._j... | [
"0.6963116",
"0.6169438",
"0.5998683",
"0.57739687",
"0.5754608",
"0.5668251",
"0.56177",
"0.5588436",
"0.5514683",
"0.5493263",
"0.5491207",
"0.5382972",
"0.5371468",
"0.5354688",
"0.5339792",
"0.5304464",
"0.5298357",
"0.5283666",
"0.5199348",
"0.5187125",
"0.5181807",
"0... | 0.0 | -1 |
Returns config whenever there is a single such non value. Returns BOTTOM if no config exists. | def chs_config(self):
conf = set()
for j in self.get_fd_j(self.id):
if self.get_config_j(j) != constants.NOT_PARTICIPANT:
conf |= set(self.get_config_j(j))
if conf == set():
return constants.BOTTOM
else:
return list(conf) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config() -> Optional[Config]:\n return CurrentConfig.get()",
"def default(self):\n return self._configs[0] if len(self._configs) else None",
"def getConfig(self, committed=False, ignore_last=False):\n # go back from the latest entry, find the most recent config entry\n for idx, ... | [
"0.6573118",
"0.6316215",
"0.62860805",
"0.6104078",
"0.6081168",
"0.60742784",
"0.6067803",
"0.605521",
"0.6035528",
"0.6021096",
"0.59994614",
"0.5970423",
"0.5957983",
"0.59468275",
"0.59468275",
"0.5943898",
"0.59314483",
"0.5925146",
"0.58585817",
"0.5848977",
"0.5847518... | 0.5750651 | 100 |
Returns either the value stored in all[k] or if k == i, whether there exists p_l one phase "ahead" of p_i | def my_alll(self, k):
all_k = self.get_all_j(k)
exists_pl_ahead = False
ahead = (self.get_prp_j(self.id)[0] + 1) % 3
for l in self.all_seen:
if self.get_prp_j(l)[0] == ahead:
exists_pl_ahead = True
return all_k or ((k == self.id) and exists_pl_ahead) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first_active(self, k):\n return k - self.p",
"def fn(x):\n k = 0 \n for i, ch in enumerate(s): \n if mp.get(i, inf) < x: continue \n if k < len(p) and ch == p[k]: k += 1\n return k == len(p)",
"def _is_polynomial(self, p, i):\n or... | [
"0.56682724",
"0.55324847",
"0.54159045",
"0.5402462",
"0.53369343",
"0.52204055",
"0.52181983",
"0.51593745",
"0.5117445",
"0.5115613",
"0.50642437",
"0.5046544",
"0.5038634",
"0.50367725",
"0.50101006",
"0.49974707",
"0.49965903",
"0.49912035",
"0.4976445",
"0.4962322",
"0.... | 0.7482815 | 0 |
Calculates the degree of p_k's most recently received notification Calculated as twice the notification phase plus one whenever all participants are using the same notification (0 otherwise), where each notification is a configuration replacement proposal. | def degree(self, k):
one_if_my_all_k = 1 if self.my_alll(k) else 0
return (2 * self.get_prp_j(k)[0]) + one_if_my_all_k | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def langmuir_occ(p, k):\n\n intermediate = k * p\n\n occupancy = intermediate / (intermediate + 1)\n\n return occupancy",
"def _calculate_probability(self,k):\n\t\tif abs(k * self.delta_x) > (3 * np.sqrt(self.variance)):\n\t\t\treturn 0.0\n\t\tbinom_coeff = special.binom(self.n,(self.n + k)/2)\n\t\tb_va... | [
"0.575358",
"0.5645525",
"0.5627544",
"0.55538696",
"0.5541306",
"0.54604745",
"0.54539067",
"0.5432265",
"0.5383388",
"0.5368729",
"0.5346243",
"0.5339594",
"0.53276587",
"0.53068185",
"0.52934635",
"0.5250172",
"0.5222444",
"0.51899505",
"0.51531494",
"0.51329046",
"0.51319... | 0.64719737 | 0 |
Tests whether p_k and p_k' have degrees that differ by <= 1 Used when considering operations in mod 6 | def corr_deg(self, k, k_prime):
ok_deg_tups = [{0, 5}, {5, 5}]
for x in range(0, 5):
ok_deg_tups.append({x, x+1})
ok_deg_tups.append({x, x})
return {self.degree(k), self.degree(k_prime)} in ok_deg_tups | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def echo_fun(self, k):\n same_all = self.my_alll(self.id) == self.get_echo_all_j(k)\n ok_deg = ((self.degree(k) - self.degree(self.id)) % 6) in {0, 1}\n return self.echo_no_all(k) and same_all and ok_deg",
"def goodDLK_2(d,l,k) :\n if (d == 0) and ((l != 0) or (k != 3)) :\n return ... | [
"0.6549065",
"0.6408314",
"0.62199163",
"0.6166814",
"0.6073687",
"0.6015139",
"0.60098195",
"0.5946944",
"0.5922223",
"0.580886",
"0.5793645",
"0.5749401",
"0.5662234",
"0.5647768",
"0.5639147",
"0.5632892",
"0.56150824",
"0.5612917",
"0.5608243",
"0.55855036",
"0.5585182",
... | 0.6567329 | 0 |
Tests whether p_i was acked by all participants for the values it has sent. Considers just the fields that are related to its own participant set and notification. | def echo_no_all(self, k):
same_fd_part = set(self.get_fd_part_j(self.id)) == set(self.get_echo_part_j(k))
(phase_i, set_i) = self.get_prp_j(self.id)
(phase_k, set_k) = self.get_echo_prp_j(k)
same_prp = (phase_i == phase_k) and (set(set_i) == set(set_k))
return same_fd_part and sa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ack_required(self):\n v = self[22]\n v = v >> 1\n return (v & 0b1) != 0",
"def ack(self):\n return (self.status == self.STATUS_ACK)",
"def acknowledged(self):\n ...",
"def successful(self):\n return (self.power_ack & self.datarate_ack & self.channelmask_ack) == 1... | [
"0.54846966",
"0.542285",
"0.533005",
"0.5275694",
"0.51296085",
"0.5083332",
"0.50610894",
"0.5043839",
"0.5016612",
"0.5011998",
"0.49795997",
"0.49607998",
"0.4947806",
"0.49460548",
"0.4926226",
"0.49083593",
"0.4906408",
"0.49044418",
"0.48991197",
"0.4897232",
"0.488377... | 0.0 | -1 |
Tests whether p_k was acked by all participants for the values it has sent. Considers the fields that are related to its own participant set and notification as well as all[]. | def echo_fun(self, k):
same_all = self.my_alll(self.id) == self.get_echo_all_j(k)
ok_deg = ((self.degree(k) - self.degree(self.id)) % 6) in {0, 1}
return self.echo_no_all(k) and same_all and ok_deg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ack_required(self):\n v = self[22]\n v = v >> 1\n return (v & 0b1) != 0",
"def ack(self):\n return (self.status == self.STATUS_ACK)",
"def acknowledged(self):\n ...",
"def check_saved_acks():\n log('Looking through saved ACKS')\n if (BUFFER):\n for decoded in RECEI... | [
"0.5611435",
"0.5374959",
"0.5341598",
"0.53283286",
"0.5248775",
"0.5178723",
"0.5162214",
"0.50907016",
"0.50575113",
"0.50436157",
"0.5031918",
"0.5031193",
"0.5030639",
"0.5014339",
"0.5008831",
"0.50069094",
"0.49977213",
"0.49705735",
"0.4849885",
"0.4849865",
"0.484559... | 0.4488583 | 77 |
Performs the transition between phases of the delicate reconfiguration. | def increment(self, prp):
(prp_phase, prp_set) = prp
if prp_phase == 1:
return ((2, prp_set), False)
elif prp_phase == 2:
return (constants.DFLT_NTF, False)
else:
return (self.get_prp_j(self.id), self.get_all_j(self.id)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_05_node_down_and_resync_hard(self):\n for cluster in test_rest.cluster.clusters:\n if cluster == 'index':\n continue\n test_rest.db_simulate(cluster, 240)\n port = test_rest.cluster.clusters[cluster][0][0]\n test_rest.step(f'stopping cluste... | [
"0.5382239",
"0.5332354",
"0.529817",
"0.52783895",
"0.5275057",
"0.52285475",
"0.52197593",
"0.52029765",
"0.51907116",
"0.5169656",
"0.5154796",
"0.50708884",
"0.50369895",
"0.5027845",
"0.5020152",
"0.5008651",
"0.4988927",
"0.4971399",
"0.4971297",
"0.49467748",
"0.494261... | 0.0 | -1 |
Tests whether all active participants have noticed that all other participants have finished the current phase. | def all_seen_fun(self):
return self.get_all_j(self.id) and \
(set(self.get_fd_part_j(self.id)) <= (self.all_seen | {self.id})) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_players_finish(self):\n return len(self.game_winners) == len(self.players)",
"def is_done(self):\n return not any((agent.is_alive() for agent in self.agents))",
"def is_done(self):\n return not any(agent.is_alive() for agent in self.agents)",
"def is_done(self):\n return n... | [
"0.70197296",
"0.6961213",
"0.68932307",
"0.68932307",
"0.6708486",
"0.6580946",
"0.6557289",
"0.647794",
"0.647794",
"0.647794",
"0.647794",
"0.647794",
"0.647794",
"0.6374831",
"0.63552946",
"0.63506705",
"0.6344467",
"0.63239634",
"0.63140446",
"0.6268045",
"0.6217618",
... | 0.0 | -1 |
Returns maximum phase value of two processors considering mod 3 operations. Assumes that no two processors in FD[i].part have two notifications that p_i stores for which the degree differs by more than one. | def mod_max(self):
phs = set()
for k in self.get_fd_part_j(self.id):
phs.add(self.get_prp_j(k)[0])
if (1 in phs) and (2 not in phs) and (self.get_prp_j(self.id)[0] != max(phs)):
self.all_seen = set()
return max(phs)
else:
return self.get_pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_ntf(self):\n deg_diffs = set()\n for k in self.get_fd_part_j(self.id):\n deg_diff = (self.degree(k) - self.degree(self.id)) % 6\n deg_diffs.add(deg_diff)\n if not (deg_diffs <= {0, 1}):\n return self.get_prp_j(self.id)\n else:\n max_le... | [
"0.5673758",
"0.5658783",
"0.55484",
"0.5479257",
"0.533177",
"0.5197469",
"0.51458836",
"0.50572944",
"0.5057134",
"0.50482756",
"0.50440663",
"0.5006366",
"0.49880645",
"0.49865636",
"0.4975815",
"0.4964766",
"0.49578205",
"0.49548864",
"0.49516526",
"0.49196458",
"0.491935... | 0.5880462 | 0 |
Selects notification with maximal lexicographical value. Returns BOTTOM in the absence of notification that is not phase 0 notification. | def max_ntf(self):
deg_diffs = set()
for k in self.get_fd_part_j(self.id):
deg_diff = (self.degree(k) - self.degree(self.id)) % 6
deg_diffs.add(deg_diff)
if not (deg_diffs <= {0, 1}):
return self.get_prp_j(self.id)
else:
max_lex_set = const... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max(self, include_zero=False):\n for key, value in reversed(self.items()):\n if value > 0 or include_zero:\n return key",
"def get_highest_priority(self):\n for i in self.query.index.values.tolist():\n if not int(self.query.loc[i,'in_%s'%self.program]):\n ... | [
"0.55475223",
"0.552495",
"0.5510104",
"0.5480517",
"0.5471584",
"0.5462136",
"0.5439084",
"0.54091084",
"0.5366987",
"0.5362412",
"0.5342453",
"0.53143114",
"0.52908576",
"0.52789414",
"0.5275979",
"0.52707195",
"0.5249729",
"0.52354413",
"0.52332634",
"0.5227913",
"0.522721... | 0.5258826 | 16 |
The main loop of the Reconfiguration Stability Assurance module | def run(self, testing=False):
# block until system is ready
while not testing and not self.resolver.system_running():
time.sleep(0.1)
while True:
# Update some local variables
# self.fd[self.id] = self.get_fd_j(self.id)
# Algorithm 3.1 in the te... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\tconnected = False\n\t# Get the values from the config file\n\tconfig = read_config()\n\t# Do the infinite(ish) internet check loop\n\twhile True:\n\t\tconnected = check_connection(connected, config)\n\t\ttime.sleep(30)",
"def work(self):\n self.config_file = self.args.config\n self.i... | [
"0.6277527",
"0.62423164",
"0.62375265",
"0.6079482",
"0.60270476",
"0.5973181",
"0.5917289",
"0.5906455",
"0.5889537",
"0.58889675",
"0.58718526",
"0.58513665",
"0.58500284",
"0.5829142",
"0.5815654",
"0.5806713",
"0.58017844",
"0.5792019",
"0.5780087",
"0.5761517",
"0.57588... | 0.0 | -1 |
Stale info check type 1 Tests that all notifications of configuration proposals are valid. | def stale_info_type_1(self):
for k in self.prp.keys():
if (self.get_prp_j(k)[0] == 0) and (self.get_prp_j(k)[1] != constants.BOTTOM):
logger.debug("Stale info (type 1) found!")
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_config(self):",
"def stale_info_type_2(self):\n config_values = self.config.values()\n bot_exists = constants.BOTTOM in config_values\n empty_exists = [] in config_values\n if bot_exists or empty_exists:\n logger.debug(f\"Stale info (type 2) found! Current config... | [
"0.60339475",
"0.59377944",
"0.5910291",
"0.5813845",
"0.56256354",
"0.55865383",
"0.55583864",
"0.55517274",
"0.5533488",
"0.5477461",
"0.54541314",
"0.54493076",
"0.535062",
"0.5346866",
"0.53342646",
"0.53342646",
"0.53342646",
"0.53342646",
"0.532297",
"0.53192294",
"0.53... | 0.6215256 | 0 |
Stale info check type 2 Tests that there are no configuration conflicts or an active reset process | def stale_info_type_2(self):
config_values = self.config.values()
bot_exists = constants.BOTTOM in config_values
empty_exists = [] in config_values
if bot_exists or empty_exists:
logger.debug(f"Stale info (type 2) found! Current config: {self.config}")
return bot_exis... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_contradictory_multiple_actions(self):\n self.render_config_template(\n modules=[{\n \"name\": \"system\",\n \"metricsets\": [\"process\"],\n \"period\": \"1s\"\n }],\n processors=[{\n \"include_fields\": {\... | [
"0.62229544",
"0.6143",
"0.6102025",
"0.60690427",
"0.6050885",
"0.60290176",
"0.6003052",
"0.59661",
"0.5961326",
"0.59563583",
"0.5942481",
"0.5918147",
"0.5906738",
"0.5895629",
"0.58829015",
"0.5879181",
"0.5837083",
"0.5837083",
"0.5835069",
"0.5821932",
"0.582185",
"0... | 0.62378997 | 0 |
Stale info check type 3 Tests that the phase information, including all_seen, are not out of synch | def stale_info_type_3(self):
type_3_a = False
type_3_b_set = set()
prp_sets = []
exists_phase_2 = False
for k in self.get_fd_part_j(self.id):
if not self.corr_deg(self.id, k):
type_3_a = True
if self.get_prp_j(k)[0] == ((self.get_prp_j(self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_unstaged_changes(self):\n pass",
"def check_consistency(self, es):",
"def test_full_house_flush_ind(self):",
"def insync_and_state_check(self):\n self.step('verifying tables are properly synced on all endpoints')\n is_ok = True\n limit, count = 10, 0\n while count... | [
"0.59557796",
"0.58068776",
"0.5780649",
"0.5647411",
"0.56288046",
"0.5578073",
"0.55761534",
"0.55458236",
"0.5541266",
"0.55296147",
"0.5525599",
"0.54691684",
"0.54571563",
"0.5455311",
"0.5441073",
"0.54253876",
"0.542445",
"0.53946173",
"0.53917575",
"0.5380218",
"0.537... | 0.5904927 | 1 |
Stale info check type 4 Tests that there are active participants in the config | def stale_info_type_4(self):
if self.get_fd_part_j(self.id) == []:
type_4_a = False
else:
type_4_a = True
for k in self.get_fd_part_j(self.id):
different_fd = self.get_fd_j(self.id) != self.get_fd_j(k)
different_fd_part = self.get_fd_pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_meeting_status(self):\n pass",
"def test_meeting_registrant_status(self):\n pass",
"def test_past_meeting_participants(self):\n pass",
"def test_api_livesession_read_attendances_admin(self):\n video = VideoFactory(\n live_state=RUNNING,\n live_info={... | [
"0.61871",
"0.61276037",
"0.5981777",
"0.5936343",
"0.59027237",
"0.58347964",
"0.58249664",
"0.57979",
"0.5792451",
"0.5760414",
"0.5683491",
"0.567219",
"0.5661282",
"0.5660331",
"0.5652906",
"0.56523436",
"0.56283253",
"0.56200165",
"0.56166345",
"0.56166345",
"0.5611324",... | 0.0 | -1 |
Tests if we are in the special state where there are no participants and all FD monitors are stable | def no_participants_and_stable_fd_monitors(self):
if len(self.get_fd_j(self.id)) < 1:
return False
for k in self.get_fd_j(self.id):
if (not self.resolver.fd_stable_monitor(k)) or (self.get_config_j(k) != constants.NOT_PARTICIPANT):
return False
logger.debu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_device_state(self):",
"def nanny(self): \n while not self.started and not self.failed:\n eventlet.sleep(.1)\n return not self.failed",
"def test_verify_state_of_a_device_when_disconnected_from_the_device():",
"def __bool__(self):\n return self.wait(0)",
"def p... | [
"0.6425011",
"0.63082165",
"0.6045461",
"0.59334505",
"0.59191984",
"0.5908985",
"0.5904193",
"0.5903354",
"0.5896522",
"0.587225",
"0.581643",
"0.5764986",
"0.5762647",
"0.57485974",
"0.5692651",
"0.5689246",
"0.5686668",
"0.5686668",
"0.5686668",
"0.5686668",
"0.5686668",
... | 0.79300994 | 0 |
Called whenever a message is received from another processor. | def receive_msg(self, msg):
self.fd[self.id] = self.get_fd_j(self.id)
# Update state values
j = int(msg["sender"])
data = msg["data"]
self.fd[j] = data["fd"]
self.fd_part[j] = data["fd_part"]
self.config[j] = data["config"]
self.prp[j] = data["prp"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_receive(self, msg):\n raise NotImplementedError",
"def receive_message(self, message):\r\n return",
"def receive(self, message):",
"def receive_message(self, message):",
"def received_message(self, m):\n self.receiver.handle_message(m)",
"def receive(self, msg):\n p... | [
"0.7862769",
"0.76799077",
"0.76312256",
"0.7608615",
"0.7607217",
"0.7538339",
"0.75038445",
"0.74965125",
"0.746925",
"0.7403302",
"0.73713607",
"0.7350669",
"0.73237234",
"0.7297885",
"0.7295632",
"0.7285056",
"0.7275669",
"0.7240056",
"0.7209663",
"0.71553165",
"0.7145084... | 0.0 | -1 |
Called by the API, used to expose data to 3rd party services. | def get_data(self):
return {
"fd": self.get_fd_j(self.id),
"fd_part": self.get_fd_part_j(self.id),
"config": self.config,
# "config": self.get_config_j(self.id),
"prp": self.get_prp_j(self.id),
"alll": self.my_alll(self.id)
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(self):\r\n pass",
"def get_data():\n pass",
"def get_data(self):",
"def get_data(self):\n pass",
"def get_data(self):\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def get_data():\n pass",
"def _get_data(self):\n raise NotImpl... | [
"0.70393324",
"0.70280385",
"0.696577",
"0.6895153",
"0.6895153",
"0.6799701",
"0.6799701",
"0.6799701",
"0.67311615",
"0.670738",
"0.66781694",
"0.6561099",
"0.655223",
"0.6532856",
"0.64652133",
"0.6398914",
"0.6398914",
"0.6334646",
"0.6334482",
"0.62170565",
"0.62081915",... | 0.0 | -1 |
Generate a set of random primary masses from an IMF | def get_M1(M_low=0.5, M_high=10.0, num_sys=1):
C_m = 1.0 / (M_high**(c.alpha+1.0) - M_low**(c.alpha+1.0))
tmp_y = uniform(size=num_sys)
return (tmp_y/C_m + M_low**(c.alpha+1.0))**(1.0/(c.alpha+1.0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def randomize(self):\n random_pfm = [[c for c in row] for row in self.pfm]\n random.shuffle(random_pfm)\n m = Motif(pfm=random_pfm)\n m.id = \"random\"\n return m",
"def sample_masses(M_min=M_min, M_max=M_max, size=1):\n\n A = 1 / (1/M_min - 1/M_max)\n R = np.random.unifo... | [
"0.65151",
"0.6007895",
"0.5946582",
"0.58961266",
"0.58928275",
"0.5833074",
"0.58166003",
"0.56992304",
"0.56806356",
"0.56651413",
"0.5650023",
"0.5640961",
"0.5618418",
"0.5591245",
"0.55861664",
"0.557171",
"0.5536853",
"0.55131465",
"0.55063003",
"0.55022585",
"0.549928... | 0.0 | -1 |
Generate secondary masses from flat mass ratio | def get_M2(M1, num_sys=1):
return M1*uniform(size=num_sys) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_mass(self):\n\n star = self.star\n\n M, K, N = star.mesh_size\n ph = star.phi_coords\n mu = star.mu_coords\n r = star.r_coords\n\n def Q1(j, k):\n sum = 0\n\n for i in range(0, M - 2, 2):\n sum += (1 / 6) * (ph[i + 2] - ph[i]) ... | [
"0.64000714",
"0.6238822",
"0.61394453",
"0.61247844",
"0.6120809",
"0.6029744",
"0.6020185",
"0.60080254",
"0.5945285",
"0.5925701",
"0.59193194",
"0.5916817",
"0.5915651",
"0.59039074",
"0.5874747",
"0.5861079",
"0.5851206",
"0.5851057",
"0.5833349",
"0.5821455",
"0.5799484... | 0.5596177 | 45 |
Generate a set of orbital separations from a power law | def get_a(a_low=1.0e1, a_high=4.41e7, num_sys=1, alpha=-1.6, prob='log_flat'):
if prob == 'log_flat':
C_a = 1.0 / (np.log(a_high) - np.log(a_low))
tmp_y = uniform(size=num_sys)
return a_low*np.exp(tmp_y/C_a)
elif prob == 'raghavan':
mu_P_orb = 5.03
sigma_P_orb = 2.28
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def algebra_generators(self):\n return self.basis().keys().semigroup_generators().map(self.monomial)",
"def _orbits(degree, generators):\n\n orbs = []\n sorted_I = list(range(degree))\n I = set(sorted_I)\n while I:\n i = sorted_I[0]\n orb = _orbit(degree, generators, i)\n... | [
"0.5652893",
"0.5591018",
"0.55886817",
"0.5511983",
"0.53179085",
"0.53030336",
"0.5277192",
"0.52234703",
"0.521836",
"0.5189718",
"0.5187448",
"0.513841",
"0.51347405",
"0.5111671",
"0.5096825",
"0.50921446",
"0.5089524",
"0.50467527",
"0.50381434",
"0.498961",
"0.49811035... | 0.0 | -1 |
Return e from an input distribution | def get_e(num_sys=1, prob='thermal'):
if prob == 'thermal':
return np.sqrt(uniform(size=num_sys))
elif prob == 'flat':
return uniform(size=num_sys)
elif prob == 'circular':
return np.zeros(num_sys)
elif prob == 'tokovinin': # From Tokovinin & Kiyaeva (2016), MNRAS 456
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def e(self):\n if self._e is None:\n # self._e = self.distributions.uniform(0.3,0.33)\n # return self._e\n # max is set by q but also limited by users choice of e_max.\n res_a = 29.9*((self.j[0]/self.k[0])**(2/3))\n q = self.distributions.truncated_norm... | [
"0.7415424",
"0.7137588",
"0.71217835",
"0.695846",
"0.6825506",
"0.63998413",
"0.6388059",
"0.6343656",
"0.6254818",
"0.62431073",
"0.6239055",
"0.6230489",
"0.62157154",
"0.62043214",
"0.6115948",
"0.6113689",
"0.6105811",
"0.6094007",
"0.6073158",
"0.60673875",
"0.60582536... | 0.7340206 | 1 |
Random arguments of periapse | def get_omega(num_sys=1):
return 2.0*np.pi*uniform(size = num_sys) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_params(self, randomize=True):\n pass",
"def get_random_individual():\r\n return [ random.random() for _ in range(PARAMETERS_COUNT) ]",
"def __init__(self, p=0.5):\n assert 0. <= p <= 1.\n self.p = p\n self.rng = T.shared_randomstreams.RandomStreams(seed=123456)\n self.params ... | [
"0.6938783",
"0.6491806",
"0.63690495",
"0.63165206",
"0.6313736",
"0.62580925",
"0.6256701",
"0.622051",
"0.62057483",
"0.62039655",
"0.62012607",
"0.61541957",
"0.61290187",
"0.61183494",
"0.61082566",
"0.6094903",
"0.60927033",
"0.6087658",
"0.60800815",
"0.60666597",
"0.6... | 0.0 | -1 |
Random longitudes of the ascending node | def get_Omega(num_sys=1):
return 2.0*np.pi*uniform(size = num_sys) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_lat_lon(self):\n delta = round(random.random() * random.randint(1, 4), 4)\n sign = random.randint(1, 100)\n if sign % 2 == 0:\n self.lat += delta\n else:\n self.lat -= delta\n\n delta = round(random.random() * random.randint(1, 4), 4)\n sign =... | [
"0.74656385",
"0.6945643",
"0.68974334",
"0.68718785",
"0.68526447",
"0.6818553",
"0.6602211",
"0.64611965",
"0.6382285",
"0.63493824",
"0.63344187",
"0.6205524",
"0.6155454",
"0.6045223",
"0.6034526",
"0.6026114",
"0.60254955",
"0.60047567",
"0.5951849",
"0.5941057",
"0.5939... | 0.0 | -1 |
Wrapper to generate num_sys number of random binaries | def create_binaries(num_sys=1, ecc_prob='thermal', a_prob='log_flat'):
M1 = get_M1(num_sys=num_sys)
M2 = get_M2(M1, num_sys=num_sys)
a = get_a(num_sys=num_sys, prob=a_prob)
e = get_e(num_sys=num_sys, prob=ecc_prob)
M = get_M(num_sys=num_sys)
omega = get_omega(num_sys=num_sys)
Omega = get_Om... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate() -> int:\n return randint(0, 1000000000)",
"def generate_random_num():\n return (long(hexlify(urandom(7)), 16) >> 3) * 2**(-53)",
"def generate_raiz():\n\treturn os.urandom(12)",
"def _gen_random_number() -> float:\n return uniform(0, 1000)",
"def _generate_raw_environments(self,... | [
"0.66994655",
"0.6487863",
"0.61182594",
"0.60619056",
"0.6048561",
"0.60208446",
"0.6018677",
"0.5972783",
"0.5968178",
"0.5900481",
"0.5897057",
"0.5803381",
"0.57801616",
"0.5762383",
"0.5755088",
"0.5753558",
"0.57464737",
"0.5703544",
"0.5691936",
"0.5663027",
"0.5659972... | 0.5641367 | 22 |
Orbital period (days) to separation (Rsun) | def P_to_a(M1, M2, P):
mu = c.GGG * (M1 + M2) * c.Msun_to_g
n = 2.0*np.pi / P / c.day_to_sec
return np.power(mu/(n*n), 1.0/3.0) / c.Rsun_to_cm | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _period( self ):\r\n\treturn 2 * pi * sqrt( self.orbital_elements[0]**3 / self.mu_central_body )\r\n\t# http://en.wikipedia.org/wiki/Orbital_period#Calculation\r",
"def orbitalPeriod_fromRad(r, muPlanet = 3.986e14):\n\tt = 2*np.pi*np.sqrt(r**3/muPlanet)\n\treturn t",
"def period(self) -> int:",
"def do_d... | [
"0.669264",
"0.6487234",
"0.6137466",
"0.59712",
"0.5787186",
"0.5787186",
"0.5583346",
"0.55811644",
"0.55696404",
"0.5547855",
"0.5490516",
"0.54747593",
"0.54678684",
"0.54668385",
"0.54651695",
"0.5447805",
"0.54459494",
"0.54388714",
"0.54260975",
"0.53886",
"0.5387826",... | 0.0 | -1 |
Orbital separation (Rsun) to period (days) | def a_to_P(M1, M2, a):
mu = c.GGG * (M1 + M2) * c.Msun_to_g
n = np.sqrt(mu/(a**3 * c.Rsun_to_cm**3))
return 2.0*np.pi / n / c.day_to_sec | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _period( self ):\r\n\treturn 2 * pi * sqrt( self.orbital_elements[0]**3 / self.mu_central_body )\r\n\t# http://en.wikipedia.org/wiki/Orbital_period#Calculation\r",
"def orbitalPeriod_fromRad(r, muPlanet = 3.986e14):\n\tt = 2*np.pi*np.sqrt(r**3/muPlanet)\n\treturn t",
"def phase_to_day(phase):\n if phase... | [
"0.6482488",
"0.6414512",
"0.62869877",
"0.62869877",
"0.6130169",
"0.59887373",
"0.5953878",
"0.58666456",
"0.5859269",
"0.5816153",
"0.57685345",
"0.5627325",
"0.5604342",
"0.55974203",
"0.55968726",
"0.5568787",
"0.554821",
"0.55030775",
"0.54587173",
"0.5448637",
"0.54360... | 0.0 | -1 |
Function to get the true anomaly | def get_f(M, e):
# Get eccentric anomaly
def func_E(x,M,e):
return M - x + e*np.sin(x)
E = newton(func_E, 0.5, args=(M,e))
# Get true anomaly from eccentric anomaly
f = np.arccos((np.cos(E)-e)/(1.0-e*np.cos(E)))
if np.sin(E) < 0:
f = 2.0*np.pi - f
return f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def anomaly(self):\n return self._anomaly(result_count=1, failure_amount=1)",
"def anomaly():\n\n #Load anomaly dataset\n anomaly_data = LoadDataset(\"dataset/kaggle_anomalies/\",0)\n anomaly_data, anomaly_label, val, val_label = anomaly_data.load_data()\n for i in range (len(anomaly_label)):\n ... | [
"0.81399435",
"0.642333",
"0.6417571",
"0.63595444",
"0.6152872",
"0.61317694",
"0.61164016",
"0.6031858",
"0.6018328",
"0.59970033",
"0.59798664",
"0.59798664",
"0.59798664",
"0.5977451",
"0.59740037",
"0.59740037",
"0.59740037",
"0.5964329",
"0.59347373",
"0.591814",
"0.589... | 0.0 | -1 |
Function to get the projected physical separation | def get_proj_sep(f, e, sep, Omega, omega, inc):
sep_x = sep*(np.cos(Omega)*np.cos(omega+f) - np.sin(Omega)*np.sin(omega+f)*np.cos(inc))
sep_y = sep*(np.sin(Omega)*np.cos(omega+f) + np.cos(Omega)*np.sin(omega+f)*np.cos(inc))
proj_sep = np.sqrt(sep_x**2 + sep_y**2)
return proj_sep | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def separation_radius(self, z_cm):\n # Calculate the separation given an array of redshift values\n # if z_cm is None:\n # z_cm = utils.log_zgrid([0.1, 3.5], 0.01)\n\n dr_cm = WMAP9.kpc_comoving_per_arcmin(z_cm).to(u.Mpc/u.arcsec)\n\n # density\n # dz_thresh = 0.01 # ... | [
"0.58315927",
"0.58251774",
"0.55857515",
"0.5570805",
"0.55141634",
"0.55076575",
"0.5486175",
"0.5476776",
"0.54566306",
"0.5429258",
"0.5419415",
"0.537922",
"0.5353704",
"0.5334152",
"0.5314451",
"0.531292",
"0.5310104",
"0.52699727",
"0.5269345",
"0.52328557",
"0.5232355... | 0.55784225 | 3 |
Return the tangential peculiar velocity | def get_delta_v_tot(f, e, a, P):
coeff = (2.0*np.pi/P) * a / np.sqrt(1.0 - e*e)
delta_v_tot = coeff * (1.0 + 2.0*e*np.cos(f) + e*e) / 1.0e5
return delta_v_tot | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_velocity(self):\n return self.momentum/self.mass",
"def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.pre... | [
"0.720252",
"0.718206",
"0.7076089",
"0.67346025",
"0.6688718",
"0.6685318",
"0.6683201",
"0.6683015",
"0.66693825",
"0.66693825",
"0.66656214",
"0.6619844",
"0.66111654",
"0.6599508",
"0.6594819",
"0.656926",
"0.6568828",
"0.6567502",
"0.65587795",
"0.65563166",
"0.6552568",... | 0.0 | -1 |
Return the tangential peculiar velocity | def get_delta_v_trans(f, e, a, P, Omega, omega, inc):
# r_dot = a * e * np.sin(f) / np.sqrt(1.0 - e*e) * (2.0*np.pi/P)
# r_f_dot = a / np.sqrt(1.0 - e*e) * (1.0 + e*np.cos(f)) * (2.0*np.pi/P)
# delta_vel_1 = r_dot * (np.cos(Omega)*np.cos(omega+f) - np.sin(Omega)*np.sin(omega+f)*np.cos(inc))
# delta_vel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_velocity(self):\n return self.momentum/self.mass",
"def getVelocity(self):\n\t\tif len(self.prevPositions) < 2:\n\t\t\tself.velocity = 0\n\t\telse:\n\t\t\ttime = self.position[2] - self.prevPositions[len(self.prevPositions)-1][2]\n\t\t\txdist = self.position[0][0] - self.prevPositions[len(self.pre... | [
"0.7203267",
"0.71829313",
"0.70765245",
"0.6734887",
"0.6685064",
"0.668375",
"0.6683103",
"0.66702276",
"0.66702276",
"0.66659766",
"0.6620383",
"0.6611471",
"0.65995187",
"0.65948755",
"0.65696913",
"0.65692496",
"0.6567785",
"0.6559351",
"0.6556902",
"0.65530384",
"0.6522... | 0.6689094 | 4 |
From the random orbits, calculate the projected separation, velocity | def calc_theta_delta_v_trans(M1, M2, a, e, M, Omega, omega, inc):
# Calculate f's
num_sys = len(M1)
f = np.zeros(num_sys)
for i in np.arange(num_sys):
f[i] = get_f(M[i], e[i])
# Calculate separations - in Rsun
sep = a * (1.0 - e*e) / (1.0 + e*np.cos(f))
proj_sep = get_proj_sep(f, e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def orbit_posvel(Ms,eccs,semimajors,mreds,obspos=None):\n\n Es = Efn(Ms,eccs) #eccentric anomalies by interpolation\n\n rs = semimajors*(1-eccs*np.cos(Es))\n nus = 2 * np.arctan2(np.sqrt(1+eccs)*np.sin(Es/2),np.sqrt(1-eccs)*np.cos(Es/2))\n\n xs = semimajors*(np.cos(Es) - eccs) #AU\n ys = sem... | [
"0.63251454",
"0.6273948",
"0.6188891",
"0.6090473",
"0.5994018",
"0.59354585",
"0.58900326",
"0.585876",
"0.5821824",
"0.5773603",
"0.5721551",
"0.5704402",
"0.56722057",
"0.56588554",
"0.5617459",
"0.5591772",
"0.55805904",
"0.556481",
"0.55638385",
"0.5555641",
"0.5554868"... | 0.0 | -1 |
From the random orbits, calculate the projected separation, velocity | def calc_theta_delta_v_trans_MOND(M1, M2, a, e, M, Omega, omega, inc):
# Acceleration constant for MOND
a0 = 1.2e-8
# From Scarpa et al. (2017), MOND acts at separations larger than 7000 AU
a_limit = 7000.0 * c.AU_to_cm
# Calculate f's
num_sys = len(M1)
f = np.zeros(num_sys)
proj_sep ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def orbit_posvel(Ms,eccs,semimajors,mreds,obspos=None):\n\n Es = Efn(Ms,eccs) #eccentric anomalies by interpolation\n\n rs = semimajors*(1-eccs*np.cos(Es))\n nus = 2 * np.arctan2(np.sqrt(1+eccs)*np.sin(Es/2),np.sqrt(1-eccs)*np.cos(Es/2))\n\n xs = semimajors*(np.cos(Es) - eccs) #AU\n ys = sem... | [
"0.6325394",
"0.6273604",
"0.61889213",
"0.60910815",
"0.5992941",
"0.5935161",
"0.5889572",
"0.5858033",
"0.5822188",
"0.57730037",
"0.5721572",
"0.57053345",
"0.567247",
"0.5658431",
"0.56169254",
"0.5591375",
"0.5579938",
"0.5565701",
"0.55635047",
"0.5555609",
"0.55549604... | 0.0 | -1 |
This function calculates the probability of a random star having the observed proper motion | def get_P_binary(proj_sep, delta_v_trans, num_sys=100000, method='kde', kde_method='sklearn'):
# Catalog check
global binary_set
if binary_set is None:
generate_binary_set(num_sys=num_sys)
if method is 'kde':
# Use a Gaussian KDE
global binary_kde
#if binary_kde is Non... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_probability(self):\n return 0",
"def p(self) -> Probability:\n ...",
"def prob1(n):\n#raise NotImplementedError(\"Problem 1 Incomplete\")\n if n == 0 :\n raise ValueError(\"Sampling 0 points is not defined.\")\n total = 0\n for i in xrange(n) :\n if np.random.... | [
"0.6616909",
"0.66122586",
"0.65956324",
"0.65656006",
"0.6558705",
"0.6527563",
"0.65138316",
"0.6502501",
"0.63788253",
"0.6353283",
"0.6345645",
"0.6345645",
"0.6343374",
"0.6284382",
"0.62379724",
"0.62123704",
"0.61686015",
"0.61510676",
"0.61377114",
"0.6118212",
"0.610... | 0.0 | -1 |
This function calculates the probability of a random star having the observed proper motion | def get_P_binary_v_tot(proj_sep, delta_v_tot, num_sys=100000):
# Catalog check
global binary_set
if binary_set is None:
generate_binary_set(num_sys=num_sys)
# Use a Gaussian KDE
global binary_v_tot_kde
# We work in log space for the set of binaries
if binary_v_tot_kde is None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_probability(self):\n return 0",
"def p(self) -> Probability:\n ...",
"def prob1(n):\n#raise NotImplementedError(\"Problem 1 Incomplete\")\n if n == 0 :\n raise ValueError(\"Sampling 0 points is not defined.\")\n total = 0\n for i in xrange(n) :\n if np.random.... | [
"0.6616407",
"0.6611605",
"0.6594753",
"0.6565147",
"0.6557539",
"0.65286505",
"0.65132105",
"0.6502074",
"0.6378543",
"0.63531625",
"0.6344999",
"0.6344999",
"0.6343321",
"0.62833744",
"0.62366265",
"0.6212156",
"0.61679083",
"0.61501026",
"0.613744",
"0.61175925",
"0.610784... | 0.0 | -1 |
Create set of binaries to be saved to P_binary.binary_set | def generate_binary_set(num_sys=100000, ecc_prob='thermal', a_prob='log_flat', method='kepler'):
global binary_set
if method != 'kepler' and method != 'MOND':
print("You must provide a valid method.")
return
# Create random binaries
M1, M2, a, e, M, Omega, omega, inc = create_binaries... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createBinObjects(n):\n bins = []\n for i in range(n):\n \tbins.append(Bin())\n return bins",
"def get_binaries(kdb,entry):\n xml = objectify.fromstring(entry.dump_xml())\n binaries = list(xml.xpath('./Binary'))\n for binary in binaries:\n yield (binary.Key.text, Binary(kdb,binary)... | [
"0.5964837",
"0.59422576",
"0.5907919",
"0.58536303",
"0.5810957",
"0.55953133",
"0.5575792",
"0.5559989",
"0.5528495",
"0.54272175",
"0.54035234",
"0.5372073",
"0.5370181",
"0.5360584",
"0.5342469",
"0.5317253",
"0.53051674",
"0.52968377",
"0.5291435",
"0.5269143",
"0.525454... | 0.6768494 | 0 |
This function calculates the binary prior | def get_prior_binary(ra, dec, mu_ra, mu_dec, t, sigma_pos=None, sigma_mu=None):
if sigma_pos is None: sigma_pos = P_random.get_sigma_pos(ra, dec, catalog=t)
if sigma_mu is None: sigma_mu = P_random.get_sigma_mu(mu_ra, mu_dec, catalog=t)
C2_prior = sigma_pos * sigma_mu * len(t) * c.f_bin
return C2_pri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bias_prior(self):",
"def prior(old_params,params):\n \n for s in range(len(params)):\n if params[s] < 0.0 or params[s] > 2:\n return 0\n return 1",
"def lnprior(params):\n a, b, f = params\n if -10.0 < b < 0. and 0. < a < 10 and 0. < f:\n return 0.0\n\n return -np... | [
"0.7155866",
"0.699966",
"0.6571168",
"0.6567543",
"0.64442766",
"0.63115424",
"0.6297148",
"0.6282599",
"0.6273565",
"0.6272402",
"0.62659776",
"0.6243217",
"0.62369555",
"0.6232393",
"0.6206088",
"0.61796415",
"0.61197674",
"0.6055244",
"0.6032322",
"0.60282356",
"0.6008326... | 0.6521243 | 4 |
Create a set of random binaries and plot the distribution of resulting theta vs pm | def create_plot_binary(dist=100.0, num_sys=100, bins=25):
global binary_set
if binary_set is None or len(binary_set) != num_sys:
generate_binary_set(num_sys=num_sys, dist=dist)
fig, ax1 = plt.subplots(1,1, figsize=(6,4))
# Plot limits
xmin, xmax = 0.0, 5000.0
ymin, ymax = 0.0, 3.0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_rand(txyxidata, b,X, outfile):\r\n\t\r\n\tme = \"LE_Plot.plot_rand: \"\r\n\tif os.path.isfile(outfile): return me+\"skip\"\r\n\tt0 = time.time()\r\n\tshowplot = False\r\n\t\r\n\tt, x, eta, xi = txyxidata\r\n\tdel txyxidata\r\n\ttmax = np.ceil(t.max())\r\n\t\r\n\t## Plot walk\r\n\tfs = 25\r\n\twinsize = in... | [
"0.6268543",
"0.614437",
"0.5935378",
"0.59198856",
"0.59051406",
"0.58652925",
"0.5832034",
"0.58278227",
"0.57644266",
"0.5739203",
"0.57001245",
"0.56712866",
"0.5613258",
"0.56017554",
"0.5589682",
"0.5588418",
"0.5587215",
"0.5586687",
"0.55653733",
"0.55634075",
"0.5549... | 0.5565269 | 19 |
The main clustering algorithm "Adaptive Density Level Set Clustering" | def cluster(name, epsilon: float, delta: float, tau: float, tree_structure='automatic', threads=1,
sequential_search_threshold=2000, return_list=False, epsilon_multiple=None, output_name=None):
global dataListGlobal, index_inverse_global
if output_name is None:
output_name = get_filename(na... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n se... | [
"0.71741533",
"0.67322356",
"0.6666687",
"0.65774506",
"0.65705204",
"0.65535855",
"0.65231776",
"0.65206176",
"0.65019965",
"0.64918864",
"0.6490709",
"0.64769727",
"0.64763695",
"0.6370144",
"0.63568753",
"0.6326915",
"0.63129586",
"0.6295431",
"0.62900186",
"0.6275923",
"0... | 0.0 | -1 |
Test parsing a NatNet 3.0 packet containing an EchoRequest message. | def test_parse_echorequest_packet_v3():
data = open('test_data/echorequest_packet_v3.bin', 'rb').read()
echo_request = deserialize(data, Version(3), strict=True) # type: EchoRequestMessage
assert echo_request.timestamp == 278554190 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_nmap_icmp_echo_request(self):\n assert_equal(self.test_nmap.ICMP_ECHO_REQUEST, 8)",
"def test_serialize_echorequest_message():\n expected = open('test_data/echorequest_packet_v3.bin', 'rb').read()\n actual = serialize(EchoRequestMessage(278554190))\n\n assert actual == expected",
"def ... | [
"0.6922761",
"0.645755",
"0.62202394",
"0.61036783",
"0.6077745",
"0.5845379",
"0.561444",
"0.56112283",
"0.5592843",
"0.5554618",
"0.55424106",
"0.5531693",
"0.55176955",
"0.5470128",
"0.5331703",
"0.52536505",
"0.5216656",
"0.52039826",
"0.5197637",
"0.5129498",
"0.5113845"... | 0.78382856 | 0 |
Test serializing an EchoRequest message. | def test_serialize_echorequest_message():
expected = open('test_data/echorequest_packet_v3.bin', 'rb').read()
actual = serialize(EchoRequestMessage(278554190))
assert actual == expected | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_parse_echorequest_packet_v3():\n data = open('test_data/echorequest_packet_v3.bin', 'rb').read()\n echo_request = deserialize(data, Version(3), strict=True) # type: EchoRequestMessage\n\n assert echo_request.timestamp == 278554190",
"def test_to_from_bytes(self):\n self.assertIsInstance... | [
"0.6572642",
"0.61764574",
"0.6086326",
"0.59407955",
"0.5922413",
"0.58965194",
"0.58927226",
"0.5885049",
"0.5877283",
"0.5793095",
"0.5780958",
"0.57690734",
"0.5724307",
"0.5715814",
"0.571562",
"0.56420356",
"0.5629515",
"0.5627429",
"0.56192356",
"0.56028426",
"0.559966... | 0.802424 | 0 |
Read the `file_name` and return a list of words. | def get_word_bank(file_name: str = "word_bank.txt") -> list[str]:
txt_file = Path(__file__).parent / file_name
return [x.strip() for x in txt_file.read_text().splitlines() if x.strip()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_words_in_file(file_name):\n\n\tlines = get_file_contents(file_name)\n\tall_words = []\n\tfor line in lines:\n\t\t# remove lines that don't have words on them\n\t\tif len(line) < 2:\n\t\t\tcontinue\n\t\tline = line.rstrip() # removes \\n at the end of each line\n\t\twords = line.split()\n\t\tfor word in wor... | [
"0.8380143",
"0.8295852",
"0.82919544",
"0.8151556",
"0.80914605",
"0.80806166",
"0.79787743",
"0.7968935",
"0.7963683",
"0.79565525",
"0.7956438",
"0.79367113",
"0.79367113",
"0.7934003",
"0.7849445",
"0.7846242",
"0.7816437",
"0.7779671",
"0.77628523",
"0.7730976",
"0.77243... | 0.7516058 | 34 |
Returns the library context used in this discovery context. | def get_library_context(cls) -> tlib.LibraryContext:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def context(self):\n LOGGER.debug('Getting context: %s', self._context)\n return self._context",
"def context(self):\n return self._context",
"def context(self):\n return self._context",
"def context(self):\n return self._context",
"def context(self):\n return self... | [
"0.667756",
"0.66378725",
"0.66378725",
"0.66378725",
"0.66378725",
"0.66378725",
"0.66378725",
"0.66378725",
"0.663065",
"0.66174483",
"0.6544556",
"0.649594",
"0.6494292",
"0.6387364",
"0.63614374",
"0.63529253",
"0.6344479",
"0.63225037",
"0.63176763",
"0.6317549",
"0.6312... | 0.77775526 | 0 |
Given an item path, yields all valid meta file paths that could provide direct metadata for that item. This also verifies that all of the resulting meta file paths exist. | def meta_files_from_item(cls, rel_item_path: pl.Path) -> tt.PathGen:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def items_from_meta_file(cls, rel_meta_path: pl.Path) -> tt.PathMetadataPairGen:\n pass",
"def items_from_meta_file(cls, rel_meta_path: pl.Path) -> tt.PathMetadataPairGen:\n rel_meta_path, abs_meta_path = library_context.co_norm(rel_sub_path=rel_meta_path)\n\n # Check that the provid... | [
"0.66138536",
"0.6287318",
"0.5991842",
"0.59201646",
"0.55912",
"0.55242085",
"0.53850317",
"0.536932",
"0.535586",
"0.5347209",
"0.53227246",
"0.5274453",
"0.5271265",
"0.5266176",
"0.51852953",
"0.5179801",
"0.51075685",
"0.5093312",
"0.50908816",
"0.5088963",
"0.50860953"... | 0.7029848 | 0 |
Given a meta file path, yields all item paths that this meta file provides metadata for, along with the metadata itself. | def items_from_meta_file(cls, rel_meta_path: pl.Path) -> tt.PathMetadataPairGen:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def meta_files_from_item(cls, rel_item_path: pl.Path) -> tt.PathGen:\n pass",
"def items_from_meta_file(cls, rel_meta_path: pl.Path) -> tt.PathMetadataPairGen:\n rel_meta_path, abs_meta_path = library_context.co_norm(rel_sub_path=rel_meta_path)\n\n # Check that the provided path exis... | [
"0.6940595",
"0.69089586",
"0.6876326",
"0.64572424",
"0.628037",
"0.62579995",
"0.5958289",
"0.5942649",
"0.59193397",
"0.59042585",
"0.587694",
"0.5822334",
"0.57854456",
"0.5695793",
"0.56426466",
"0.5638825",
"0.5620414",
"0.56117773",
"0.55844843",
"0.55390435",
"0.55067... | 0.71756345 | 0 |
Given a meta file path, yields all item paths that this meta file provides metadata for, along with the metadata itself. | def items_from_meta_file(cls, rel_meta_path: pl.Path) -> tt.PathMetadataPairGen:
rel_meta_path, abs_meta_path = library_context.co_norm(rel_sub_path=rel_meta_path)
# Check that the provided path exists and is a file.
if not abs_meta_path.is_file():
msg = f'Meta file ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def items_from_meta_file(cls, rel_meta_path: pl.Path) -> tt.PathMetadataPairGen:\n pass",
"def meta_files_from_item(cls, rel_item_path: pl.Path) -> tt.PathGen:\n pass",
"def _walk_dir_meta(self):\n for key, child in sorted(self._children.items()):\n if isinstance(child, PackageE... | [
"0.7175146",
"0.69405776",
"0.6876897",
"0.64581895",
"0.6280624",
"0.6258256",
"0.5957642",
"0.5943421",
"0.5919406",
"0.59043944",
"0.5877299",
"0.5823322",
"0.5785377",
"0.5695088",
"0.5643666",
"0.563889",
"0.56202036",
"0.5613605",
"0.55839753",
"0.5538756",
"0.5506507",... | 0.69089144 | 2 |
Set figure dimensions to sit nicely in our document. | def set_size(width_pt=430.00462, fraction=1, subplots=(1, 1), golden_ratio=1):
# Width of figure (in pts)
fig_width_pt = width_pt * fraction
# Convert from pt to inches
inches_per_pt = 1 / 72.27
# Golden ratio to set aesthetic figure height
# golden_ratio = (5**.5 - 1) / 2
# Figure width i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_figure_size(self):\n lims, _ = self.set_lims()\n size_fac = 50\n paperSizeFac = 0.65\n one_dec = 1.6\n xdecs = np.log10(lims(1)) - np.log10(lims(0))\n one_dec = one_dec * 4 / xdecs\n ydecs = np.log10(lims[3]) - np.log10(lims[2])\n paper_width = xdecs ... | [
"0.7354754",
"0.68874747",
"0.6691664",
"0.6680031",
"0.66291857",
"0.65430367",
"0.65289485",
"0.64953256",
"0.6470769",
"0.6351633",
"0.63221294",
"0.63212305",
"0.6305874",
"0.6265708",
"0.6263046",
"0.6263046",
"0.6263046",
"0.62619877",
"0.6215848",
"0.62117124",
"0.6204... | 0.6455241 | 9 |
Given an (n x 2) matrix of (x, y) ordered pairs, return an (n x n x 2) matrix M of differences so that m_{j,k} = x_j x_k. | def build_difs_matrix(xs):
n = len(xs)
difs = np.zeros((n, n, 2))
for row_id in range(n):
ident = -np.eye(n)
ident[:, row_id] += 1
difs[row_id, :, 0] = ident @ xs[:, 0]
difs[row_id, :, 1] = ident @ xs[:, 1]
return difs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def det_matrix_2x2(m: list):\n return m[0][0]*m[1][1] - m[0][1]*m[1][0]",
"def delta_matrix(x, y=None):\n # 1 x N x D (1 x N if we view the last axis as a whole)\n if type(y) == type(None):\n y = x\n x = np.expand_dims(x, axis=0)\n y = np.expand_dims(y, axis=0)\n return np.moveaxis(x, 0,... | [
"0.6474755",
"0.5953065",
"0.5938427",
"0.5882346",
"0.5844783",
"0.5815114",
"0.57700604",
"0.568207",
"0.56775004",
"0.562826",
"0.55804396",
"0.5579718",
"0.55030394",
"0.5438494",
"0.5408733",
"0.5406271",
"0.5398787",
"0.5398416",
"0.53746647",
"0.5368937",
"0.53512144",... | 0.0 | -1 |
Compute the righthand side for the 1st order | def rhs1(t, state):
# Get the number of prey
n = (len(state) // 2) - 1
# Extract the prey positions
xs = state[2:].reshape(n, 2)
# Extract the predator position
z = state[:2]
# Compute the differences between the prey
# positions and the predator positio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def orig(side):\n return (side + 1) % 3 # ccw(side)",
"def left (x):\n\n return Sinary(side(x.v,1))",
"def right (x):\n\n return Sinary(side(x.v,0))",
"def _right(self, index):\r\n return 2*index + 2",
"def _right(self, col, row):\n ones = 0\n twos = 0\n for st... | [
"0.6480988",
"0.62802595",
"0.623735",
"0.6105407",
"0.6098619",
"0.6089276",
"0.6055689",
"0.60474217",
"0.60154814",
"0.59407306",
"0.59407306",
"0.5914894",
"0.590506",
"0.5880765",
"0.5880765",
"0.5871038",
"0.5866244",
"0.58380574",
"0.58325565",
"0.58253336",
"0.5812927... | 0.0 | -1 |
Wrapper for scipy.integrate.solve_ivp that uses tqdm to monitor progress. | def solve_ivp_tqdm(fun, t_span, y0, t_eval, **kwargs):
sol = None
n = len(t_eval) - 1
for i in tqdm(range(n)):
t0 = t_eval[i]
tf = t_eval[i + 1]
s = solve_ivp(fun, [t0, tf], y0, t_eval=[t0, tf], **kwargs)
y0 = s.y[:, 1]
if sol is None:
sol = s
else... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tqdm(*args, **kwargs):\n kwargs_ = dict(file=sys.stdout, disable=C.DISPLAY.PROGRESS.DISABLE, leave=False)\n kwargs_.update(kwargs)\n clear_tqdm()\n return tq.tqdm(*args, **kwargs_)",
"def __call__(self, pv, sp, dt, freeze_ff=False): \n error = sp - pv\n if not freeze_ff:\n ... | [
"0.57856476",
"0.54917467",
"0.54638255",
"0.5340637",
"0.53261566",
"0.5145216",
"0.51342434",
"0.5121947",
"0.51104546",
"0.5110409",
"0.50878906",
"0.5081126",
"0.503787",
"0.50289875",
"0.49790072",
"0.49576634",
"0.49356022",
"0.49148926",
"0.49119833",
"0.49048683",
"0.... | 0.67726123 | 0 |
Bake the simulation for figure 2 from the paper. | def bake_regimes_figure():
d = {'n': 400, # 400,
'a': 1,
'b': 0.2,
'p': 3,
'cs': np.asarray([0.15, 0.4, 0.8, 1.5, 2.5]),
'times': np.asarray([[0, 45, 55, 60, 70, 80, 100],
[0, 0.35, 0.85, 2.35, 4.85, 9.85, 21.05],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simulationTwoDrugsDelayedTreatment():\n\n # TODO",
"def make_simulation(self):\n pass",
"def Main():\n numberOfPopulation = 350\n numberOfDays = 60\n \n simulation = Simulation(Covid19(), numberOfPopulation, numberOfDays, \"Covid 19 Simulation\")\n simulation.run() \n simulat... | [
"0.65148926",
"0.60968244",
"0.60415083",
"0.59246224",
"0.5909946",
"0.5894872",
"0.5844042",
"0.5806909",
"0.5765315",
"0.57645464",
"0.57575774",
"0.5751835",
"0.574717",
"0.5740862",
"0.57390875",
"0.5732647",
"0.57138056",
"0.5709134",
"0.56926733",
"0.568895",
"0.567669... | 0.52665377 | 93 |
Return (left, right) and (bottom, top) tuples specifying a square viewport of sidelength `width` centered at `center`. | def compute_xy_lims(center, width):
x, y = center
w2 = width / 2
return (x - w2, x + w2), (y - w2, y + w2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def center(width, height):\n return width/2, height/2",
"def get_bottom_center(left, right):\n x = (right.x - left.x) / 2 + left.x\n y = right.y - (right.y - left.y) / 5\n return (x, y)",
"def center2corner(center):\n x, y, w, h = center[0], center[1], center[2], center[3]\n x1 = x - w * ... | [
"0.69217473",
"0.6217429",
"0.6214814",
"0.613843",
"0.6086448",
"0.6063258",
"0.6029447",
"0.59973025",
"0.59623396",
"0.59502745",
"0.59427935",
"0.5881541",
"0.587597",
"0.5813926",
"0.5798873",
"0.57948077",
"0.57931226",
"0.5784657",
"0.57794344",
"0.57760435",
"0.575416... | 0.62433493 | 1 |
Set the viewport to be a square of sidelength `width` centered at the mean of the data. | def set_ax_lims(ax, xs, ys, width=2.5):
center = (xs.mean(), ys.mean())
xlim, ylim = compute_xy_lims(center, width)
ax.set_xlim(xlim)
ax.set_ylim(ylim) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def setWidth(*args):",
"def set_width(self, width):\n... | [
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5904734",
"0.5809414",
"0.5734108",
"0.5702411",
"0.569464",
"0.568543",
"0.56622624",
"0.5616756",
"0.56004506",
"0.5594036",
"0.5594036",
"... | 0.0 | -1 |
Replicate figure 2 from the paper. | def make_regimes_figure():
d = pickle.load(open('regimes.pickle', 'rb'))
fig, ax_matrix = plt.subplots(*d['times'].shape,
figsize=set_size(fraction=1,
subplots=d['times'].shape))
for row_id, (axes, c, ts) in enumerate(zip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fig_2():\n epoch = 3\n N = 60000\n Nr = N\n K = 32\n n_iter = 256\n Nstar = 16\n data = 'dr10'\n factor = 100.\n features = ['psf_mag', 'model_colors', 'psf_minus_model']\n filters = ['r', 'ug gr ri iz', 'ugriz']\n message = 'pm_mc_pmm_r_all_all'\n model = 'xdmodel_%s_%d_%d_... | [
"0.5918637",
"0.59148043",
"0.5729256",
"0.5667046",
"0.5649839",
"0.5555471",
"0.5472683",
"0.5443591",
"0.5438068",
"0.54345113",
"0.5421252",
"0.53784335",
"0.5355207",
"0.5343826",
"0.5295455",
"0.52814543",
"0.5265556",
"0.52616036",
"0.5235621",
"0.51987725",
"0.5197005... | 0.0 | -1 |
prevedeni obrazku na cernobily | def greyScale(img, shape):
s, v = shape
greyPicture = [sum(img[i]) / 3 for i in range(v * s)]
return greyPicture | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mezclar_bolsa(self):",
"def cliquer_sur_unité(self):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def podziel(self):\n def fraktal(dlugosc, alpha, poziom):\n \"\"\"Metoda wyznaczajaca fr... | [
"0.6707366",
"0.6552483",
"0.6486341",
"0.6486341",
"0.6486341",
"0.6486341",
"0.6486341",
"0.6212716",
"0.5865186",
"0.5821931",
"0.5794412",
"0.57473534",
"0.5747329",
"0.5704396",
"0.56910485",
"0.56881607",
"0.56881607",
"0.56881607",
"0.56881607",
"0.56881607",
"0.568816... | 0.0 | -1 |
anisotropic filtering of image | def anisotropie(img, shape, lambdaValue=0.1, sigma=0.015):
h, w = shape
newPicture = copy.copy(img)
for row in range(1, h - 1):
for column in range(1, w - 1):
north = float(img[(row - 1) * w + column])
south = float(img[(row + 1) * w + column])
west = float(img[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_filter(self, image):\n pass",
"def custom_filter(image: Image) -> Image:\n image = image.filter(ImageFilter.Kernel(\n size=(3, 3), kernel=(1, 0, 1, 0, 0, 0, 1, 0, 1)))\n return image",
"def filter_image(img):\n return cv2.bilateralFilter(img, 9, 50, 50)",
"def filtering(self)... | [
"0.7440313",
"0.7173908",
"0.70498675",
"0.6904407",
"0.6758465",
"0.67095786",
"0.6634642",
"0.6616985",
"0.6608021",
"0.6580589",
"0.65700567",
"0.6567188",
"0.65615916",
"0.6527729",
"0.65277004",
"0.6503931",
"0.64302045",
"0.64226204",
"0.6419179",
"0.6396645",
"0.638951... | 0.6093233 | 39 |
Updates the metric with given true and predicted value for a timestep. | def update(self, y_true, y_pred):
self.y_true.append(y_true)
self.y_pred.append(y_pred) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, y_true: list[Number], y_pred: list[Number]) -> ForecastingMetric:",
"def _update(self, time_step, **train_kwargs):\n # training is implied here\n self.set_t_cutoff(self.cutoff_t + time_step, **train_kwargs)",
"def update(self, y_pred: torch.Tensor, y_true: torch.Tensor) -> None:\... | [
"0.6576584",
"0.62704575",
"0.6262165",
"0.6231757",
"0.60995567",
"0.6043346",
"0.6043346",
"0.5948913",
"0.57387596",
"0.57233065",
"0.57221586",
"0.57048523",
"0.56996983",
"0.5699047",
"0.5646774",
"0.56256723",
"0.5622597",
"0.5620955",
"0.5553786",
"0.55417526",
"0.5487... | 0.59305936 | 8 |
Gets the current value of the score. | def get(self):
score = self._evaluate(self.y_true, self.y_pred)
return score | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_score(self):\n return self.score",
"def get_score(self):\n return self.score",
"def get_score(self):\n return self.score",
"def getScore(self):\r\n return self._score",
"def get_score(self):\n return self._score",
"def get_score(self):\n return self._scor... | [
"0.8346142",
"0.8346142",
"0.8346142",
"0.82685524",
"0.82329327",
"0.82329327",
"0.82329327",
"0.81996274",
"0.8153556",
"0.8084667",
"0.80073917",
"0.7920184",
"0.7873557",
"0.7837606",
"0.77810675",
"0.7692049",
"0.76469946",
"0.751065",
"0.7477388",
"0.74663246",
"0.74570... | 0.6870809 | 97 |
Abstract method to be filled with the sklearn metric. | def _evaluate(self, y_true, y_pred):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n super().__init__()\n self.metric = 'AVGDIST'",
"def compute_metrics(self):\n pass",
"def _get_eval_metric(self):\n raise NotImplementedError",
"def __init__(self):\n super().__init__()\n self.metric = 'AUC'",
"def test_get_derived_metric(self)... | [
"0.6940169",
"0.6921432",
"0.6865521",
"0.683773",
"0.6775468",
"0.6678773",
"0.6529701",
"0.6487454",
"0.6459841",
"0.6435887",
"0.6404384",
"0.63758117",
"0.6339544",
"0.6301063",
"0.6298025",
"0.6288517",
"0.62738615",
"0.62386024",
"0.62353283",
"0.62189716",
"0.6189819",... | 0.0 | -1 |
Handle login requests On successfull login a session with a length of an hour should be generated. On failure an error should be thrown. | def login():
hasher = PasswordHasher()
payload = request.json
username = payload['user']
password = payload['pass']
DBSessionMaker = sessionmaker(bind=engine)
db_session = DBSessionMaker()
try:
user = db_session.query(Users).get(username)
hasher.verify(user.password, passw... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logged_in(handler):\n\n def check_login(self, *args, **kwargs):\n jwtToken = self.request.headers.get('Authorization', None)\n\n if jwtToken:\n # validate token\n try:\n userToken = jwt.decode(\n jwtToken,\n defaultConf... | [
"0.62985647",
"0.6271258",
"0.6153987",
"0.61011446",
"0.61011446",
"0.6089704",
"0.607207",
"0.60559976",
"0.60424393",
"0.6018455",
"0.6008699",
"0.5993032",
"0.5970212",
"0.5953699",
"0.59374076",
"0.5935772",
"0.59291905",
"0.59214896",
"0.5899712",
"0.589537",
"0.5883899... | 0.58135813 | 25 |
Handle logout requests Delete user's session entry in the sessions table Also, delete user's cookie whether session entry delete is successful or not Return 200 OK on success Otherwise, return 500 INTERNAL SERVER ERROR | def logout():
DBSessionMaker = sessionmaker(bind=engine)
db_session = DBSessionMaker()
# Find and delete user's session entry in the session table
try:
cookie_sess_id = request.cookies.get('session')
db_session.query(Sessions).filter(Sessions.id==cookie_sess_id).delete()
db_sess... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logout():\n session.clear()\n return json_response(status=200, response_data={\"success\": True})",
"def logout():\n body = request.json\n user_id = body.get('user_id')\n user = User.get(User.id == user_id).username\n clear_token(user)\n return HTTPResponse(status=200, body={\"message\":... | [
"0.7407927",
"0.7350498",
"0.7283106",
"0.7283106",
"0.7241016",
"0.7215676",
"0.72012705",
"0.7179627",
"0.7175114",
"0.7168609",
"0.7154243",
"0.71284455",
"0.7119963",
"0.71039796",
"0.70737725",
"0.7069549",
"0.7069501",
"0.70591354",
"0.70546526",
"0.7053894",
"0.7050064... | 0.81909466 | 0 |
Fills result_buffer with l, r bounds of intervals in w > low_threshold which exceed high_threshold somewhere | def find_intervals_above_threshold(w, high_threshold, low_threshold, result_buffer, dynamic_low_threshold_coeff=0):
in_candidate_interval = False
current_interval_passed_test = False
current_interval = 0
result_buffer_size = len(result_buffer)
last_index_in_w = len(w) - 1
current_candidate_inter... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regrid(old_grid):\n bins = np.floor((np.log10(old_grid) - l_min) / dl).astype(int)\n w = (bins >= 0) & (bins < nbins)\n\n return bins, w",
"def Bounds_to_short_filter(chargeBounds,dischargeBounds):\n \n global time_treshold \n \n ## first Filter filters all the windows which are below a ... | [
"0.553738",
"0.54760826",
"0.5427398",
"0.53159803",
"0.5290415",
"0.5239659",
"0.5216173",
"0.51883864",
"0.51512986",
"0.51274943",
"0.5100661",
"0.5094",
"0.5070553",
"0.5060594",
"0.50378984",
"0.50272125",
"0.49709576",
"0.49683148",
"0.4963083",
"0.4962075",
"0.49619874... | 0.73507464 | 0 |
Finds argmax, area and center of gravity of hits in w indicated by (l, r) bounds in raw_hits. raw_hits should be a numpy array of (left, right) bounds (inclusive) Other arguments are numpy arrays which will be filled with results. centers, argmaxes are returned in samples right of hit start you probably want to convert... | def compute_hit_properties(w, raw_hits, argmaxes, areas, centers):
for hit_i in range(len(raw_hits)):
current_max = -999.9
current_argmax = -1
current_area = 0.0
current_center = 0.0
for i, x in enumerate(w[raw_hits[hit_i, 0]:raw_hits[hit_i, 1]+1]):
if x > current... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getTopCenterIndices(self, resolution, rectangular):\n # get x, y indices to get away from the ring basis.\n # indices starts with (0, 0) in the middle, with (r2, p1) -> (1, 0), etc. (x is on the pos 1 ray)\n\n numAxialLevels = 2 * resolution\n xi, yi = self.indices()\n if r... | [
"0.54468155",
"0.5245982",
"0.52018434",
"0.51407737",
"0.5027572",
"0.501179",
"0.49909672",
"0.49505368",
"0.49250877",
"0.49115202",
"0.49069312",
"0.4905353",
"0.48982129",
"0.48870504",
"0.4865395",
"0.48550183",
"0.4845263",
"0.47969246",
"0.4787651",
"0.4767172",
"0.47... | 0.73296267 | 0 |
Compute basic pulse properties quickly | def compute_pulse_properties(w, initial_baseline_samples):
# First compute baseline
baseline = 0.0
initial_baseline_samples = min(initial_baseline_samples, len(w))
for x in w[:initial_baseline_samples]:
baseline += x
baseline /= initial_baseline_samples
# Now compute mean, noise, and m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, power, T0_ps, center_wavelength_nm,\n time_window_ps = 10., frep_MHz = 100., NPTS = 2**10, \n GDD = 0, TOD = 0, chirp2 = 0, chirp3 = 0,\n power_is_avg = False):\n\n Pulse.__init__(self, frep_MHz = frep_MHz, n = NPTS)\n # make sure we ... | [
"0.6358498",
"0.6317641",
"0.63023865",
"0.60456705",
"0.60405445",
"0.59185964",
"0.5912954",
"0.58964646",
"0.5826671",
"0.5813686",
"0.58130246",
"0.5761169",
"0.5713485",
"0.56207675",
"0.56019944",
"0.55966306",
"0.5565917",
"0.55059624",
"0.55000675",
"0.5494248",
"0.54... | 0.60221887 | 5 |
Prepares the data for creating ML models | def prepare_data(camera, image_nums):
from gen_d_params import gen_d_params
# Fetch the data of interest set by "camera" and "image_nums"
imgs = [camera + x for x in image_nums]
d_params = gen_d_params(imgs)
# Add azimuth feature for pixel location
d_params["err_ang"] = np.rad2deg(np.arcta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prepare_data(self):\n #TODO hardcoded values need to change\n print_info(\"Preprocessing the train data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"train\"),\n self.TRAIN_OUT_PATH)\n\n print_info(\"Preprocessing the test data..... | [
"0.80092263",
"0.74358416",
"0.7237138",
"0.7234688",
"0.71888596",
"0.715646",
"0.7066007",
"0.7044061",
"0.7012535",
"0.69576716",
"0.69042885",
"0.6898071",
"0.6874291",
"0.67918086",
"0.6788373",
"0.6775429",
"0.67715067",
"0.67438567",
"0.6699872",
"0.6649036",
"0.662834... | 0.0 | -1 |
Checks if _any_ robot enters the provided regions | def get_validation_status(self, world) -> ValidationStatus:
for region in self.regions:
for robot in world.friendly_team.team_robots:
if tbots.contains(
region, tbots.createPoint(robot.current_state.global_position)
):
return Va... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkRegions(self, iPlayer, regionList, bVassal=False):\n\t\tfor regionID in regionList:\n\t\t\tif not utils.checkRegionControl(iPlayer, regionID, bVassal):\n\t\t\t\treturn False\n\t\treturn True",
"def is_in_state(location, state_regions):\n flag=0\n for each in state_regions:\n if is_in_region... | [
"0.6682395",
"0.6617277",
"0.655005",
"0.65364325",
"0.6430662",
"0.6267606",
"0.61465126",
"0.61261976",
"0.6090589",
"0.6046472",
"0.6023994",
"0.6016984",
"0.59815913",
"0.59123266",
"0.5840832",
"0.58313024",
"0.5781557",
"0.57534957",
"0.5749572",
"0.57270414",
"0.569021... | 0.0 | -1 |
(override) shows regions to enter | def get_validation_geometry(self, world) -> ValidationGeometry:
return create_validation_geometry(self.regions) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_regions(view=None):\r\n # Get current active view\r\n if view is None:\r\n view = sublime.active_window().active_view()\r\n # Unable to set regions when no view available\r\n if view is None:\r\n return\r\n\r\n # Do no set regions if view is empty or still loading\r\n if ... | [
"0.65240884",
"0.6408818",
"0.633112",
"0.6262963",
"0.60573566",
"0.6022681",
"0.5926789",
"0.59011424",
"0.5846541",
"0.58321047",
"0.58177316",
"0.58080935",
"0.579175",
"0.57498974",
"0.574381",
"0.57271105",
"0.57197857",
"0.5711749",
"0.5662972",
"0.5655112",
"0.5649187... | 0.0 | -1 |
Construct a basic RNN cell. It is configured to be passed to a multi rnn cell wrapper. | def build_rnn_cell(type, num_units, dropout):
cell = tf.nn.rnn_cell.BasicRNNCell(num_units)
if dropout:
result = tf.nn.rnn_cell.DropoutWrapper(cell,
output_keep_prob=1-dropout)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_rnn_cell(num_units,\n num_layers,\n num_residual_layers,\n dropout,\n mode,\n num_gpus,\n base_gpu=0,\n single_cell_fn=None,\n all_layer_outputs=False):... | [
"0.71335816",
"0.6953759",
"0.6925032",
"0.6800048",
"0.6565086",
"0.65646267",
"0.637898",
"0.6358356",
"0.6312413",
"0.62985456",
"0.629002",
"0.6288718",
"0.62280524",
"0.61890537",
"0.6145752",
"0.612748",
"0.6081028",
"0.60306144",
"0.6012887",
"0.5991209",
"0.59855443",... | 0.6650443 | 4 |
Construct a basic RNN cell. It is configured to be passed to a multi rnn cell wrapper. | def build_lstm_cell(num_units, dropout):
cell = tf.nn.rnn_cell.LSTMCell(num_units)
if dropout:
result = tf.nn.rnn_cell.DropoutWrapper(cell,
output_keep_prob=1-dropout)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_rnn_cell(num_units,\n num_layers,\n num_residual_layers,\n dropout,\n mode,\n num_gpus,\n base_gpu=0,\n single_cell_fn=None,\n all_layer_outputs=False):... | [
"0.7134765",
"0.69544786",
"0.6926675",
"0.68001246",
"0.6651791",
"0.6566028",
"0.6565687",
"0.638008",
"0.63594615",
"0.63141453",
"0.6299174",
"0.62913984",
"0.6288368",
"0.6231029",
"0.61889553",
"0.61449057",
"0.612983",
"0.60820633",
"0.60315627",
"0.6013897",
"0.599206... | 0.0 | -1 |
Construct a GRU RNN cell. It is configured to be passed to a multi rnn cell wrapper. | def build_gru_cell(num_units, dropout):
cell = tf.nn.rnn_cell.GRUCell(num_units)
if dropout:
result = tf.nn.rnn_cell.DropoutWrapper(cell,
output_keep_prob=1-dropout)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initialize_gru_cell(self, num_units):\n return gru_cell.LayerNormGRUCell(\n num_units,\n w_initializer=self.uniform_initializer,\n u_initializer=random_orthonormal_initializer,\n b_initializer=tf.constant_initializer(0.0))",
"def build_rnn_cell(type, num_units, dropout):\n ... | [
"0.75219285",
"0.67751324",
"0.65611047",
"0.652693",
"0.65234923",
"0.6497355",
"0.6401402",
"0.6371681",
"0.6347477",
"0.6342275",
"0.62993085",
"0.6285365",
"0.6272967",
"0.6165039",
"0.61427605",
"0.6132339",
"0.610192",
"0.6040023",
"0.59487605",
"0.58486575",
"0.5812393... | 0.75191617 | 1 |
Multi RNN cell wraps a sequence of cells into one cell | def build_multi_rnn(cells):
return tf.nn.rnn_cell.MultiRNNCell(cells) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_rnn_cells(self, is_list=False):\n\n stacked_rnn = []\n for _ in range(self.num_layers):\n single_cell = self._rnn_single_cell()\n stacked_rnn.append(single_cell)\n\n if is_list:\n return stacked_rnn\n else:\n return tf.nn.rnn_cell.... | [
"0.7117752",
"0.70600027",
"0.674815",
"0.65157115",
"0.6431374",
"0.63540703",
"0.6354059",
"0.62947875",
"0.6241957",
"0.6232274",
"0.61524653",
"0.6138036",
"0.6061001",
"0.6054821",
"0.6045019",
"0.5993263",
"0.59205985",
"0.5865216",
"0.5863549",
"0.58027077",
"0.5800259... | 0.76230234 | 0 |
resize input in order to produce sampled depth map | def scale_camera(cam, scale=1):
new_cam = np.copy(cam)
# focal:
new_cam[1][0][0] = cam[1][0][0] * scale
new_cam[1][1][1] = cam[1][1][1] * scale
# principle point:
new_cam[1][0][2] = cam[1][0][2] * scale
new_cam[1][1][2] = cam[1][1][2] * scale
return new_cam | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resized_map(self, new_size):\n\n new_map = cv2.resize(self.map.copy(), new_size)\n cur_count = np.sum(new_map)\n\n # Avoid dividing by zero\n if cur_count == 0:\n return new_map\n\n scale = self.count / cur_count\n new_map *= scale\n return new_map",
... | [
"0.6337556",
"0.58340174",
"0.58162516",
"0.5748601",
"0.5645124",
"0.558781",
"0.55794656",
"0.5574537",
"0.5515735",
"0.5503842",
"0.5475208",
"0.54662806",
"0.546386",
"0.54406154",
"0.5417694",
"0.5378523",
"0.5363706",
"0.5360747",
"0.53576624",
"0.5348146",
"0.5339047",... | 0.0 | -1 |
resize input in order to produce sampled depth map | def scale_mvs_camera(cams, scale=1):
for view in range(FLAGS.view_num):
cams[view] = scale_camera(cams[view], scale=scale)
return cams | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resized_map(self, new_size):\n\n new_map = cv2.resize(self.map.copy(), new_size)\n cur_count = np.sum(new_map)\n\n # Avoid dividing by zero\n if cur_count == 0:\n return new_map\n\n scale = self.count / cur_count\n new_map *= scale\n return new_map",
... | [
"0.6338632",
"0.5834115",
"0.5815747",
"0.5748118",
"0.5644575",
"0.5589045",
"0.5579177",
"0.55736023",
"0.55167085",
"0.5504079",
"0.5475519",
"0.5465852",
"0.5462426",
"0.54406005",
"0.5418562",
"0.5378243",
"0.53638965",
"0.5361241",
"0.53567934",
"0.53504694",
"0.5339551... | 0.0 | -1 |
resize image using cv2 | def scale_image(image, scale=1, interpolation='linear'):
if interpolation == 'linear':
return cv2.resize(image, None, fx=scale, fy=scale, interpolation=cv2.INTER_LINEAR)
if interpolation == 'nearest':
return cv2.resize(image, None, fx=scale, fy=scale, interpolation=cv2.INTER_NEAREST) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resize(image):\r\n return cv2.resize(image, (200, 66), interpolation=cv2.INTER_AREA)",
"def resize_image(img, width, height):\n\n return cv2.resize(img, (width, height))",
"def resize_image(image_path):\n img = cv2.imread(image_path);\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB);\n img = cv2... | [
"0.8261548",
"0.8075126",
"0.8029768",
"0.8016128",
"0.7924036",
"0.7875393",
"0.78491545",
"0.7844469",
"0.7772517",
"0.77287513",
"0.77221835",
"0.7603124",
"0.7569391",
"0.75212836",
"0.7410956",
"0.73702043",
"0.73482066",
"0.73242635",
"0.73195106",
"0.7284048",
"0.72769... | 0.0 | -1 |
resize input to fit into the memory | def scale_mvs_input(images, cams, depth_image=None, scale=1):
for view in range(FLAGS.view_num):
images[view] = scale_image(images[view], scale=scale)
cams[view] = scale_camera(cams[view], scale=scale)
if depth_image is None:
return images, cams
else:
depth_image = scale_ima... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resize(self):\n pass",
"def _resize(self, new_capacity):\n temp_array = self.make_array(new_capacity)\n for i in range(self.n):\n temp_array[i] = self.original_array[i]\n self.original_array = temp_array\n self.capacity = new_capacity",
"def resize(self, old, n... | [
"0.6756476",
"0.6747655",
"0.6701643",
"0.6621688",
"0.6541919",
"0.6481869",
"0.64757544",
"0.63817364",
"0.6371053",
"0.63494724",
"0.63349277",
"0.631679",
"0.6284716",
"0.62780786",
"0.62718976",
"0.6259087",
"0.62462807",
"0.61517614",
"0.6054047",
"0.5986684",
"0.598603... | 0.0 | -1 |
resize images and cameras to fit the network (can be divided by base image size) | def crop_mvs_input(images, cams, depth_image=None):
# crop images and cameras
for view in range(FLAGS.view_num):
h, w = images[view].shape[0:2]
new_h = h
new_w = w
if new_h > FLAGS.height:
new_h = FLAGS.height
else:
new_h = int(math.ceil(h / FLAGS... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resize_real_images(self, images):\n block_idx = (self.growth_idx + 1) // 2\n height, width = self.params[\"generator_projection_dims\"][0:2]\n resized_image = tf.image.resize(\n images=images,\n size=[\n height * (2 ** block_idx), width * (2 ** block_id... | [
"0.66563886",
"0.66166437",
"0.6392838",
"0.6369865",
"0.63596517",
"0.63324946",
"0.6206985",
"0.6188757",
"0.6171561",
"0.6120761",
"0.60885406",
"0.60879236",
"0.6077981",
"0.607681",
"0.6075122",
"0.607204",
"0.6069862",
"0.6055661",
"0.6013288",
"0.6003485",
"0.6003485",... | 0.0 | -1 |
mask outofrange pixel to zero | def mask_depth_image(depth_image, min_depth, max_depth):
# print ('mask min max', min_depth, max_depth)
ret, depth_image = cv2.threshold(depth_image, min_depth, 100000, cv2.THRESH_TOZERO)
ret, depth_image = cv2.threshold(depth_image, max_depth, 100000, cv2.THRESH_TOZERO_INV)
depth_image = np.expand_dims... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Mask(self) -> int:",
"def mask(self):",
"def applymask(self,mask):\n self.spec[mask==0]=np.nan",
"def pixel2mask(image: np.ndarray, low: float, high: float) -> np.ndarray:\n mask = image > low\n labels = smeasure.label(mask, background=0)\n for region in smeasure.regionprops(label_image=l... | [
"0.7277648",
"0.70975006",
"0.6916187",
"0.67861253",
"0.6672735",
"0.6455906",
"0.6452693",
"0.6435973",
"0.63348085",
"0.63294333",
"0.6324877",
"0.63084173",
"0.6267788",
"0.6267649",
"0.6242802",
"0.62425005",
"0.6238908",
"0.6234164",
"0.6233499",
"0.61704344",
"0.616048... | 0.0 | -1 |
read camera txt file | def load_cam(file, interval_scale=1, max_d = None):
cam = np.zeros((2, 4, 4))
words = file.read().split()
# read extrinsic
for i in range(0, 4):
for j in range(0, 4):
extrinsic_index = 4 * i + j + 1
cam[0][i][j] = words[extrinsic_index]
# read intrinsic
for i in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cam_read(filename):\n f = open(filename,'rb')\n check = np.fromfile(f,dtype=np.float32,count=1)[0]\n assert check == TAG_FLOAT, ' cam_read:: Wrong tag in flow file (should be: {0}, is: {1}). Big-endian machine? '.format(TAG_FLOAT,check)\n M = np.fromfile(f,dtype='float64',count=9).reshape((3,3))\n ... | [
"0.6273761",
"0.61905116",
"0.6149404",
"0.6120383",
"0.60943437",
"0.5985097",
"0.59676677",
"0.59638536",
"0.5951896",
"0.5951896",
"0.5945563",
"0.5891649",
"0.5891006",
"0.5866269",
"0.58474845",
"0.58314574",
"0.5801502",
"0.5800049",
"0.5794519",
"0.5760646",
"0.5747874... | 0.52473044 | 96 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.