Jeroens blog

Two months back I dug up the project files of BN+ Converter Pro, a .Net application I created when I was in secondary school, and did some high level refactoring to optimize it for .Net 4.0 and version 3 of my .Net class library. This was soon after I released a similar update for BN+ Brute Force Hash Attacker, another of my old .Net apps. On top of the changes I made, and a very few new features I’ve added, the code is now publicly available under the terms of the GNU General Public License v3 or later on SourceForge. I waited with releasing this since I wanted the app to be compiled with the stable release of .Net framework, which was released a while back now.

Changes in this release

* Use of BN+ Library 3.0.1
* Use of native components of .Net framework 4.0
* Implemented a new update platform
* Refactored namespaces and moved around a bunch of files
* Redesigned the about interface
* Redesigned the help menu
* Moved documentation to a wiki page
* Added ROT 5, ROT 13, ROT 18 and ROT 48 codecs
* Made the source code available under the GPL on SourceForge

Downloads

• Setup file (zip, windows installer, includes update platform)
• Executables tarball (latest version of the executables, straight from the SVN repo)
• SVN repostory

Links

• Project home
• Documentation

This is a screen shot of the previous version. This part of the interface is pretty much unchanged.

This screenshot shows the redesigned about interface.

the terms of the GNU General Public License

A few days back I decided I should release an update including a new update platform to some of my old applications. Apparently I had deleted the source of my little class library that I used for these applications a while back, and had to do a binary search through my backup archives to find the latest version. While implementing the new update platform in one of these apps, BN+ Brute Force Hash Attacker, I did a bunch of high level refactoring, both in the app itself and the used library, and decided to put them both freely available on SourceForge. I also decided to make some changes to the interface of BN+ BFHA, and replace the usage of a C# library for BigInteger support with the stuff that comes natively with .Net framework 4.0. So basically, after having put this app on the shelve for about a year, here is a new version, which might very well be the final one for this app.

Changes in 1.2.0

* Replaced custom BigInteger class by native .Net 4.0 class.
* Replaced update platform with native ClickOnce deployment updater.
* Refactored code structure and reduced required assemblies to BN+ Framework core.
* Improved Help menu links.
* Fixed Import/Export issue.
* Redesigned about screen.

Downloads

• Setup file (zip, windows installer, includes update platform)
• Executables tarball (latest version of the executables)
• SVN repostory

Links

• Project home
• Documentation

This is a screen shot of the previous version. This part of the interface is pretty much unchanged.

I’m also planning to release the new version of my class library that’s used for this app, which I renamed to BN+ Library, in the near future

Today I released the first public beta of Skynet, which is now at version 0.1.3. Skynet is an implementation of GALib with WPF GUI that solves the Travelling Salesman Problem (TSP) using Genetic Algorithms (GA). It’s completely open source and available under the GNU General Public License.

Downloads

• Skynet 0.1.3.zip 99.4 KB
• Skynet 0.1.3 setup.zip 331.3 KB
• Download GNU tarball (latest version of the source project, straight from SVN)

You can also download the project code directly via SVN from the SourceForge source code repository, at https://csgalib-tsp.svn.sourceforge.net/svnroot/csgalib-tsp. From a command line, you can call the following:  svn checkout https://csgalib-tsp.svn.sourceforge.net/svnroot/csgalib-tsp

Application features

• Graphical WPF interface
• Multiple selection algorithms
• Pause, resume and cancellation support
• Control over mutation ratio’s and elitism percentage
• Optional removal of identical twins or individuals
• “Take over the world” button

Background

The idea for creating this application came to me after reading the first part of Bio-Inspired Artificial Intelligence by Dario Floreano and Claudio Mattiussi. I figured I needed to do an implementation of what I’ve read to test myself. I split up the general GA code from the application itself and created GALib, a small C# Library that provides the scaffolding for Genetic Algorithm based functionality. All work was done in my free time.

See this page for more screenshots.

Using the application

Although the application interface should be pretty straight forward to use, I’ve written some documentation, which can be found here. If you have any questions, let me know

How it works

This section on my wiki explains how Skynet works as an implementation of GALib. If you are not familiar with how genetic algorithms work, you are advised to first have a good look at this Wikipedia article and related pages. This section will introduce you to how GA logic specific to the TSP works in a bottom-up fashion. For more information on the actual evolution, see GALib. I’m also planning to write a Code Project article about this implementation of GALib.

This is a full dependency digram generated in a Visual Studio solution containing both the GALib and Skynet projects.

Points of interest

Since my main motivation for creating this application was exercise, I learned a lot from building it. It’s my first decent C# application, as well as the first time I’ve created one using WPF and the first time I’ve done any GA programming (or AI in general). It also gave me the chance to familiarize myself with some of the new things of .Net 4.0, some profiling tools (see screenshot below), and have some fun with navigation based windows. The biggest challenge in the application itself (so not counting GALib), was definitely creating the crossover algorithm for the Route individual type. At first I simply took half of the connections of one parent, and then the other half from the other parent, but I rewrote this to take all common connections. Although the crossover algorithm works fine now, it’s pretty heavy on the cpu, and limiting the maximum speed of the application severely. If anyone finds a way to speed it up, be sure to let me know :)

I’ve been working on this application on an off for a month now, and have implemented everything I’ve planned and more. Although a lot of cool stuff could still be added, I’m quitting active development of both this application and GALib, so I can focus on new projects that allow me to further expand my understanding of AI.

Over the past 2 weeks I’ve been putting time in creating a general purpose Genetic Algorithm (GA) library in C#. It provides the scaffolding for any GA based functionality. Although it’s not fully finished yet, it is now available under the GPL licence at SourceForge.

What does it provide and can it do ATM?

• An abstract Individual class that can be inherited from to make your own individual type, with it’s own mutation, crossover, initialization and fitness functions and genotype.
• A population class, which is basically a List<IndividualType>, which enables you to do the actual GA evolution. The evolution is done on a background thread, and events keep you up to date by reporting every time a generation has evolved, a new fittest individual is found, or the evolution is complete due to reaching the maximum amount of generations, reaching the stagnation limit or being cancelled. For the evolution you can choose between rank based selection, truncated rank based selection, and roulette wheel selection. You can also set properties like the mutation ratio, and elitism percentage.

What still needs to be finished/added?

• The library contains a IslandGroup class, allowing you to do simultaneous evolution on multiple ‘islands’. This class still needs to be finished though.
• The Population class contains a method for tournament based selection, but the code is not complete yet.
• The performance of the library could probably be improved.
• A lot of other neat things could be added, like multiple reproduction methods and varying genotype size support.

This is a class diagram of the library as it is at the moment.

I’m going to release the TSP implementation I made with this lib on-line in a similar fashion, after the interface is fully finished. Also, once the library itself is finished, I’m going to create an article explaining how it works and should be used, and put it both on The Code Project and my wiki

Resources

• Project home @ SourceForge
• SVN repository @ SourceForge
• Related posts

Over the last week, I’ve been rewriting my Genetic Algorithm (GA) implementation of the Travelling Salesman Problem (TSP). I’ve rewritten pretty much everything, but the two most notable changes are:

1. I split the code into 2 projects: one holding the general GA code, which is now called GALib, and one holding the code specific to the TSP, now called Skynet (lol ). This allows for making any other GA implementation using GALib, even in .Net languages different from C#. The underneath diagram should give you a good idea of how the who thing works. The 4 most left classes are of Skynet, all remaining classes and interfaces are of GALib.

2. I rewrote the genotype of the Route individual type, the core of the TSP implementation. Instead of having a list of integers, referring to cities, I now have a list of Connection, each containing 2 instances of Location. I’ve done this to allow smarter crossover, decreasing the chance of not finding a better solution while it’s still in the converged search space significantly. As a result of this change, I also had to rewrite pretty much everything else of the Route class, including random initialization, mutation and fitness assessment. The biggest challenge here was preventing the creation of multiple loops in the crossover algorithm.

The interface of the TSP app (now called Skynet) also has seen quite some work. I figured out quite a lot of WPF stuff by further creating it. Some extra controls and progress indicators still need to be added though, and I also haven’t created the Cancel/Stop functionality.

Although the algorithm is efficient in the way that it takes relatively few generations to find a close to optimal solution, there remain a few mayor performance issues. If I compare the speed of evolution (measured in generations) with similar applications tackling the TSP, there are those performing up to 3 orders of magnitude faster. Although the fastest of those are written in C++ or C, I should be able to significantly speed up my application. Tracking down resource eating parts of code will be one of my next steps in developing this app. Another possible issue is diversity of the population. I have the suspicion that the diversity shrinks pretty fast, resulting into evolution driven only by mutation. I’m not sure of this though, and also have to investigate how I can prevent this from happening.

Here you have a few screenshots of the app in action

To practice some AI methods I’ve been reading about, I created a genetic algorithm (GA) implementation to tackle the travelling salesman problem (TSP). I decided to do this in C#, to practice myself in some more advanced aspects of the language, and mess some more around with the new stuff of .Net 4.0, and with WPF as interface to get a better grip on the basics of WPF and XAML.

I started with creating a general data structure for any GA algorithm (Classes Population and Individual, interface IIndividual and some others), and then added handling for the TSP problem by creating a Route class. This class holds the crossover, mutation and random initialization methods for routes. Each instance of Route, which derives from Individual and implements IIndividual, contains it’s own genotype, which is a List<Int64>. This list contains the numbers of the ‘cities’ the ‘salesman’ travels along. In the code behind my main window, I then create an instance of a Population<Route>, and do a calculation of the distances between all points, which is then stored in a static field of Route.

I’m going to put the complete project on SourceForge when it’s a little more finished. Although the algorithm is working it can still be optimized a lot (especially the genetic operations). Also, the interface is far from ready, and I’d like to do another simple implementation with the general GA structure to tackle some other problem.

In any case, here are some nice sceenshots

The dots represent cities.

The shortest route after several generations. The gray line represents an attempted, but failed, mutation or combination.

After a while the shortest route, or at least one that's very close, is found.

.

Two days I go I got the beta 2 of Visual Studio 2010, which is scheduled to be released in the first half of next year. With it, came .Net Framework 4 beta 2. I’ve taken a good look at the changes in these new versions, and am really excited about the new features included in them.

The new WPF interface of VS is obviously cool, but it includes heaps of improvements, making life for the user easier. I’m still in the process of finding all goodies

The changes in the new .Net Framework are even more exciting. It includes a new parallel programming model, enabling you to create multi threaded applications without having to bother the low level work like locks and thread pools that was required until now. Also new are code contracts, a very handy feature allowing you to specify certain conditions for your code state (see this blog post). On top of that, there are various new features that where lacking in previous versions of the framework, like biginteger support, tuples and complex numbers, as well as multiple others.

Yesterday I went to my first VISUG event. VISUG stands for Visual Studio User Group and is the independent professional user group for Microsoft Visual Studio users in Belgium. The presentation, titled “C# 4.0 and testability”, and given by Dino Esposito, addressed the importance of testability in applications, and how this is made easier with code contracts.

Code Contracts provide a language-agnostic way to express coding assumptions in .NET programs. The contracts take the form of preconditions, postconditions, and object invariants. They act as checked documentation of your external and internal APIs. The contracts are used to improve testing via runtime checking, enable static contract verification (yay!), and documentation generation. In short, they bring the advantages of design-by-contract programming to all .NET programming languages.