class ConvolutionalNN():
def __init__(self, embedding, batch_size):
TEXT, vocab_size, word_embeddings, self.train_iter, self.valid_iter, self.test_iter = load_dataset.load(
embedding=embedding, batch_size=batch_size)
self.embedding = embedding
output_size = 10
in_channel = 1
out_channel = 16
kernel_heights = [3, 5, 7]
keep_probab = 0
stride = 1
padding = [1, 2, 3]
embedding_length = 300
self.model = CNN(batch_size, output_size, in_channel, out_channel,
kernel_heights, stride, padding, keep_probab,
vocab_size, embedding_length, word_embeddings)
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad,
self.model.parameters()),
weight_decay=0.0005,
lr=0.0001)
loss_fn = F.cross_entropy
self.training_handler = TrainingHandler(optimizer, loss_fn, batch_size)
def train(self, numberOfEpochs):
patience_threshold = 3
patience = patience_threshold
min_valid_loss = np.Inf
for epoch in range(numberOfEpochs):
if torch.cuda.is_available():
torch.cuda.empty_cache()
train_loss, train_acc = self.training_handler.train_model(
self.model, self.train_iter, epoch)
val_loss, val_acc = self.training_handler.eval_model(
self.model, self.valid_iter)
print(
f'Epoch: {epoch+1:02}, Train Loss: {train_loss:.3f}, Train Acc: {train_acc:.2f}%, Val. Loss: {val_loss:3f}, Val. Acc: {val_acc:.2f}%'
)
output_handler.outputFileHandler.write(
f'Epoch: {epoch+1:02}, Train Loss: {train_loss:.3f}, Train Acc: {train_acc:.2f}%, Val. Loss: {val_loss:3f}, Val. Acc: {val_acc:.2f}%'
)
patience -= 1
if val_loss < min_valid_loss and abs(min_valid_loss -
val_loss) > 0.005:
patience = patience_threshold
torch.save(self.model, "./saved_models/cnn-" + self.embedding)
min_valid_loss = val_loss
if patience == 0:
break
def test(self):
self.model = torch.load("./saved_models/cnn-" + self.embedding)
test_loss, test_acc = self.training_handler.eval_model(
self.model, self.test_iter)
return test_loss, test_acc
def __init__(self, *args, **kwargs):
self.model = BasketballModel()
self.handler = TrainingHandler()
self.status = 0
self.last_connection_amount = 0
self.running_time = datetime.now()
self.memory = ReplayMemory(100000)
self.csv = CSVFile()
super(ModelServer, self).__init__(self.HOST, self.PORT)
class LongShortTermMemoryAttention():
def __init__(self, embedding, batch_size):
TEXT, vocab_size, word_embeddings, self.train_iter, self.valid_iter, self.test_iter = load_dataset.load(
embedding=embedding, batch_size=batch_size)
self.embedding = embedding
output_size = 10
hidden_size = 256
embedding_length = 300
self.model = AttentionModel(batch_size, output_size, hidden_size,
vocab_size, embedding_length,
word_embeddings)
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad,
self.model.parameters()),
weight_decay=0.0005,
lr=0.0001)
loss_fn = F.cross_entropy
self.training_handler = TrainingHandler(optimizer, loss_fn, batch_size)
def train(self, numberOfEpochs):
patience_threshold = 3
patience = patience_threshold
min_valid_loss = np.Inf
for epoch in range(numberOfEpochs):
if torch.cuda.is_available():
torch.cuda.empty_cache()
train_loss, train_acc = self.training_handler.train_model(
self.model, self.train_iter, epoch)
val_loss, val_acc = self.training_handler.eval_model(
self.model, self.valid_iter)
print(
f'Epoch: {epoch+1:02}, Train Loss: {train_loss:.3f}, Train Acc: {train_acc:.2f}%, Val. Loss: {val_loss:3f}, Val. Acc: {val_acc:.2f}%'
)
output_handler.outputFileHandler.write(
f'Epoch: {epoch+1:02}, Train Loss: {train_loss:.3f}, Train Acc: {train_acc:.2f}%, Val. Loss: {val_loss:3f}, Val. Acc: {val_acc:.2f}%'
)
patience -= 1
if val_loss < min_valid_loss and abs(min_valid_loss -
val_loss) > 0.005:
patience = patience_threshold
torch.save(self.model,
"./saved_models/lstm-attn-" + self.embedding)
min_valid_loss = val_loss
if patience == 0:
break
def test(self):
self.model = torch.load("./saved_models/lstm-attn-" + self.embedding)
test_loss, test_acc = self.training_handler.eval_model(
self.model, self.test_iter)
return test_loss, test_acc
def __init__(self, embedding, batch_size):
TEXT, vocab_size, word_embeddings, self.train_iter, self.valid_iter, self.test_iter = load_dataset.load(embedding=embedding, batch_size=batch_size)
self.embedding = embedding
output_size = 10
learning_rate = 2e-5
self.model = LogisticRegressionModel(output_size, vocab_size, 300, word_embeddings)
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, self.model.parameters()), weight_decay=0.0005, lr=0.0001)
loss_fn = F.cross_entropy
self.training_handler = TrainingHandler(optimizer, loss_fn, batch_size)
def __init__(self, embedding, batch_size):
TEXT, vocab_size, word_embeddings, self.train_iter, self.valid_iter, self.test_iter = load_dataset.load(embedding=embedding, batch_size=batch_size)
self.embedding = embedding
output_size = 10
hidden_size = 256
embedding_length = 300
self.model = RCNN(batch_size, output_size, hidden_size, vocab_size, embedding_length, word_embeddings)
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad, self.model.parameters()), weight_decay=0.0005, lr=0.0001)
loss_fn = F.cross_entropy
self.training_handler = TrainingHandler(optimizer, loss_fn, batch_size)
def setUp(self):
MockProtocol.set_handler_class(handler_class=LogonHandler)
self.protocol = MockProtocol()
training_handler.player_database = PlayerDatabase()
self.player = Player(28)
self.player.name = "jerry"
training_handler.player_database.add_player(self.player)
self.protocol.remove_handler()
self.player.protocol = self.protocol
self.protocol.add_handler(TrainingHandler(self.protocol, self.player))
self.handler = self.protocol.handler
self.assertEqual(len(list(training_handler.player_database.all())), 1)
self.protocol.send_data = []
self.maxDiff = None
def __init__(self, embedding, batch_size):
TEXT, vocab_size, word_embeddings, self.train_iter, self.valid_iter, self.test_iter = load_dataset.load(
embedding=embedding, batch_size=batch_size)
self.embedding = embedding
output_size = 10
in_channel = 1
out_channel = 16
kernel_heights = [3, 5, 7]
keep_probab = 0
stride = 1
padding = [1, 2, 3]
embedding_length = 300
self.model = CNN(batch_size, output_size, in_channel, out_channel,
kernel_heights, stride, padding, keep_probab,
vocab_size, embedding_length, word_embeddings)
optimizer = torch.optim.Adam(filter(lambda p: p.requires_grad,
self.model.parameters()),
weight_decay=0.0005,
lr=0.0001)
loss_fn = F.cross_entropy
self.training_handler = TrainingHandler(optimizer, loss_fn, batch_size)
class ModelServer(SocketServer):
HOST = 'localhost'
PORT = 5600
def __init__(self, *args, **kwargs):
self.model = BasketballModel()
self.handler = TrainingHandler()
self.status = 0
self.last_connection_amount = 0
self.running_time = datetime.now()
self.memory = ReplayMemory(100000)
self.csv = CSVFile()
super(ModelServer, self).__init__(self.HOST, self.PORT)
def on_message_received(self, sock: socket, data, received_data: str,
addr: Tuple[str, int]) -> None:
request = json.loads(received_data)
print('Received {} from {}'.format(request, addr))
if is_correct_message(request):
host, prt = addr
conn = self.handler.get_connection(prt)
if is_result(request):
res_throw = float(request['throw'])
res_force = float(request['force'])
res_distance = float(request['distance'])
self.csv.add_observation(res_throw, res_force, res_distance,
(datetime.now() -
self.running_time).total_seconds())
self.memory.push(res_throw, res_force, res_distance)
conn.result = res_distance
elif is_request(request):
conn.distance = float(request['distance'])
def on_step(self):
# If all the results from the throws are in,
if self.handler.all_results_are_in():
# Then let us learn from all the results
self.model.learn(self.handler.predictions,
self.handler.get_all_results())
# Clear the results so that we can receive fresh results
self.handler.clear_results()
del self.handler.predictions
self.status = 0
# If all the distances are in
if self.handler.all_distances_are_in():
# Then we can predict the force and height
throws = self.model.throw(self.handler.get_all_distances())
# PyTorch tries to be clever, but we need it in the right dimensions
if len(throws.shape) <= 1:
throws = throws.unsqueeze(0)
# Add the predictions to the training handler for later
self.handler.predictions = throws
# And send them to all the connected clients
for conn, throw in zip(self.handler.get_connections(), throws):
# In order to send the tensor data over the network,
# we must first convert the tensor to simple python
# data types and then we can access them as normal.
t = throw[0].tolist()
# t = random.uniform(0.2, 1)
self.send_prediction_to_connection(conn, t, t)
# Clear distances afterwards
self.handler.clear_distances()
self.status = 1
def on_connection_closed(self, addr: Tuple[str, int]):
host, port = addr
self.handler.remove_connection(port)
def on_accept_connection(self, sock: socket, addr: Tuple[str, int],
data: SimpleNamespace):
host, port = addr
self.handler.add_connection(Connection(sock, host, port, data))
def send_prediction_to_connection(self, conn: Connection, force: float,
height: float) -> None:
prediction = {'Type': 'prediction', 'Force': force, 'Height': height}
self.send_message(conn.data, prediction)
def ask_for_distances(self, conn: Connection) -> None:
request = {'Type': 'request'}
self.send_message(conn.data, request)
batch_size = 100
train_batches = 20000
charset = "data/charset.txt"
train_corpus = "data/train.txt"
tag_name = "2_256"
seq_length = 128
save_on_every = 100
epoches = 50
cwd = os.getcwd()
charset = os.path.join(cwd, charset)
train_corpus = os.path.join(cwd, train_corpus)
d = DataGen2(charset, batch_size, seq_length)
gen = d.generate_v1(train_corpus, batches=train_batches)
input_shape = (seq_length, len(d.char2int) + 1)
output_shape = len(d.char2int) + 1
model = get_model(input_shape, output_shape, lstm_cell=True)
model_name = "single_input_single_task"
trainer = TrainingHandler(model, model_name)
trainer.train(tag_name, gen, epoches,
train_batches, save_on_every,
save_model=True)
def goto_train(self):
self.player.active = False
self.protocol.add_handler(TrainingHandler(self.protocol, self.player))
self.logout_message("%s leaves to edit stats" % self.player.name)