I have written an application which creates pools of 1000 neural networks. One test performs backpropagation training on them. A second test performs backpropagation, and a genetic algorithm. The amount of times training is called for each test is the same. The genetic algorithm seems to actually be able to converge on a lottery ticketContinue reading “Lottery Ticket Hypothesis in action”
Author Archives: Nicholas Komsa
My AI study so far
I have been studying neural networks for some time, and recently during a YSU hackthon, I managed to make interesting progress. After about a year long break, I return to this code and make large amounts of progress and a number of topics have presented in C++ software. I’m going to describe some of myContinue reading “My AI study so far”
Introduction to Data Oriented Design
Object oriented programming is the typical go-to method of programming, and it is super useful, especially in a program’s “sculpting”/exploration or design phase. The problem with it, however, is that modern computer hardware has evolved and typical OOP practices have not. The main issues are that hardware is getting more parallelized and cache-centric. What thisContinue reading “Introduction to Data Oriented Design”
Division By Zero Exploration pt 2
This is a continuation of an earlier post called, Division By Zero Exploration, which was a continuation of an even earlier post, Division By Zero. In the exploration post, I concluded that, if dividing by zero is valid, then, “it is basically possible to make anything equal anything”. Further thought has lead to an additionalContinue reading “Division By Zero Exploration pt 2”
Structured Bindings and replacing by reference
C++ 17 has Structured Bindings, what they do is create a temporary object and provide access to the object’s members locally. What happens is we create a temporary S object, and then copy the values memberwise into the binding structure. x now equals 5 and b equals 3.2. the S instance goes away. Since functionsContinue reading “Structured Bindings and replacing by reference”
Asymptotic Movement
I discovered a GDC talk on a topic called: Asymptotic Averaging. This is sort of a form of interpolation, and can be used to eliminate jerky motions – in particular, they focus on camera movement. Naturally, when you want to change a camera’s direction, you just set the direction. However, if you are doing thisContinue reading “Asymptotic Movement”
Fold Expressions and Lamda Overloads
C++17 has a powerful template feature – Fold Expressions – that combines with a C++11 feature – Parameter Pack. This allows us to do away with C-style variable arguments (variadic functions). I introduce Lamda Overloading as well, to work with these two concepts in a wonderful way. First off, the Parameter Pack. This is aContinue reading “Fold Expressions and Lamda Overloads”
Division By Zero Exploration
This post isn’t so much about programming as much about an earlier post about Division By Zero. So, I thought, if the reciprocal operation to 1 / 0, 0 / 1, is valid, then maybe division by zero can be postponed and considered later. Similar to the imaginary concept, i or sqrt(-1). Using just fractionContinue reading “Division By Zero Exploration”
Super Simple Lambda Thread Pool
I wanted to quickly create a thread pooler that could be passed lamdas. Turns out it’s super simple. Here are the main things I wanted to accomplish: pass lamdas as tasks to be executed asap. be able to wait for all tasks to execute create a bunch of threads at initialization and them have thenContinue reading “Super Simple Lambda Thread Pool”
Division By Zero
So we all know that dividing by zero is an error in programming, but do you know why? It turns out that it not really an error as much as a math problem, and not so much a problem as much as a thing. Here’s how it goes according to my understanding: A function y=Continue reading “Division By Zero”
Spot C++ 