def start(self):
for i in range(int(self.actual_tournament.round_number)):
Menu.set_round(self, i + 1)
ShowInfos.tournament_results(
sorted(self.actual_tournament.players,
key=attrgetter("score"),
reverse=True))
DataHandler.save(self.actual_tournament)
self.actual_tournament = None
def __init__(self):
DataHandler.__init__(self, TRAIN_TEST_SPLIT)
self.epochs = EPOCHS
self.embed_size = EMBEDDING_SIZE # how big is each word vector
self.embeddings = get_embeddings()
self.max_features = 25000 # how many unique words to use (i.e num rows in embedding vector)
self.maxlen = 100 # max number of words taken in a sentence
# get preprocessed train and test set
self.t_X_train, self.t_X_test, self.tokenizer = self.pre_process()
def view_tournament(self):
name, place, date = AskInfos.view_tournament()
if DataHandler.search_tournament(name, place, date):
self.actual_tournament = DataHandler.tournament_deserializer(
DataHandler.search_tournament(name, place, date))[0]
Menu.quit = False
while not Menu.quit:
response = ShowInfos.one_tournament(self.actual_tournament)
while not response.isnumeric():
print("Vous devez choisir une réponse entre 1 et 4")
response = ShowInfos.one_tournament(self.actual_tournament)
while not 1 <= int(response) <= 4:
print("Vous devez choisir une réponse entre 1 et 4")
response = ShowInfos.one_tournament(self.actual_tournament)
if response == "1":
ShowInfos.tournament_results(
self.actual_tournament.players)
elif response == "2":
ShowInfos.rounds(self.actual_tournament.rounds)
elif response == "3":
result = AskInfos.sorting_method()
while not result.isnumeric():
print("Vous devez choisir une réponse entre 1 et 2")
result = AskInfos.sorting_method()
while not 1 <= int(result) <= 2:
print("Vous devez choisir une réponse entre 1 et 2")
result = AskInfos.sorting_method()
if result == "1":
ShowInfos.player_list(
sorted(self.actual_tournament.players,
key=attrgetter("last_name", "first_name")))
elif result == "2":
ShowInfos.player_list(
sorted(self.actual_tournament.players,
key=attrgetter("rating"),
reverse=True))
elif response == "4":
Menu.quit = True
self.actual_tournament = None
else:
print("Ce tournoi n'existe pas")
def create_player():
last_name = AskInfos.player_last_name()
while not last_name.replace(" ", "").isalpha():
print("Le nom de famille ne peut être composé que de lettres")
last_name = AskInfos.player_last_name()
first_name = AskInfos.player_first_name()
while not first_name.replace(" ", "").isalpha():
print("Le prénom ne peut être composé que de lettres")
first_name = AskInfos.player_first_name()
birthdate_ok = False
birthdate = AskInfos.player_birthdate()
while not birthdate_ok:
try:
strptime(birthdate, '%d/%m/%Y')
birthdate_ok = True
except ValueError:
print("La date doit être au format JJ/MM/AAAA")
birthdate = AskInfos.player_birthdate()
sex = AskInfos.player_sex().upper()
while sex != "H" and sex != "F":
print("Le sexe doit être au format H/F")
sex = AskInfos.player_sex()
rating = AskInfos.player_rating()
while not rating.isnumeric():
print("Le classement doit être un nombre")
rating = AskInfos.player_rating()
new_player = Player(last_name, first_name, birthdate, sex, rating)
if DataHandler.check_existance(new_player):
print("Ce joueur existe déja dans la base de donnée, il n'est donc"
" pas rajouté\n")
return new_player
else:
DataHandler.save(new_player)
print("Le joueur {} a bien été créé\n".format(
new_player.first_name))
return new_player
def display(self):
response = AskInfos.main()
while not response.isnumeric():
print("Vous devez choisir une réponse entre 1 et 7")
response = AskInfos.main()
while not 1 <= int(response) <= 7:
print("Vous devez choisir une réponse entre 1 et 7")
response = AskInfos.main()
if response == "1":
Menu.create_tournament(self)
elif response == "2":
Menu.create_player()
elif response == "3":
if AskInfos.sorting_method() == "1":
ShowInfos.player_list(
sorted(DataHandler.player_deserializer(
DataHandler.get_players()),
key=attrgetter("last_name", "first_name")))
else:
ShowInfos.player_list(
sorted(DataHandler.player_deserializer(
DataHandler.get_players()),
key=attrgetter("rating"),
reverse=True))
elif response == "4":
Menu.modify_rating()
elif response == "5":
ShowInfos.tournament_list(
DataHandler.tournament_deserializer(
DataHandler.get_tournaments()))
elif response == "6":
Menu.view_tournament(self)
elif response == "7":
Menu.play = False
import os
import argparse
import utils
from torchtext import data
from model.data_handler import DataHandler
parser = argparse.ArgumentParser()
parser.add_argument('--train_file',
default='./data/train.csv',
help='Training dataset in csv to build vocabulary upon')
parser.add_argument('--max_vocab_size',
default=20000,
help='Maximum vocabulary size to be built')
if __name__ == '__main__':
args = parser.parse_args()
print("Loading dataset ...")
data_handler = DataHandler(train_file=args.train_file)
print("- done.")
print("Building word vocabulary ...")
data_handler.build_vocab(field=data.Field(),
target_path='./model/TEXT.Field',
max_size=args.max_vocab_size)
print("- done.")
def modify_rating():
last_name, first_name, birthdate, new_rating = AskInfos.new_rating()
DataHandler.modify_rating(last_name, first_name, birthdate, new_rating)
def __init__(self):
DataHandler.__init__(self, TRAIN_TEST_SPLIT)
self.classifier = LogisticRegression()
self.embeddings = load_embeddings()
def __init__(self):
# intialize train test set
DataHandler.__init__(self, TRAIN_TEST_SPLIT)
self.y_train = self.restructure_labels(self.y_train)
self.y_test = self.restructure_labels(self.y_test)
# Set the random seed for reproducible experiments
torch.manual_seed(230)
if torch.cuda.is_available(): torch.cuda.manual_seed(230)
# Set the logger
utils.set_logger(os.path.join(args.experiment_dir, 'train.log'))
# Create the input data pipeline
logging.info("Loading the datasets...")
# Load data and get iterator
vocab_path = './model/TEXT.Field'
train_file_path = os.path.join(args.data_dir, 'train.csv')
val_file_path = os.path.join(args.data_dir, 'val.csv')
data_handler = DataHandler()
data_handler.load_vocab(vocab_path)
data_handler.load_dataset(train_file=train_file_path,
val_file=val_file_path)
train_iter, val_iter = data_handler.gen_iterator(
batch_size=params.batch_size)
train_size, val_size = data_handler.data_size
params.train_size = train_size
params.val_size = val_size
params.vocab_size = len(data_handler.vocab.itos)
logging.info('- done.')
# Define model
# set random seed for reproduciblity
torch.manual_seed(230)
if torch.cuda.is_available(): torch.cuda.manual_seed(230)
# set logger
utils.set_logger(os.path.join(args.experiment_dir, 'train.log'))
# create input data pipeline
logging.info("Loading the datasets ...")
# load data and get iterator
vocab_path = './model/TEXT.Field'
train_file = os.path.join(args.data_dir, 'train.csv')
valid_file = os.path.join(args.data_dir, 'val.csv')
handler = DataHandler()
handler.load_vocab(vocab_path)
handler.load_dataset(train_file=train_file, val_file=valid_file)
train_iter, _ = handler.gen_iterator(params.batch_size)
train_size, _ = handler.data_size
params.train_size = train_size
params.vocab_size = len(handler.vocab.itos)
params.bme_dim = params.vocab_size * 7 # 7 comes from nb=3 + ne=3 + 1
logging.info("- done.")
# define model
model = net.Encoder(params)
model.to(params.device)