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()
