Project – Pins

Pins is a hyper causal game I made awhile ago. It revolves around trying to get all your pins stuck into a circling object above. The challenge comes in getting all the pins to stick, with out touching any of the other pins.

Here it is on both the iTunes and Google Play Store:

Here is a link to the Github repo: https://github.com/RedGhoul/Pins

Here are a few of the screen shoots:

 

Project – The Event Horizon

This is a game I have in development. It is an atmospheric horror FPS, with rogue lite elements. I am using Unity to make it. Whats funny is that I hate scary games, and have almost never played one, but now I am making one lol. Below is what I have done so far.

And here is link to the github repo: https://github.com/RedGhoul/FPS_4

Neural Network Types

I have been working on my capstone project for the last little bit. It involves using neural networks to solve the problem of segmenting medical images.

Here is a little of what I have learned. I think I am going to start doing a series about this. Mainly cause Machine learning is easier than it seems, and the more people that realize that, the more innovation that will happen 😁

* You wanna have a good understanding of a basic generic Neural networks, before reading on.

So lets get on with it. There are basically a couple of different types of neural network types, such as Generative Adversarial Networks (GAN), Convolutional Networks (CNN), and Recurrent Networks (RNN). Each have their own area and application where they work best. However they all generally use the same principles.

In GANs one part of the NN, is called the generator. This generator generates new data instances, while the other part, the discriminator, evaluates them for authenticity. The discriminator decides whether each instance of data it reviews belongs to the actual training dataset or not. The goal of the discriminator, when shown an instance from the real-world, is to recognize it as authentic.

Generalized Flow of GAN events as follows: The generator takes in random numbers and returns an image. The generated image is fed into the discriminator alongside a stream of images taken from the actual dataset. The discriminator then takes in both real and fake images and returns probabilities, a number between 0 and 1, with 1 representing a prediction of authenticity and 0 representing fake. Then it enters a double feedback loop. Where the discriminator is in a feedback loop with the ground truth, and the generator is in a feedback loop with the discriminator.

GAN_FlowChart

CNNs for SIS are similar to ordinary GANs in the sense that they are made up of two main parts. The first part is known as the encoder, which is responsible for extracting the features of the image. And the second part is known as the decoder, which is responsible for decoding the image.

CNN_FlowChart

The encoding part of CNNs are stacks of Convolutional (C), Activation (A), and Pooling (P) Layers. In the convolutional layer, filters are passed along the image taking dot products to create feature maps. These result of this gets passed through an activation layer. If the first CA layer gets done too many times the feature maps start to degrade, therefor P layers are used. These P layers average out the values in the feature map, which helps perceive the keys features. Most CNN architectures have several CAP stacks before getting put into the decoding aspect of the CNN.

CNN_Filter

The decoding part of the NN goes through the inverse operations of the encoder. Since by the time the feature maps reach the decoder they have been significantly compressed. The CAP layers in the decoding portion go through the process of deconvolution and up sampling using max pooling.

RNNs are a type of NNs where connections between units form a directed graph along a sequence. This allows it to exhibit dynamic temporal behavior for a time sequence. Unlike feedforward neural networks, RNNs can use their internal state (memory) to process sequences of inputs. This makes them applicable to tasks such as unsegmented, connected handwriting recognition or speech recognition.

Recurrent networks are distinguished from feedforward networks by that feedback loop connected to their past decisions, ingesting their own outputs moment after moment as input. It is often said that recurrent networks have memory. Adding memory to neural networks has a purpose: There is information in the sequence itself, and recurrent nets use it to perform tasks that feedforward networks can’t.

That sequential information is preserved in the recurrent network’s hidden state, which manages to span many time steps as it cascades forward to affect the processing of each new example. It is finding correlations between events separated by many moments, and these correlations are called “long-term dependencies”. This is because an event downstream in time depends upon, and is a function of, one or more events that came before. One way to think about RNNs is this: they are a way to share weights over time.

“?” in Angular 5

As you an Angular component has a life cycle, much life us humans. In the beginning we are nothing, we do a bunch in the middle and then we die 🙂 However if you want to call a certain service in your “ngOnInit” to dump some values into a var that appears in your html, your going to have a bad time. Or at least angular is by throwing a lot of errors in your console, I mean it will still work.

To get rid of these errors all you have to do it the following add a “?” at the end of the end of the var that’s in the html, and ta-da errors gone. This works since the “?” tells Angular to chill out there will be a value you there “eventually”. Hmm… but why eventually you may ask ? Its because two functions before “ngOnInit” get called , the very first one being the constructor of the class and the second being the “ngOnChanges” method. So for the execution of the first two methods its asking “WTF where is this thing in the html in the .ts file ?”  which makes throw errors.

Project – The Knight

After taking a long hiatus from Unreal 4, cause I didn’t like blue prints (Unreal 4’s Visual Scripting Language) I preferred real programming (C++) . At which point there started to be a nice long 3 second compile time 😦

I switched to Blue Prints ! I bought my self a course and started going at it every day after work ( well … almost every day … West World doesn’t watch it’s self )  I made the final project in the course, plus some of my own additions (these additions mainly making the game look AAA, and adding UI) .

So this post is dedicated to saying “Hey look I made this cool thing 🙂 ! ” mostly by my self.

Its you basic point and click ARPG that only has one level, and uses alot of the Infinity Blade assets that Epic has given away for free. Here are some screen shots:

 

UPDATE: 2018-08-18:

I plan on adding a better AI to the game using Unreal’s Behavior Tree

Project – iPhone Door Bell

This is an app I made to integrate into another program that I also made. It uses Firebase to control a Raspberry Pie, such that you could ring a door bell from anywhere on the planet.

Here is a little of what the app looks like:

Screen Shot 2017-12-09 at 1.18.43 AM.png
Here is the story board
Screen Shot 2017-12-09 at 1.17.48 AM
Here is the login screen

 

You can find the repo for the iOS door bell here, the Android door bell here, and the program that runs on the Raspberry pie here.