Skip to main content

Matthew - Blog Post 7

Since January, we've been working hard to not only finish writing the Replay Parser and Frame Collector but also totally synchronize them. I'm pleased to report our success. This is an amazing milestone for us because it means that we've surmounted one of our most troubling obstacles.

I have also made sure to keep our documentation up to date. So, if you like, you can follow along with this blog post by replicating its results.

The Frame Collector uses timed input sequences to start each replay associated with the currently running game version. Then, after waiting a set amount of time for playback to begin, it starts grabbing 1/4-scale frames at a rate of 10 frames per second. The Frame Collector takes these down-scaled frames, which are NumPy arrays, and rapidly pickles and dumps them into the file system. Here's a screenshot of the Frame Collector in action:

If you look at the image above, you'll see that each pickle (the .np files) is simply assigned a number as its file name. This number corresponds with an estimate on how many frames passed since playback started, so "" is the 1st frame and "" is the 349th frame. The frame index values are only estimates because we do not have access to the game's internal state. However, frame 0 appears to be more or less consistently synchronized with the moment when "GO!" is fading out, which is close enough for our purposes. Recall that we are not trying to classify which character animation is associated with each movement type; rather, we are trying to predict the best movement type for any given situation.

We chose 1/4 scale because full scale results in about 1 GB per minute of playback, which is not only taxing on our collective storage capabilities, but is also excessive for machine learning. After all, each individual pixel will need to be represented by its own input node in our neural network. Otherwise, we are running the Frame Collector at about 10 FPS because, after some experimentation, we found that it provides a good balance in terms of the number of frame buffer captures generated per minute and the number of missing frames between each capture.

Our next step will be to run the Frame Collector for additional replays in order to confirm that the frames index values for all of the pickles continue to synchronize with the replay files. This can only be achieved via manual review of random samples. Hopefully we do not encounter too many discrepancies. The biggest risk I am aware of is the possibility that different replay files may take slightly different amounts of time to load in the game. I think that this is unlikely to have a significant effect, though, because replay files are never especially large.

Once we've finished those tests, we will need to collect a larger portion of the dataset. Unfortunately the collection phase can only happen in real time because the Frame Collector has to watch each replay file from start to finish. The upside of this is that the Frame Collector can run independently, fetching and watching replay files one after the other until there are none left for the installed version of the game. After we have collected all of our dataset, we will then need to finish writing the Replay Loader, implement our neural network with Keras, and begin training.


Popular posts from this blog

Matthew - Capstone Blog Post 1

First I would like to discuss our goals and long-term plans. We want to create an artificial intelligence that learns how to play first-person shooters without access to any game state data other than what can be gained through the audio and visual buffers. In other words, the AI will only have access to the information that a human player would. If we are successful with these constraints, then I could see our work leading to AI that can play any game, or even AI-driven robots that can play games using mechanical hands and eyes to operate normal peripherals and interfaces.

We are currently in the research and planning phase of the project. This means that our job right now is to decide exactly what tools and technologies we will use and how they will interact with one another. By the end of the semester, which will arrive sometime this December, we will need to be ready for phase two, which is the development, training, and testing phase. Yes, that is all three at once. However, if …

Rei - Capstone Blog Post 1

Over the past couple of weeks, Matthew and I have been trying to narrow down our idea for capstone. We have settled on a "Modular" AI that can play First Person Shooters or other similar video games. However, we decided to put a slight twist on the idea of an AI playing games. Most of the AIs that are currently out have more information than they should possibly have at that time, like the location of players. We decided that our AI would only have information that would be accessible to a human player. We also noticed that many of the "PlayerAIs" out there are reactionary, not planning. While reacting is a key part to many of these games, so is strategy. We want to create an AI that thinks, at least a little bit, about that actions it is making or should make.

Since narrowing down our topic we have split off and started looking at different existing technologies and research that could help us understand and create this project. I decided to look at some computer…

Matthew - Capstone Blog Post 4

Finally, our CSI-480 (Advanced Topics: AI) course material is catching up to where we need to be. We are covering perceptrons and sigmoid neurons in the lectures, and we are also using TensorFlow to solve some very simple introductory problems (via tutorials). To supplement this I have been reading Neural Networks and Deep Learning by Michael Nielsen, a textbook available for free on the internet, which dives into neural networks right from the first chapter. Additionally, I have been finding 3Blue1Brown's multi-part video series about deep learning to be extremely helpful for visualizing some of the more advanced concepts. Even if I do not fully understand the calculus and linear algebra involved, at the very least I have a better idea of what goes on inside of neural networks. For example: I know what loss and gradient descentalgorithmsdo, essentially, and I also understand how the latter helps find a local minimum for the former, but I do not necessarily feel confident in my …