In this blog post I am going to explain one of possible way how to implement Deep Learning ML to play video game. For this purpose I used the following:
- N64 Nintendo emulator which can be found here,
- Mario Kart 64 ROM, which can be found on internet as well,
- CNTK – Microsoft Cognitive Toolkit
- .NET Framework and C#
The idea behind this machine learning project is to capture images together with action, while you play Mario Kart game. Then captured images are transformed into features of training data set, and action keys into label hot vectors respectively. Since we need to capture images, the emulator should be positioned at fixed location and size during playing the game, as well as during testing algorithm to play game. The flowing image shows N64 emulator graphics configuration settings.
Also the N64 emulator is positioned to Top-Left corned of screen, so it is easier to capture the images.
Data collection for training data set
During image captures game is played as you would play normally. Also no special agent, not platform is required.
In .NET and C# it is implemented image capture from the specific position of screen, as well as it is recorded which keys are pressed during game play. In order to record keys press, the code found here is modified and used.
The flowing image shows the position of N64 emulator with playing Mario Kart game (1), the windows which is capture and transform the image (2), and the application which collect images, and key press action and generated training data set into file(3).
The data is generated on the following way:
- each image is captured, resized to 100×74 pixels and gray scaled prior to be transformed and persisted to data set training file.
- before image is persisted the hotkey of action key press is recorded and connected to image.
So the training data is persisted into CNTK format which consist of:
- |label – which represent 5 component hot vector, indicate: Forward, Break, Forward-Left, Forward-Right and None (1 0 0 0 0)
- |features consist of 100×74 numbers which represent pixels of the images.
The following data sample shows how training data set are persisted in the txt file:
|label 1 0 0 0 0 |features 202 202 202 202 202 202 204 189 234 209 199... |label 0 1 0 0 0 |features 201 201 201 201 201 201 201 201 203 18... |label 0 0 1 0 0 |features 199 199 199 199 199 199 199 199 199 19... |label 0 0 0 1 1 |features 199 199 199 199 199 199 199 199 199 19...
Since my training data is more than 300 000 MB of size, I provided just few BM sized file, but you can generate file as big as you wish with just playing the game, and running the flowing code from Program.cs file:
Training Model to play the game
Once we generate the data, we can move to the next step: training RCNN model to play the game. For training model the CNTK is used. Also since we play a game and previous sequence will determined the next sequence in the game, LSTM RNN is used. More information about CNTK and LSTM can be found in previous posts. In my case I have collected nearly 15000 images during several round of playing the same level and route. Also for more accurate model much more images should be collected, nearly 100 000. The model is trained in one hour, with 500000 iterations. The source code about whole project can be found on GitHub page. (http://github.com/bhrnjica/LSTMBotGame )
By running the following code, the training process is started with provided training data:
Playing the game with CNTK model
Once we trained the model, we move to the next step: playing a game. The emulator should be positioned on the same position and with the same size in order to play the game.ONce the model is trained and created in th training folder, the playing game can be achive by running:
var dev = DeviceDescriptor.CPUDevice;
How it looks like on my case, you can see on this youtube video:
In the next few steps will show how to install CNTK and python environment in Visual Studio 2017.
- First download the latest CNTK version from the official GitHub page, or just click on the following link: https://github.com/Microsoft/CNTK/releases
The release page will show the latest bits. Click on the CPU only package, accept the license and download the zip file.
- Once that you have zip file on your PC, create the folder C:/local on disk and unzip the package in to it.
- The next step performs the installation of the library as well as installation of the Python related distribution anaconda 4.1.1.
- Open C:\local\cntk\Scripts\install\windows path and run install.bat file. You will need administrative rights in order to successfully install all required components.
- The following image shows the installation process:
- As can be seen first you have to run batch file (step 2), then press 1 and ENTER in order to continue with the installation process and press ‘y‘, to perform downloading required components.
- The installation process takes several minutes to complete. The first component to be installed is Anaconda 4.1.1 which is needed in order to setup CNTK.
- Once the anaconda is installed, the process of CNTK installation starts and passes very quickly since we already download all CNTK bits.
- Now that we have CNTK installed, the last installation step is installation of the Visual Studio Tool for Python.
- Run the Visual Studio 2017 Installer and after the installed is show, just select the python components similar picture shows below:
- Once the installation is completed run Visual Studio 2017.
- From the Visual Studio 2017 Tool menu select Python and then select Python Environment:
- From the Python Environment window select Anaconda 4.1.1 and update symbols DB, by pressing the button pointed on the image below:
- Once we have environment updated, Press “Make this the default environment for the new projects” option in order to apply the environment for the future Python CNTK based projects.
- Also the path for Python and Python scripts should be registered in Global Environment OS.
- Once the previous steps are performed successfully, we can start writing CNTK aware python code in Visual Studio 2017.
- OPen VS 2017 and Anaconda 4.1.1 environment and type.
print(“CNTK verion:”, cntk__version__)
- Similar output should be appear
- print(“CNTK version:”, cntk.__version__)
After almost two years of implementation, I am proud to announce the forth version of the Open source project called GPdotNET v4.0. The latest version completely implements Genetic Programming and Artificial Neural Network for supervised learning tasks in three kind of problems: regression, binary and multiclass classification. Beside supervised learning tasks, with GPdotNET you can solve several Linear Programming problems: Traveling Salesman, Assignment and Transportation problems. The source code and binaries can be download from Github page: https://github.com/bhrnjica/gpdotnet/releases/tag/v4.0
Figure 1. Main Window in GPdotNET v4.0
In 2006 the GPdotNET started as post-graduate semester project, where I was trying to implement simple C# program based on genetic programming. After successfully implemented console application, started to implement .NET Windows application to be easy to use for anyone who wants to build mathematical model from the data based on genetic programming method. In November 2009 GPdotNET became an open source project, by providing the source code and installer. Since then I have received hundreds of emails, feedbacks, questions and comments. The project was hosted on http://gpdotnet.codeplex.com. In 2016 I decided to move the project to GitHub for better collaboration and compatibility, and can be found at http://github.com/bhrnjica/gpdotnet. However, for backward compatibility, the old hosting site will be live as long as the codeplex.com would be live. Since the beginning of the development, my intention was that the GPdotNET would be cross-OS application which can be run on Windows, Linux and Mac. Since version 2, GPdotNET can be compiled against .NET and Mono, and can be run on any OS which has Mono Framework installed. Beside this fact, vast majority of users are using GPdotNET on Windows OS.
GPdotNET is primarily used on Academia by helping engineers and researchers in modelling and prediction various problems, from the air pollution, water treatment, rainfall prediction, to the various modelling of machining processes, electrical engineering, vibration, automotive industry etc. GPdotNET is used in more than ten doctoral dissertations (known to me) and master thesis, nearly hundreds paper used GPdotNET in some kind of calculation.
Modeling with GPdotNET (New in GPdotNET v4.0)
Working with GPdotNET requires the data. By providing the learning algorithms GPdotNET uses a data of the research or experimental measures to learn about the problem. The results of learning algorithms are analytical models which can describe or predict the state of the problem, or can recognize the pattern. GPdotNET is very easy to use, even if you have no deep knowledge of GA, GP or ANN. Appling those methods in finding solutions can be achieved very quickly. The project can be used in modeling any kind of engineering process, which can be described with discrete data, as well as in education during teaching students about evolutionary methods, mainly GP and GA, as well as Artificial Neural Networks.
Working in GPdotNET follows the same procedures regardless of the problem type. That means you have the same set of steps when modelling with Genetic Programming or Neural Networks. In fact, GPdotNET contains the same set of input dialogs when you try to solve Traveling Salesman Problem with Genetic Algorithm or if you try to solve handwriting recognition by using Backpropagation Neural Networks. All learning algorithms within GPdotNET share the same UI.
The picture below shows the flowchart of the modelling in GPdotNET. The five steps are depicted in the graphical forms surrounded with Start and Stop item.
Figure 2. Modelling layout in GPdotNET 4.0
After GPdotNET is started main window is show, and the modelling process can be started.
Choosing the Solver Type
The first step is choosing the type of the solver. Which solver you will use it depends on your intention what you want to do. Choosing solver type begins when you press “New” button, the “GPdotNET Model creation wizard” appear. Soler types are grouped in two categories. The first group (on the left side) contains models implemented prior to v4.0 version. It contains solvers which apply GP in modelling regression problems, and GP in optimization of the GP models. In addition, you can perform optimization of any analytically defined function by using “Optimization of the Analytic function”. Also, there are three linear programming problems which GPdotNET can solve using GA.
On the right side, there are two kind of solvers: GP or ANN, which are not limited to solve only regression. Both GP or ANN can build model for regression, binary or multi-class problems. Which type of problem GPdotNET will use, depends of the type of the output column data (label column).
Figure 3. Available model types
Loading Experimental Data (new in GPdotNET 4.0)
GPdotNET uses powerful tool for importing your experimental data regardless of the type. You can import numerical, binary or classification data by using Importing Data Wizard. With GPdotNET importing tools you can import any kind of textual data, with any kind of separation character.
Figure 4. Importing dataset dialog
After the data is imported in forms of columns and rows, GPdotNET implemented set of very simple controls which can perform very powerful feature engineering. For each loaded column, you can set several types of metadata: column name, column type (input, output, ignore), normalization type (minmax, gauss), and missing value (min, max, avg). With those options, you can achieve most of the modelling scenarios. Before “Start Modelling” minimum conditions must be achieved.
- At least one column must be of “input” parameter type.
- At least one column must be of “output” parameter type.
Which type of problem (regression, binary or multi class) will be used depends of the type of the output column. The following cases are considered:
- in case of regression problems ouput column must be of numeric type.
- in case of binary classinfication output column must be of binary type.
- in case of multi class classinfication output column must be of categorical type.
Figure 5. Defining metadata for training data set
When the column should not be part of the feature list, it can be easily ignored when the Column Type is set to “ignore“, or Param type is set to “string“.
Figure 6. Changing column type to binary
Change value of metadata by double click on the current value, select new values from available popup list. When you done with Feature Engineering press “Start Modelling” button and the process of modelling can be start.
Note: After you press Start Modelling button you can still change values of metadta, but after every change of the metadata values, Start Modelling button must be pressed.
Setting Learning Parameters
Figure 7. Setting parameters Dialog
After data is loaded and prepared successfully, you have to set parameters for the selected method. GPdotNET provides various parameters for each method, so you can set parameters which can provides and generates best output model. Every parameter is self-explanatory.
Searching for the solution
GPdotNET provides visualization of the searching solution so you can visually monitor how GPdotNET finds better solution as the iteration number is increasing. Beside searching simulation, GPdotNET provides instant result representation (only GP models), so any time the user can see what is the best solution, and how currently best solution is good against validate or predicted set of data. (Result and Prediction tabs).
Figure 8. Searching simulation in GPdotNET
Saving and exporting the results:
GPdotNET provides several options you can choose while exporting your solution. You can export your solution in Excel or text file, as well as in Wolfram Mathematica or R programming languages (GP Models only). In case of ANN model the result can se exported only to Excel.
Figure 9. Searching simulation in GPdotNET
Besides parameters specific to learning algorithm, GPdotNET provides set of parameters which control the way of how iteration process should terminates as well as how iteration process should be processed by means of parallelization to use the multicore processors. During the problem searching GPdotNET records the history, so you can see when the best solution is found, how much time pass since the last iteration process start, or how much time is remaining to finish currently running iteration process.
Due to the fact that GP is the method which requires lot of processing time, GPdotNET provides parallelization, which speed up the process of searching. Enabling or disabling the parallelization processing is just a click of the button.
GPdotNET Start Page
In case you have no data or just want to test the application, GPdotNET providers 15 data samples for demo purposes. All samples are grouped in problems specific groups: Approximation and Regressions, Binary Classification, Multi-class classification, Time series modelling and Linear Programming.
Figure 10. Modelling layout in GPdotNET
By click on appropriate link sample can be opened to see current result and parameter values. You can easily change parameter, press Run button and search for another solution. This is very handy to introduce with GPdotNET. In any time, you can stop searching and export current model or save current state of the program.
Final note: The project is licensed under GNU Library General Public License (LGPL). For information about license and other kind of copyright e.g. using the application in commercial purpose please see http://github.com/bhrnjica/gpdotnet/blob/master/license.md.
In case you need to cite it in scientific paper or book please refer to https://wordpress.com/post/bhrnjica.net/5995
Download GPdotNET v4 beta2
The last few days I am preparing the new build for publishing of GPdotNET v4.0 which will include lot of new features. In the last post I have announced ANN modul and compleately new modul for preparing tha data for modelling. Here is a quick overview of the new features comming in this build:
- Since this build the GP modul is also integrated with the new way of data preparation. Now with the latest version of GPdotNET the user will have the same user experience in modelling with GP and ANN.
- The big news for this build is ability for modelling classification problems (two-class as well ) with Genetic programming. Multy -classs GP solver will be released soon.
- Separation of the previous and new version. Both are included in the latest build.
- Disable protected operations.
As picture shows below you can choose models from prevous version on the left side. On the right side of the new model dialog, you can select modeling and prediction with ANN or GP.
After you select the solver GPdotNET is ready to accept the data.
From the previous blog post you can see more info about loading and handling data. The same user experimence you can see regadles of the solver type (ANN or GP).
Beside this GP integration there are several bug fix which were reported from the users.
In GP solver the new feature has been added: Ability to disable protected operations. In the previuous version of GPdotNET protected operations (eg. /, log, ln, etc) are enabled in the model. Whenever operation was undefined for the current value. GPdotNET returned default value (0 or 1). So with protected operation the model is always defined. With protected operations we collect much good genetic material dufirng evolution. In case the option is disable any upprotected operation can discar the model. This option is available in new and previous GP solver.
Features not implemented in this beta
1. Exporting GP/ANN model
2. Open/Save gpa file for new Solvers.