├── .gitignore ├── ElasticNet.pkl ├── README.md ├── __init__.py ├── game_objects ├── AIPlayers.py ├── TrainingPlayer.py ├── __init__.py ├── ball.py ├── block.py └── player.py ├── pong2players.py ├── pong_data ├── models_parameters │ ├── x_mean.pkl │ └── y_mean.pkl └── training_data │ └── .gitignore ├── requirements.txt ├── self_pong.py └── training ├── __init__.py ├── conv_model_keras.py ├── elasticnet.py └── utils ├── __init__.py └── sequential_data.py /.gitignore: -------------------------------------------------------------------------------- 1 | *.DS_Store 2 | *.ipynb_checkpoints/ 3 | *.idea/ 4 | *.pyc 5 | *.ipynb 6 | *.pkl 7 | *.csv 8 | *.h5 9 | -------------------------------------------------------------------------------- /ElasticNet.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DiegoAgher/learnPongPython/fd635c8fdc1a2bcce7df3a376d64d0edd0df7e2f/ElasticNet.pkl -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # learnPongPython 2 | This project that aims to build a model that learns how to play pong using python2.7 3 | 4 | # Requirements 5 | Create a virtualenv that uses python2.7 along with `pip` 6 | 7 | run `pip install -r requirements.txt` 8 | 9 | # How to train my model and play against him? 10 | After installing the proper requirements. 11 | 1. Gather data: run `python pong2players.py` use the up/down keys for player 12 | on the right, and w/s for player on the left. To save the data one will have to 13 | loose after 4 points. 14 | 15 | 2. Train your model: train an elasticnet or 2Dconvolutional Network by running 16 | `python -m training.elasticnet` or `python -m training.conv_model_keras.py`. This 17 | could take quite a while. Keep in mind you'll need considerable data so play 18 | three games at least. 19 | 20 | 3. Deploy the model an play against it: run `python self_pong.py` and play 21 | against the player on the left. Have fun! (Disclaimer: depending on the human 22 | player's performance, on the left, that's how good the AI will be. 23 | 24 | -------------------------------------------------------------------------------- /__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DiegoAgher/learnPongPython/fd635c8fdc1a2bcce7df3a376d64d0edd0df7e2f/__init__.py -------------------------------------------------------------------------------- /game_objects/AIPlayers.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | import numpy as np 3 | from pygame.locals import * 4 | from sklearn.externals import joblib 5 | from keras.models import load_model 6 | from game_objects.player import Player 7 | 8 | MODELS_PARAMETERS_DIR = 'pong_data/models_parameters/' 9 | x_mean_dir = MODELS_PARAMETERS_DIR + 'x_mean.pkl' 10 | y_mean_dir = MODELS_PARAMETERS_DIR + 'y_mean.pkl' 11 | 12 | 13 | class ElasticNetPlayer(Player): 14 | def __init__(self, name, screen, screen_height, screen_width): 15 | Player.__init__(self, name, screen, screen_height, screen_width) 16 | try: 17 | self.predictive_model = joblib.load('ElasticNetSeq.pkl') 18 | self.y_mean = joblib.load(y_mean_dir) 19 | self.x_mean = joblib.load(x_mean_dir) 20 | except Exception as e: 21 | print Exception 22 | print "Models or parameters above not found, train the model first" 23 | print """To train the model use pong2players.py script to gather 24 | data and then train the model with one of the training 25 | scripts, eg: training/elasticnet.py""" 26 | 27 | def scoring(self): 28 | scoreBlit = self.scoreFont.render(str(self.score), 29 | 1, (255, 255, 255)) 30 | if self.name == "player1": 31 | self.screen.blit(scoreBlit, (32, 16)) 32 | if self.score == 5: 33 | print ("player 1 wins!") 34 | exit() 35 | elif self.name == "player2": 36 | self.screen.blit(scoreBlit, (self.SCR_HEI + 92, 16)) 37 | if self.score == 5: 38 | print ("Player 2 wins!") 39 | exit() 40 | 41 | def movement(self, screen_np): 42 | if screen_np is not None: 43 | model = self.predictive_model 44 | prediction = model.predict(screen_np) 45 | self.y = prediction + self.y_mean 46 | 47 | 48 | class Conv2DPlayer(Player): 49 | def __init__(self, name, screen, screen_height, screen_width): 50 | Player.__init__(self, name, screen, screen_height, screen_width) 51 | try: 52 | self.predictive_model = load_model('pong_conv2d.h5') 53 | self.y_mean = joblib.load(y_mean_dir) 54 | self.x_mean = joblib.load(x_mean_dir) 55 | except Exception as e: 56 | print Exception 57 | print "Models or parameters above not found, train the model first" 58 | print """To train the model use pong2players.py script to gather 59 | data and then train the model with one of the training 60 | scripts, eg: training/elasticnet.py""" 61 | 62 | def movement(self, screen_np): 63 | if screen_np is not None: 64 | frame_length = screen_np.shape[1] 65 | centered_data = np.reshape(screen_np, (1, frame_length / (400 * 3), 66 | 400, 3)) 67 | model = self.predictive_model 68 | prediction = model.predict(centered_data) 69 | self.y = prediction + self.y_mean 70 | -------------------------------------------------------------------------------- /game_objects/TrainingPlayer.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import h5py 3 | import pygame 4 | from pygame.locals import * 5 | from datetime import datetime 6 | from game_objects.player import Player 7 | 8 | 9 | class TrainPlayer(Player): 10 | def __init__(self, name, screen, screen_height, screen_width): 11 | Player.__init__(self, name, screen, screen_height, screen_width) 12 | 13 | def scoring(self, screen_data): 14 | scoreBlit = self.scoreFont.render(str(self.score), 15 | 1, (255, 255, 255)) 16 | if self.name == "player1": 17 | self.screen.blit(scoreBlit, (32, 16)) 18 | if self.score == 5: 19 | print ("player 1 wins!") 20 | training_id = datetime.today().strftime("%Y-%m-%d-%H-%M-%S") 21 | training_id = training_id.strip().replace(" ", "") 22 | data_file = (h5py.File("pong_data/training_data/{}.h5". 23 | format(training_id))) 24 | dataset = (data_file. 25 | create_dataset( 26 | 'train_{}'.format(training_id), 27 | (len(screen_data), screen_data[0].shape[0]), 28 | dtype='f')) 29 | for index, vector in enumerate(screen_data): 30 | dataset[index] = vector 31 | 32 | data_file.close() 33 | exit() 34 | elif self.name == "player2": 35 | self.screen.blit(scoreBlit, (self.SCR_HEI + 92, 16)) 36 | if self.score == 5: 37 | print ("Player 2 wins!") 38 | training_id = datetime.today().strftime("%Y-%m-%d-%H-%M-%S") 39 | training_id = training_id.strip().replace(" ", "") 40 | data_file = (h5py.File("pong_data/training_data/{}.h5". 41 | format(training_id))) 42 | dataset = (data_file. 43 | create_dataset( 44 | 'train_{}'.format(training_id), 45 | (len(screen_data), screen_data[0].shape[0]), 46 | dtype='f')) 47 | for index, vector in enumerate(screen_data): 48 | dataset[index] = vector 49 | 50 | data_file.close() 51 | exit() 52 | -------------------------------------------------------------------------------- /game_objects/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DiegoAgher/learnPongPython/fd635c8fdc1a2bcce7df3a376d64d0edd0df7e2f/game_objects/__init__.py -------------------------------------------------------------------------------- /game_objects/ball.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | from pygame.locals import * 3 | from numpy.random import randint 4 | 5 | 6 | class Ball(pygame.sprite.Sprite): 7 | image = pygame.Surface((8, 8)) 8 | image.fill((255, 255, 255)) 9 | 10 | def __init__(self, screen, screen_height, screen_width, player1, player2): 11 | pygame.sprite.Sprite.__init__(self) 12 | self.screen = screen 13 | self.SCR_WID = screen_width 14 | self.SCR_HEI = screen_height 15 | self.player1, self.player2 = player1, player2 16 | self.rect = self.image.get_rect() 17 | 18 | self.rect.x, self.rect.y = self.SCR_WID / 2, self.SCR_HEI / 2 19 | sign_x = randint(0, 2) 20 | sign_y = randint(0, 2) 21 | speed = randint(5, 7) 22 | self.speed_x = (-1 ** sign_x) * speed 23 | self.speed_y = (-1 ** sign_y) * speed 24 | self.size = 8 25 | 26 | def restart(self): 27 | self.__init__(self.screen, self.SCR_HEI, self.SCR_HEI, 28 | self.player1, self.player2) 29 | 30 | def movement(self): 31 | self.rect.x += self.speed_x 32 | self.rect.y += self.speed_y 33 | 34 | if self.rect.y <= 0: 35 | self.speed_y *= -1 36 | elif self.rect.y >= self.SCR_HEI - self.size: 37 | self.speed_y *= -1 38 | 39 | if self.rect.x <= 0: 40 | self.restart() 41 | self.player1.score += 1 42 | elif self.rect.x >= self.SCR_WID - self.size: 43 | self.restart() 44 | self.speed_x = 3 45 | self.player2.score += 1 46 | 47 | if (self.player1.x - self.player1.padWid <= self.rect.x 48 | <= self.player1.x + self.player1.padWid): 49 | 50 | if (self.player1.y - (self.player1.padHei / 2) + 22 <= self.rect.y 51 | <= self.player1.y + self.player1.padHei): 52 | self.speed_x *= -1 53 | 54 | if self.rect.x >= self.player2.x - self.player2.padWid: 55 | if (self.player2.y - (self.player2.padHei / 2) + 22 <= self.rect.y 56 | <= self.player2.y + self.player2.padHei): 57 | self.speed_x *= -1 58 | 59 | def draw(self): 60 | pygame.draw.rect(self.screen, (255, 255, 255), 61 | (self.rect.x, self.rect.y, self.size, self.size)) -------------------------------------------------------------------------------- /game_objects/block.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | from pygame.locals import * 3 | 4 | 5 | class Block(pygame.sprite.Sprite): 6 | image = pygame.Surface((20, 20)) 7 | 8 | def __init__(self): 9 | pygame.sprite.Sprite.__init__(self) 10 | self.rect = self.image.get_rect() 11 | self.rect.x = 300 12 | self.rect.y = 0 13 | -------------------------------------------------------------------------------- /game_objects/player.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | from pygame.locals import * 3 | 4 | 5 | class Player(pygame.sprite.Sprite): 6 | def __init__(self, name, screen, screen_height, screen_width): 7 | pygame.sprite.Sprite.__init__(self) 8 | self.SCR_HEI = screen_height 9 | self.SCR_WID = screen_width 10 | self.screen = screen 11 | if name == "player1": 12 | self.x, self.y = 16, self.SCR_HEI / 2 13 | elif name == "player2": 14 | self.x, self.y = self.SCR_WID - 16, self.SCR_HEI / 2 15 | self.name = name 16 | self.speed = 6 17 | self.padWid, self.padHei = 8, 64 18 | self.score = 0 19 | self.scoreFont = pygame.font.SysFont("Arial", 32) 20 | 21 | def scoring(self): 22 | scoreBlit = self.scoreFont.render(str(self.score), 23 | 1, (255, 255, 255)) 24 | if self.name == "player1": 25 | self.screen.blit(scoreBlit, (32, 16)) 26 | if self.score == 2: 27 | print ("player 1 wins!") 28 | exit() 29 | elif self.name == "player2": 30 | self.screen.blit(scoreBlit, (self.SCR_HEI + 92, 16)) 31 | if self.score == 2: 32 | print ("Player 2 wins!") 33 | exit() 34 | 35 | def movement(self): 36 | 37 | keys = pygame.key.get_pressed() 38 | if self.name == "player1": 39 | if keys[pygame.K_w]: 40 | self.y -= self.speed 41 | elif keys[pygame.K_s]: 42 | self.y += self.speed 43 | elif self.name == "player2": 44 | if keys[pygame.K_UP]: 45 | self.y -= self.speed 46 | elif keys[pygame.K_DOWN]: 47 | self.y += self.speed 48 | 49 | if self.y <= 0: 50 | self.y = 0 51 | elif self.y >= self.SCR_HEI - 64: 52 | self.y = self.SCR_HEI - 64 53 | 54 | def draw(self): 55 | pygame.draw.rect(self.screen, (255, 255, 255), 56 | (self.x, self.y, self.padWid, self.padHei)) 57 | 58 | -------------------------------------------------------------------------------- /pong2players.py: -------------------------------------------------------------------------------- 1 | import pygame 2 | import numpy as np 3 | from pygame.locals import * 4 | from game_objects.TrainingPlayer import TrainPlayer 5 | from game_objects.ball import Ball 6 | from game_objects.block import Block 7 | 8 | SCR_WID, SCR_HEI = 400, 400 9 | screen = pygame.display.set_mode((SCR_WID, SCR_HEI)) 10 | pygame.display.set_caption("Pong") 11 | pygame.font.init() 12 | clock = pygame.time.Clock() 13 | FPS = 30 14 | pygame.init() 15 | 16 | 17 | BLACK = (0, 0, 0) 18 | WHITE = (255, 255, 255) 19 | RED = (255, 0, 0) 20 | GOLD = (201, 168, 168) 21 | Call = pygame.sprite.Group(()) 22 | got = pygame.sprite.Group(()) 23 | backg = pygame.Surface((SCR_WID, SCR_HEI)) 24 | 25 | 26 | def main(): 27 | backgscale = pygame.transform.scale(backg, (SCR_WID, SCR_HEI)) 28 | 29 | global player 30 | player = TrainPlayer("player1", screen, SCR_HEI, SCR_WID) 31 | 32 | global enemy 33 | enemy = TrainPlayer("player2", screen, SCR_HEI, SCR_WID) 34 | 35 | block = Block() 36 | got.add(block) 37 | 38 | ball = Ball(screen, SCR_HEI, SCR_WID, player, enemy) 39 | Call.add(ball) 40 | 41 | screen_data = [] 42 | i = 0 43 | SCREEN_REDUCE = 16 44 | while True: 45 | 46 | for event in pygame.event.get(): 47 | if event.type == pygame.QUIT: 48 | print("Game exited by user") 49 | exit() 50 | 51 | keys = pygame.key.get_pressed() 52 | # if keys[pygame.K_w]: 53 | # pressed = 'up' 54 | # elif keys[pygame.K_s]: 55 | # pressed = 'down' 56 | screen.blit(backg, (0, 0)) 57 | got.update() 58 | Call.update() 59 | backgscale = pygame.transform.scale(backg, (SCR_WID, SCR_HEI)) 60 | got.draw(screen) 61 | Call.draw(screen) 62 | #print "ball x, y: ", ball.rect.x, ball.rect.y 63 | player.draw() 64 | enemy.draw() 65 | if ball.rect.x <= 200: 66 | screen_np = (pygame.surfarray.array2d(screen) 67 | [SCREEN_REDUCE*2:SCR_WID - SCREEN_REDUCE, :]) 68 | screen_np = np.append(screen_np.flatten(), player.y) 69 | screen_data.append(screen_np) 70 | player.movement() 71 | enemy.movement() 72 | ball.movement() 73 | player.scoring(screen_data) 74 | enemy.scoring(screen_data) 75 | 76 | pygame.display.flip() 77 | clock.tick(FPS) 78 | i += 1 79 | 80 | if __name__ == "__main__": 81 | main() 82 | -------------------------------------------------------------------------------- /pong_data/models_parameters/x_mean.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DiegoAgher/learnPongPython/fd635c8fdc1a2bcce7df3a376d64d0edd0df7e2f/pong_data/models_parameters/x_mean.pkl -------------------------------------------------------------------------------- /pong_data/models_parameters/y_mean.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DiegoAgher/learnPongPython/fd635c8fdc1a2bcce7df3a376d64d0edd0df7e2f/pong_data/models_parameters/y_mean.pkl -------------------------------------------------------------------------------- /pong_data/training_data/.gitignore: -------------------------------------------------------------------------------- 1 | *.h5 2 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | numpy 2 | scikit-learn==0.19.1 3 | tensorflow==1.4.0 4 | pygame==1.9.3 5 | h5py 6 | scipy 7 | -------------------------------------------------------------------------------- /self_pong.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import numpy as np 3 | import pygame 4 | from pygame.locals import * 5 | from sklearn.externals import joblib 6 | from game_objects.player import Player 7 | from game_objects.AIPlayers import ElasticNetPlayer, Conv2DPlayer 8 | from game_objects.block import Block 9 | from game_objects.ball import Ball 10 | 11 | MODELS_PARAMETERS_DIR = 'pong_data/models_parameters/' 12 | x_mean_dir = MODELS_PARAMETERS_DIR + 'x_mean.pkl' 13 | x_mean = joblib.load(x_mean_dir) 14 | 15 | SCR_WID, SCR_HEI = 400, 400 16 | screen = pygame.display.set_mode((SCR_WID, SCR_HEI)) 17 | pygame.display.set_caption("Pong") 18 | pygame.font.init() 19 | clock = pygame.time.Clock() 20 | FPS = 30 21 | pygame.init() 22 | 23 | 24 | BLACK = (0, 0, 0) 25 | WHITE = (255, 255, 255) 26 | RED = (255, 0, 0) 27 | GOLD = (201, 168, 168) 28 | Call = pygame.sprite.Group(()) 29 | got = pygame.sprite.Group(()) 30 | backg = pygame.Surface((SCR_WID, SCR_HEI)) 31 | 32 | 33 | def main(): 34 | backgscale = pygame.transform.scale(backg, (SCR_WID, SCR_HEI)) 35 | try: 36 | ai_player = sys.argv[1] 37 | except: 38 | ai_player = 'linear' 39 | 40 | SCREEN_REDUCE = 16 41 | 42 | global player 43 | if ai_player == 'conv': 44 | player = Conv2DPlayer("player1", screen, SCR_HEI, SCR_WID) 45 | elif ai_player == 'linear': 46 | player = ElasticNetPlayer("player1", screen, SCR_HEI, SCR_WID) 47 | 48 | global enemy 49 | enemy = Player("player2", screen, SCR_HEI, SCR_WID) 50 | 51 | block = Block() 52 | got.add(block) 53 | 54 | ball = Ball(screen, SCR_HEI, SCR_WID, player, enemy) 55 | Call.add(ball) 56 | 57 | prev_screen_1 = None 58 | prev_screen_2 = None 59 | i = 0 60 | while True: 61 | 62 | for event in pygame.event.get(): 63 | if event.type == pygame.QUIT: 64 | print("Game exited by user") 65 | exit() 66 | 67 | screen.blit(backg, (0, 0)) 68 | got.update() 69 | Call.update() 70 | backgscale = pygame.transform.scale(backg, (SCR_WID, SCR_HEI)) 71 | got.draw(screen) 72 | Call.draw(screen) 73 | screen_np = (pygame.surfarray.array2d(screen) 74 | [SCREEN_REDUCE * 2:SCR_WID - SCREEN_REDUCE, :]) 75 | screen_np = screen_np.flatten().reshape(1, -1) - x_mean 76 | prev_screen_2 = prev_screen_1 77 | prev_screen_1 = screen_np 78 | 79 | player.draw() 80 | enemy.draw() 81 | if i > 2: 82 | 83 | screen_sequence = np.concatenate([prev_screen_2, prev_screen_1, 84 | screen_np], axis=1) 85 | 86 | player.movement(screen_sequence) 87 | 88 | else: 89 | player.movement(None) 90 | enemy.movement() 91 | ball.movement() 92 | enemy.scoring() 93 | player.scoring() 94 | i += 1 95 | pygame.display.flip() 96 | clock.tick(FPS) 97 | 98 | if __name__ == "__main__": 99 | main() 100 | -------------------------------------------------------------------------------- /training/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DiegoAgher/learnPongPython/fd635c8fdc1a2bcce7df3a376d64d0edd0df7e2f/training/__init__.py -------------------------------------------------------------------------------- /training/conv_model_keras.py: -------------------------------------------------------------------------------- 1 | import os 2 | import numpy as np 3 | import h5py 4 | from sklearn.externals import joblib 5 | from sklearn.model_selection import train_test_split 6 | from keras.models import Model 7 | from keras.layers import Input, Convolution2D, MaxPooling2D, Dense, Dropout,\ 8 | Flatten 9 | from training.utils.sequential_data import build_sequential_data_from_frames 10 | 11 | MODELS_PARAMETERS_DIR = 'pong_data/models_parameters/' 12 | x_mean_dir = MODELS_PARAMETERS_DIR + 'x_mean.pkl' 13 | y_mean_dir = MODELS_PARAMETERS_DIR + 'y_mean.pkl' 14 | 15 | TRAINING_DATA_DIR = 'pong_data/training_data' 16 | training_sets = os.listdir(TRAINING_DATA_DIR) 17 | 18 | for i, file_id in enumerate(training_sets[-3:]): 19 | current_file = h5py.File(TRAINING_DATA_DIR + '/{}'.format(file_id), 'r') 20 | dataset_id = 'train_' + file_id.replace('.h5', '') 21 | if i == 0: 22 | current_data = current_file[dataset_id][:] 23 | else: 24 | training_data = current_data 25 | current_data = current_file[dataset_id][:] 26 | training_data = np.concatenate([training_data, current_data]) 27 | 28 | x = training_data[:, :-1] 29 | y = training_data[:, -1] 30 | 31 | frame_length = x.shape[1] 32 | 33 | x_mean = x.mean() 34 | y_mean = y.mean() 35 | joblib.dump(x_mean, x_mean_dir) 36 | joblib.dump(y_mean, y_mean_dir) 37 | 38 | 39 | sequential_data = build_sequential_data_from_frames(x - x_mean, y - y_mean, 3) 40 | x_sequential = sequential_data[:, :-1] 41 | y_sequential = sequential_data[:, -1] 42 | del x, y, training_data, current_data, sequential_data 43 | 44 | x_sequential = np.reshape(x_sequential, (x_sequential.shape[0], 45 | frame_length/400, 400, 3)) 46 | 47 | 48 | num_train, height, width, channels = x_sequential.shape 49 | 50 | X_train, X_test, y_train, y_test = train_test_split(x_sequential, y_sequential) 51 | del x_sequential, y_sequential 52 | 53 | batch_size = 32 54 | num_epochs = 2 55 | kernel_size = 3 56 | pool_size = 2 57 | conv_depth_1 = 32 58 | conv_depth_2 = 64 59 | drop_prob_1 = 0.25 60 | drop_prob_2 = 0.5 61 | hidden_size = 512 62 | output_size = 1 63 | 64 | input_placeholder = Input(shape=(height, width, channels)) 65 | conv_1 = Convolution2D(conv_depth_1, (kernel_size, kernel_size), 66 | padding='same', activation='relu')(input_placeholder) 67 | 68 | conv_2 = Convolution2D(conv_depth_1, (kernel_size, kernel_size), 69 | padding='same', activation='relu')(conv_1) 70 | 71 | pool_1 = MaxPooling2D(pool_size=(pool_size, pool_size))(conv_2) 72 | drop_1 = Dropout(drop_prob_1)(pool_1) 73 | 74 | conv_3 = Convolution2D(conv_depth_2, (kernel_size, kernel_size), 75 | padding='same', activation='relu')(drop_1) 76 | conv_4 = Convolution2D(conv_depth_2, (kernel_size, kernel_size), 77 | padding='same', activation='relu')(conv_3) 78 | pool_2 = MaxPooling2D(pool_size=(pool_size, pool_size))(conv_4) 79 | drop_2 = Dropout(drop_prob_1)(pool_2) 80 | 81 | flat = Flatten()(drop_2) 82 | hidden = Dense(hidden_size, activation='relu')(flat) 83 | 84 | output = Dense(output_size)(hidden) 85 | 86 | model = Model(inputs=input_placeholder, outputs=output) 87 | 88 | model.compile(loss='mean_squared_error', 89 | optimizer='adam', 90 | metrics=['mae']) 91 | 92 | model.fit(X_train, y_train, 93 | batch_size=batch_size, epochs=num_epochs, 94 | verbose=1, validation_split=0.1) 95 | 96 | model.evaluate(X_test, y_test, verbose=1) 97 | 98 | model.save('pong_conv2d.h5') 99 | -------------------------------------------------------------------------------- /training/elasticnet.py: -------------------------------------------------------------------------------- 1 | import os 2 | import numpy as np 3 | import h5py 4 | from sklearn.externals import joblib 5 | from sklearn.linear_model import ElasticNet, ElasticNetCV 6 | from sklearn.model_selection import train_test_split 7 | from training.utils.sequential_data import build_sequential_data_from_frames 8 | 9 | MODELS_PARAMETERS_DIR = 'pong_data/models_parameters/' 10 | x_mean_dir = MODELS_PARAMETERS_DIR + 'x_mean.pkl' 11 | y_mean_dir = MODELS_PARAMETERS_DIR + 'y_mean.pkl' 12 | 13 | TRAINING_DATA_DIR = 'pong_data/training_data' 14 | 15 | training_sets = os.listdir(TRAINING_DATA_DIR) 16 | 17 | for i, file_id in enumerate(training_sets[-3:]): 18 | if not file_id.endswith('h5'): 19 | continue 20 | current_file = h5py.File(TRAINING_DATA_DIR + '/{}'.format(file_id), 'r') 21 | dataset_id = 'train_' + file_id.replace('.h5', '') 22 | if i == 0: 23 | current_data = current_file[dataset_id][:] 24 | else: 25 | training_data = current_data 26 | current_data = current_file[dataset_id][:] 27 | training_data = np.concatenate([training_data, current_data]) 28 | 29 | 30 | training_data = training_data[1:, :] 31 | x = training_data[:, :-1] 32 | y = training_data[:, -1] 33 | 34 | frame_length = x.shape[1] 35 | x_mean = x.mean() 36 | y_mean = y.mean() 37 | 38 | joblib.dump(x_mean, x_mean_dir) 39 | joblib.dump(y_mean, y_mean_dir) 40 | 41 | sequential_data = build_sequential_data_from_frames(x - x_mean, 42 | y - y_mean, 3) 43 | 44 | x_sequential = sequential_data[:, :-1] 45 | y_sequential = sequential_data[:, -1] 46 | 47 | X_train, X_test, y_train, y_test =\ 48 | train_test_split(x_sequential, y_sequential, test_size=0.1, random_state=1) 49 | 50 | del x_sequential, y_sequential, x, y, training_data, current_data 51 | 52 | myElastic = ElasticNetCV(cv=2, l1_ratio=0.7, fit_intercept=False) 53 | myElastic.fit(X_train, y_train) 54 | print "Training score: ", myElastic.score(X_train, y_train) 55 | print "Test score: ", myElastic.score(X_test, y_test) 56 | 57 | joblib.dump(myElastic, 'ElasticNetSeq.pkl') 58 | 59 | -------------------------------------------------------------------------------- /training/utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DiegoAgher/learnPongPython/fd635c8fdc1a2bcce7df3a376d64d0edd0df7e2f/training/utils/__init__.py -------------------------------------------------------------------------------- /training/utils/sequential_data.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | 4 | def build_sequential_data_from_frames(x_data, y_data, window_size): 5 | num_rows = x_data.shape[0] 6 | frame_length = x_data.shape[1] 7 | 8 | sequential_data = np.zeros((num_rows, (frame_length * window_size) + 1)) 9 | 10 | for i, vector in enumerate(x_data): 11 | sequential_data[i, -1] = y_data[i] 12 | sequential_data[i, :-1] = (x_data[i: i + window_size]. 13 | reshape((1, frame_length * window_size))) 14 | 15 | if i == num_rows - window_size: 16 | break 17 | 18 | return sequential_data 19 | 20 | 21 | --------------------------------------------------------------------------------