def inference(): inf = Inference(model_path=f'models/{args.predict_type}.h5', sample_dir='samples', inference_type=args.predict_type, inference_csv=f'data/{args.predict_type}.csv') inf.predict(save_result=True)
def main(args): inference = Inference(args.model) inference.load_model() input = args.input if input == 0: input_feeder = InputFeeder('cam', input) elif input.endswith('.jpg') or input.endswith('.jpeg') or input.endswith( '.bmp'): input_feeder = InputFeeder('image', input) is_image = True else: input_feeder = InputFeeder('video', input) input_feeder.load_data() if is_image: outputs = inference.predict(input_feeder.cap) inference.preprocess_output(outputs) return 0 frames = 0 for ret, frame in input_feeder.next_batch(): if not ret: break frames += 1 key = cv2.waitKey(60) if key == 27: break outputs = inference.predict(frame) inference.preprocess_output(outputs) input_feeder.close()
def get_predicted_result(predict_images, cid_array): """ TODO: Give the predict here. :param predict_images: the images array :param cid_array: the oriented type, left center or right : 0,1,2 :return: """ infer = Inference() results = infer.predict(predict_images) new_results = [] new_results1 = [] for i in results: i.sort(reverse=True, key=lambda j: float(j.split(":")[1])) new_results.append(i[0].split(":")[0]) new_results1.append(i[0]) max_results = max_list(new_results) sum = 0 num = new_results.count(max_results) for rid in new_results1: if rid.split(":")[0] == max_results: sum = sum + float(rid.split(":")[1]) end_result = round(sum / num, 2) return end_result, max_results
def find_similar(fen, num=1, similarity_function=nearest): """ Finds x smallest values in a table. :param fen: String with chess position in Fen notation :param num: Number of games to be found :param similarity_function: Function that measures the similarity of vectors :return: list of games with similar positions """ coder = Autoencoder(settings.BOARD_SHAPE, settings.LATENT_SIZE).to( settings.DEVICE ) coder.load_state_dict(torch.load(settings.CODER_PATH, map_location=settings.DEVICE)) coder = coder.coder coder.eval() inf = Inference(settings.DEVICE, coder) target = inf.predict([fen]).tolist()[0] conn = sqlite3.connect(settings.DATABASE) cursor = conn.cursor() cursor.execute("select Embeding FROM positions_lite") matrix = cursor.fetchall() matrix = [json.loads(x[0])[0] for x in matrix] scores = similarity_function(matrix, target) idx = find_lowest(scores, num) return Games(find_game(idx, cursor))
coder = model.Autoencoder(settings.BOARD_SHAPE, settings.LATENT_SIZE).to(settings.DEVICE) coder.load_state_dict( torch.load(settings.CODER_PATH, map_location=settings.DEVICE)) coder = coder.coder coder.eval() inf = Inference(settings.DEVICE, coder) csv_name = "positions_lite.csv" ID = 0 with open(csv_name, "w", newline="") as file: writer = csv.writer(file, delimiter=";") writer.writerow(["ID", "Author", "Number", "Move", "Embeding"]) games_csv = open(os.path.join(os.getcwd(), 'games_lite.csv')) for row in games_csv: try: data = row[:-2].split(";") board = chess.Board() for idx, move in enumerate(get_move(data[3])): board.push_san(move) tensor = inf.predict([board.fen()]) writer.writerow( [ID, data[0], int(data[1]), idx, str(tensor.tolist())]) ID += 1 except: print("Error on " + data[0], data[1])
if camera_type_fisheye: dims = (640, 480) map1, map2 = cv2.fisheye.initUndistortRectifyMap( camera_matrix, distortion_coefficients, np.eye(3), camera_matrix, dims, cv2.CV_16SC2) frame = cv2.remap(frame, map1, map2, interpolation=cv2.INTER_LINEAR, borderMode=cv2.BORDER_CONSTANT) else: frame = cv2.undistort(frame, camera_matrix, distortion_coefficients) original_shape = frame.shape[0:2] frame = cv2.resize(frame, tuple(model_input_shape)) prediction, visualization = inference.predict(frame, True) image_pub.publish(visualization, True) prediction = cv2.resize(prediction, (640, 480)).argmax(axis=2) border = get_segmentation_border(prediction, every_n=5) print(border.shape) #border = np.array([0, 480], dtype=np.float32) - np.array(border, dtype=np.float32) #border = np.abs(border) #border = border.reshape((border.shape[0], 1, 2)) #border = cv2.undistortPoints(border, camera_matrix, distortion_coefficients) #border = border.reshape((border.shape[0], 2)) #print(border.shape) #print(border) rays = multi_raycast(border, camera_config)
class Main(Frame): def __init__( self, master, color_palette, home_path, pieces_name, pieces_path, arrows_path, images_sizes, selected_piece, pieces_padding, header_height = 60, option_width = 100, message_width = 600, message_height = 200, find_options_width = 600, find_options_height = 400, ): Frame.__init__(self, master, bg=color_palette[0]) master.rowconfigure(0, weight=1) master.columnconfigure(0, weight=1) self.main = self self.coder_set = False self.home_path = home_path self.current_pages = 0 self.pages_fens = ["rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"] self.pieces_name = pieces_name self.pieces_path = pieces_path self.arrows_path = arrows_path self.images_sizes = images_sizes self.selected_piece = selected_piece self.pieces_padding = pieces_padding self.color_palette = color_palette self.entering = True self.follow_fen = True self.fen_placement = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR" self.fen_player = "w" self.fen_castling = "KQkq" self.header_height = header_height self.option_width = option_width self._create_widgets(message_width, message_height, find_options_width, find_options_height) self.bind("<Configure>", self._resize) self.winfo_toplevel().minsize(600, 600) self.display_fen() self.coder = None self.games = None self.store_games = None self.lichess_set = False self.coder_launcher = None self.set_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1") self.set_coder(settings.CODER_PATH) def _create_widgets(self, message_width, message_height,find_options_width, find_options_height): self.board_box = BoardBox(self) self.option_box = Options(self, self.option_width) self.header = Header(self, header_height=self.header_height) self.pgn_box = PGNOptions(self, self.option_width) self.tensor_message = TensorDisplayer(self, message_width, message_height) self.find_option = FindOptions(self,find_options_width, find_options_height) self.lichess_set_option = LichessSetOptions(self,find_options_width,find_options_height) self.board_box.grid(row=1, column=0, sticky=N + S + E + W) self.option_box.grid(row=1, column=1, sticky=N + S + E + W) self.header.grid(row=0, column=0, columnspan=2, sticky=N + S + E + W) self.rowconfigure(1, weight=1) self.columnconfigure(0, weight=1) def show_lichess_options(self): self.lichess_set_option.place(relx=0.5, rely=0.5, anchor=CENTER) self.find_option.place_forget() def set_lichess(self,name,n_games): try: with urlopen("https://lichess.org/api/games/user/{}?max={}&perfType=ultraBullet,bullet,blitz,rapid,classical,correspondence".format(name, n_games)) as pgn: self.games = pgn_games(pgn,n_games) self.lichess_set_option.place_forget() self.header.coder_label["text"]="Account set" self.follow_fen = True self.entering = False self.lichess_set = True self.set_fen() self.option_box.grid_forget() self.pgn_box.grid(row=1, column=1, sticky=N + S + E + W) self.pgn_box.set_game_number() except: self.header.display_fen("Lichess Account couldn't be set", "", "") def _resize(self, event): """Modify padding when window is resized.""" w, h = event.width, event.height self.rowconfigure(1, weight=h - self.header_height) self.columnconfigure(0, weight=w - self.option_width) def display_fen(self): self.header.display_fen(self.fen_placement, self.fen_player, self.fen_castling) if self.follow_fen: self.pages_fens[self.current_pages] = " ".join( [self.fen_placement, self.fen_player, self.fen_castling, "- 0 0"] ) def set_fen(self, fen=None): if self.entering == False: fen = self.games.board.fen() split_fen = fen.split() self.fen_placement = split_fen[0] self.fen_player = split_fen[1] self.fen_castling = split_fen[2] self.board_box.board.set_board(self.fen_placement) if self.follow_fen: self.pages_fens[self.current_pages] = fen self.display_fen() return try: a = chess.Board(fen) fen = a.fen() del a split_fen = fen.split() self.fen_placement = split_fen[0] self.fen_player = split_fen[1] self.fen_castling = split_fen[2] self.option_box.set_option(self.fen_player, self.fen_castling) self.board_box.board.set_board(self.fen_placement) self.pages_fens[self.current_pages] = fen except ValueError: self.header.display_fen("Incorrect fen", "", "") def set_coder(self, filename): try: self.coder = Autoencoder(settings.BOARD_SHAPE, settings.LATENT_SIZE).to( settings.DEVICE ) self.coder.load_state_dict(torch.load(filename, map_location=settings.DEVICE)) self.coder = self.coder.coder self.coder.eval() self.coder_launcher = Inference( settings.DEVICE, self.coder, ) self.coder_set = True self.header.coder_label["text"]="Coder Set" return True except: return False def show_find_option(self): if self.coder_set: self.find_option.place(relx=0.5, rely=0.5, anchor=CENTER) self.lichess_set_option.place_forget() else: self.header.coder_label["text"]="Set Coder first" def run_coder(self,number,comparison): if self.coder_set: if self.lichess_set: self.store_games = self.games output = str( self.coder_launcher.predict([self.pages_fens[self.current_pages]]) ) self.find_option.place_forget() self.display_tensor(output) self.games = find_similar(self.pages_fens[self.current_pages], number, similarity_functions[comparison]) self.entering = False self.follow_fen = False self.set_fen() self.option_box.grid_forget() self.pgn_box.grid(row=1, column=1, sticky=N + S + E + W) self.pgn_box.set_game_number() def exit_pgn_options(self): if self.lichess_set: if self.follow_fen : self.lichess_set = False else: self.games = self.store_games self.follow_fen = True self.set_fen() self.option_box.grid_forget() self.pgn_box.set_game_number() return self.pgn_box.grid_forget() self.option_box.grid(row=1, column=1, sticky=N + S + E + W) self.entering = True self.follow_fen = True self.set_fen(self.pages_fens[self.current_pages]) def display_tensor(self, message): self.tensor_message.set_message(message) self.tensor_message.place(relx=0.5, rely=0.5, anchor=CENTER) def stop_display_tensor(self): self.tensor_message.place_forget()