import sys import re import warnings warnings.filterwarnings("ignore", message="numpy.dtype size changed") warnings.filterwarnings("ignore", message="numpy.ufunc size changed") # call the helper from helper import load_obj, save_obj, init_driver, searchJobs, text_cleaner, get_pause, \ string_from_text # 1- Load existing dictionary. Check for initial dictionary. # If empty initialize try: jobDict = load_obj('glassDoorDict') link = load_obj('glassDoorlink') except: save_obj([], 'glassDoorlink') save_obj({}, 'glassDoorDict') jobDict = load_obj('glassDoorDict') link = load_obj('glassDoorlink') print('len(jobDict) = '+str(len(jobDict))+ ', len(link) = '+str(len(link))) # 2- Choose what you want to do: # get_link => Scraping for links and brief data, # get_data => Scraping for detailed data.
return data src_data = get_data('source_space') tgt_data = get_data('target_space') #################################### #################################### # start iterating over the files for filename in os.listdir(path_gen): if filename.endswith('.pkl'): name = filename.replace('.pkl', '') epoch = int(name.split('_')[1]) temp = float(name.split('_')[2]) data = hp.load_obj(f'{path_gen}{name}') novo = data['novo_tr'] novo = get_n_random(novo, N_fcd, name) f_dist_src = get_frechet_dist(src_data, novo) f_dist_tgt = get_frechet_dist(tgt_data, novo) frechet_dist = {'f_dist_src': f_dist_src, 'f_dist_tgt': f_dist_tgt} hp.save_obj(frechet_dist, f'{save_path}frechet_{epoch}_{temp}') if verbose: print( f'e: {epoch}, t: {temp}, FCD to src: {f_dist_src}, FCD to tgt: {f_dist_tgt}' ) end = time.time()
out_channels_uv=256, bilinear=True) # load the best weights from the training loop correspondence_block.load_state_dict( torch.load('correspondence_block.pt', map_location=torch.device('cpu'))) pose_refiner = Pose_Refiner() # load the best weights from the training loop pose_refiner.load_state_dict( torch.load('pose_refiner.pt', map_location=torch.device('cpu'))) correspondence_block.cuda() pose_refiner.cuda() pose_refiner.eval() correspondence_block.eval() list_all_images = load_obj(root_dir + "all_images_adr") testing_images_idx = load_obj(root_dir + "test_images_indices") regex = re.compile(r'\d+') upsampled = nn.Upsample(size=[240, 320], mode='bilinear', align_corners=False) total_score = 0 for i in range(len(testing_images_idx)): img_adr = list_all_images[testing_images_idx[i]] label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1] idx = regex.findall(os.path.split(img_adr)[1])[0] tra_adr = root_dir + label + "/data/tra" + str(idx) + ".tra" rot_adr = root_dir + label + "/data/rot" + str(idx) + ".rot" true_pose = get_rot_tra(rot_adr, tra_adr)
torch.load(correspondence_block_filename, map_location=torch.device('cpu'))) pose_refiner = Pose_Refiner() print("Loading pose_refiner block") # load the best weights from the training loop pose_refiner.load_state_dict( torch.load('pose_refiner.pt', map_location=torch.device('cpu'))) correspondence_block.cuda() pose_refiner.cuda() pose_refiner.eval() correspondence_block.eval() print("Listing all images") list_all_images = load_obj(sys.path.join(root_dir, "all_images_adr")) testing_images_idx = load_obj( sys.path.join(train_eval_dir, "test_images_indices")) regex = re.compile(r'\d+') upsampled = nn.Upsample(size=[240, 320], mode='bilinear', align_corners=False) total_score = 0 print("For all %i test images..." % len(testing_images_idx)) for i in range(len(testing_images_idx)): if i % 100 == 0: print("\t %i / %i" % (i, len(testing_images_idx))) img_adr = list_all_images[testing_images_idx[i]] label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1] idx = regex.findall(os.path.split(img_adr)[1])[0]
def initial_pose_estimation(root_dir, train_eval_dir, classes, intrinsic_matrix): for c in classes: class_pred_pose_fname = os.path.join(train_eval_dir, c, "predicted_pose") if not os.path.exists(class_pred_pose_fname): os.makedirs(class_pred_pose_fname) # LineMOD Dataset train_data = LineMODDataset(root_dir, train_eval_dir, classes=classes, transform=transforms.Compose( [transforms.ToTensor()])) # load the best correspondence block weights correspondence_block = UNET.UNet(n_channels=3, out_channels_id=14, out_channels_uv=256, bilinear=True) correspondence_block.cuda() correspondence_block_filename = os.path.join(train_eval_dir, 'correspondence_block.pt') correspondence_block.load_state_dict( torch.load(correspondence_block_filename, map_location=torch.device('cpu'))) # initial 6D pose prediction regex = re.compile(r'\d+') outliers = 0 for i in range(len(train_data)): if i % 100 == 0: print(str(i) + "/" + str(len(train_data)) + " finished!") img_adr, img, idmask, _, _ = train_data[i] label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1] idx = regex.findall(os.path.split(img_adr)[1])[0] img = img.view(1, img.shape[0], img.shape[1], img.shape[2]) idmask_pred, umask_pred, vmask_pred = correspondence_block(img.cuda()) # convert the masks to 240,320 shape temp = torch.argmax(idmask_pred, dim=1).squeeze().cpu() upred = torch.argmax(umask_pred, dim=1).squeeze().cpu() vpred = torch.argmax(vmask_pred, dim=1).squeeze().cpu() coord_2d = (temp == classes[label]).nonzero(as_tuple=True) adr = os.path.join( train_eval_dir, label + "/predicted_pose/" + "info_" + str(idx) + ".txt") coord_2d = torch.cat( (coord_2d[0].view(coord_2d[0].shape[0], 1), coord_2d[1].view( coord_2d[1].shape[0], 1)), 1) uvalues = upred[coord_2d[:, 0], coord_2d[:, 1]] vvalues = vpred[coord_2d[:, 0], coord_2d[:, 1]] dct_keys = torch.cat((uvalues.view(-1, 1), vvalues.view(-1, 1)), 1) dct_keys = tuple(dct_keys.numpy()) dct = load_obj(os.path.join(root_dir, label + "/UV-XYZ_mapping")) mapping_2d = [] mapping_3d = [] for count, (u, v) in enumerate(dct_keys): if (u, v) in dct: mapping_2d.append(np.array(coord_2d[count])) mapping_3d.append(dct[(u, v)]) # Get the 6D pose from rotation and translation matrices # PnP needs atleast 6 unique 2D-3D correspondences to run if len(mapping_2d) >= 4 or len(mapping_3d) >= 4: _, rvecs, tvecs, inliers = cv2.solvePnPRansac( np.array(mapping_3d, dtype=np.float32), np.array(mapping_2d, dtype=np.float32), intrinsic_matrix, distCoeffs=None, iterationsCount=150, reprojectionError=1.0, flags=cv2.SOLVEPNP_P3P) rot, _ = cv2.Rodrigues(rvecs, jacobian=None) rot[np.isnan(rot)] = 1 tvecs[np.isnan(tvecs)] = 1 tvecs = np.where(-100 < tvecs, tvecs, np.array([-100.])) tvecs = np.where(tvecs < 100, tvecs, np.array([100.])) rot_tra = np.append(rot, tvecs, axis=1) # save the predicted pose np.savetxt(adr, rot_tra) else: # save a pose full of zeros outliers += 1 rot_tra = np.ones((3, 4)) rot_tra[:, 3] = 0 np.savetxt(adr, rot_tra) print("Number of instances where PnP couldn't be used: ", outliers)
gamma = 1 num_actions = 4 num_states = shape[0] * shape[1] human_policy = init_nonrandom_policy() #init_random_policy(25, 4) human_performance = np.mean(evaluate_policy(env, human_policy)) print("human performance: ", human_performance) saved_model = True if not saved_model: learning_rate = 0.005 untrained_agent = QLearning(num_actions, gamma, learning_rate) trained_agent = optimal_agent(env, untrained_agent, num_episodes=10000) q_star = trained_agent.q_table save_obj(dict(q_star), "q_star") else: q_star = load_obj("q_star") J_star = np.max(q_star[startState]) baseline = human_performance shared = [] nq_cost = [] min_cost = [] mod_shared = [] alphas = np.concatenate((np.arange(0, 1e-3, 1e-4), np.arange(1e-3, 1e-2, 1e-3), np.arange(1e-2, 0.1, 1e-2), np.arange(0.1, 1.01, 0.1))) for alpha in tqdm(alphas): min_performance = baseline + alpha * (J_star - baseline) #mincost """
parser.add_argument("--split", default=0.15, help="train:test split ratio") parser.add_argument("--randomseed", default=69, help="train:test split random seed") args = parser.parse_args() root_dir = args.root_dir background_dir = args.bgd_dir train_eval_dir = args.train_eval_dir # Pickling this eliminates the need to walk the dir which takes a while, especially # on Google Colab when using a mounted drive if os.path.exists(os.path.join(root_dir, "all_images_adr.pkl")): print("all_images_adr.pkl found. Assuming GT exists") gt_exists = True list_all_images = load_obj(os.path.join(root_dir, "all_images_adr")) else: gt_exists = False list_all_images = [] for root, dirs, files in os.walk(root_dir): for file in files: if file.endswith(".jpg"): # images that exist list_all_images.append(os.path.join(root, file)) if os.path.exists(os.path.join(train_eval_dir, "train_images_indices.pkl")): sys.exit("train_images_indices.pkl found. Nothing to do.") num_images = len(list_all_images) indices = list(range(num_images)) np.random.seed(args.randomseed) np.random.shuffle(indices)
def create_GT_masks(root_dir, background_dir, intrinsic_matrix, classes): """ Helper function to create the Ground Truth ID,U and V masks Args: root_dir (str): path to the root directory of the dataset background_dir(str): path t intrinsic_matrix (array): matrix containing camera intrinsics classes (dict) : dictionary containing classes and their ids Saves the masks to their respective directories """ list_all_images = load_obj(root_dir + "all_images_adr") training_images_idx = load_obj(root_dir + "train_images_indices") for i in range(len(training_images_idx)): img_adr = list_all_images[training_images_idx[i]] label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1] regex = re.compile(r'\d+') idx = regex.findall(os.path.split(img_adr)[1])[0] if i % 1000 == 0: print(str(i) + "/" + str(len(training_images_idx)) + " finished!") image = cv2.imread(img_adr) ID_mask = np.zeros((image.shape[0], image.shape[1])) U_mask = np.zeros((image.shape[0], image.shape[1])) V_mask = np.zeros((image.shape[0], image.shape[1])) ID_mask_file = root_dir + label + \ "/ground_truth/IDmasks/color" + str(idx) + ".png" U_mask_file = root_dir + label + \ "/ground_truth/Umasks/color" + str(idx) + ".png" V_mask_file = root_dir + label + \ "/ground_truth/Vmasks/color" + str(idx) + ".png" tra_adr = root_dir + label + "/data/tra" + str(idx) + ".tra" rot_adr = root_dir + label + "/data/rot" + str(idx) + ".rot" rigid_transformation = get_rot_tra(rot_adr, tra_adr) # Read point Point Cloud Data ptcld_file = root_dir + label + "/object.xyz" pt_cld_data = np.loadtxt(ptcld_file, skiprows=1, usecols=(0, 1, 2)) ones = np.ones((pt_cld_data.shape[0], 1)) homogenous_coordinate = np.append(pt_cld_data[:, :3], ones, axis=1) # Perspective Projection to obtain 2D coordinates for masks homogenous_2D = intrinsic_matrix @ ( rigid_transformation @ homogenous_coordinate.T) coord_2D = homogenous_2D[:2, :] / homogenous_2D[2, :] coord_2D = ((np.floor(coord_2D)).T).astype(int) x_2d = np.clip(coord_2D[:, 0], 0, 639) y_2d = np.clip(coord_2D[:, 1], 0, 479) ID_mask[y_2d, x_2d] = classes[label] if i % 100 != 0: # change background for every 99/100 images background_img_adr = background_dir + \ random.choice(os.listdir(background_dir)) background_img = cv2.imread(background_img_adr) background_img = cv2.resize(background_img, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_AREA) background_img[y_2d, x_2d, :] = image[y_2d, x_2d, :] # background_img = cv2.cvtColor(background_img, cv2.COLOR_BGR2RGB) background_adr = root_dir + label + \ "/changed_background/color" + str(idx) + ".png" cv2.imwrite(background_adr, background_img) # Generate Ground Truth UV Maps centre = np.mean(pt_cld_data, axis=0) length = np.sqrt((centre[0] - pt_cld_data[:, 0])**2 + (centre[1] - pt_cld_data[:, 1])**2 + (centre[2] - pt_cld_data[:, 2])**2) unit_vector = [(pt_cld_data[:, 0] - centre[0]) / length, (pt_cld_data[:, 1] - centre[1]) / length, (pt_cld_data[:, 2] - centre[2]) / length] U = 0.5 + (np.arctan2(unit_vector[2], unit_vector[0]) / (2 * np.pi)) V = 0.5 - (np.arcsin(unit_vector[1]) / np.pi) U_mask[y_2d, x_2d] = U V_mask[y_2d, x_2d] = V # Saving ID, U and V masks after using the fill holes function ID_mask, U_mask, V_mask = fill_holes(ID_mask, U_mask, V_mask) cv2.imwrite(ID_mask_file, ID_mask) cv2.imwrite(U_mask_file, U_mask * 255) cv2.imwrite(V_mask_file, V_mask * 255)
#modelg= KeyedVectors.load_word2vec_format(EMBEDDING_FILE, binary=True,limit=40000) url='https://raw.githubusercontent.com/Pratikmehta1729/walkover/master/eng_sites_dataset_2.0_shuffled.csv' #get titles,l,title_map df = pd.read_csv(url) l=[] titles=[] y=df.title.tolist() x=df.text.tolist() title_map={} count=0 for title in y: title_map[title]=count titles.append(title) count+=1 for item in x: l.append(item.split()) sentences = l modelg = Word2Vec(sentences, min_count=1,size=200) kmeans=load_obj("kmeans") X=load_obj("X") labels=load_obj("labels") centroids=load_obj("centroids") final_dict=load_obj("final_dict")
import pandas as pd # saving graph/doc embeddings path_to_data = 'fill me' #####==================PCA===========================############## gl_embds = np.save(path_to_data + 'graph_mv.npy') k = 50 pca = PCA(n_components=k) gl_pca = pca.fit_transform(gl_embds) SAVE = True if SAVE: np.save(path_to_data + 'gl_pca.npy', gl_pca) del gl_embds graphs = load_obj(path_to_data, 'graphs') # Rearranging the embeddings into the initial order SAVE = False if SAVE: print('unstructued emveddings') ml_embds = np.load(path_to_data + 'ml_embds_mv.npy') print('original embeddings') embds = np.load(path_to_data + 'embeddings.npy') print('building embeddings matrix...\n') embeddings_mv = np.zeros((embds.shape[0], ml_embds.shape[2])) for i, graph in enumerate(graphs): for j, node in enumerate(graph.nodes()): embeddings_mv[node] = ml_embds[i, j, :] sys.stderr.write('\rGraph: %d/%d' % (i + 1, len(graphs)))
def __init__(self, root_dir, classes=None, transform=None): self.root_dir = root_dir self.transform = transform self.classes = classes self.list_all_images = load_obj(root_dir + "all_images_adr") self.training_images_idx = load_obj(root_dir + "train_images_indices")
from helper import load_obj messages = load_obj('skype_messages') print(messages.keys())