Synapse Holiday Special
The holiday season is here and Peltarion would like for you to enjoy it as much as we do. Therefore we are currently offering a limited number of Synapse Licenses at half price during December and January! The first licenses each month are automatically sold at half price. There is only a limited number though, so act while there is still time!
To see if there are discounted licenses left, visit our web shop.
Synapse 1.5.2 Released
We are happy to announce that Synapse 1.5.2 has been released. This update contains a lot of improvements under the hood with optimization of the basic math libraries as well as the multicore processing parts. There have however been two updates that directly affect the usability.
In training you will notice that there is a new button in the toolbar:
This is the "Load Best System" button and behind it is an awesome new feature. One common problem with adaptive systems is that you seldom know how long you should train them - too few epochs and it won't learn, too many and it will start over-training (losing its capability of generalizing). With the Load Best System function you don't have to worry about that any more. Synapse now keeps track of all the states during training and remembers each time an improvement has occurred. Pressing the "Load Best System" button loads the best system up to date (as measured on the validation set). So it doesn't matter if the system has begun over training or is diverging - you can simply with the click of a button get the best state.
We've added new functions to the preprocessing mode GUI that will help to keep things organized when dealing with multiple data units and visualizers.
There are two major new things:
1) Colorized data units and visualizer tabs. A visualizer tab gets the same color as the data unit it is showing.
2) You can now rename tabs by right-clicking on them.
The 1.5.2 update is available as an automatic update only. Just start Synapse and unless you have turned off automatic updates you'll get it automatically.
-The Peltarion Team
Consuming deployed Synapse components from C++
Sometimes you wish to use a deployed Synapse component from software not written in a .NET language. If the software is written in C++ or can make use of native DLLs you can still make use of deployed Synapse components either directly from C++ or by creating a C++ wrapper that exports key functionality.
This post shows how this can be done by writing a simple application in C++ that uses the deployed component from the famous police tutorial. For the steps described in this post we will not need Synapse but will use Microsoft Visual Studio 2010 (Make sure it is the C++ version if you use the express edition).
In order to manage our .NET object in the unmanaged world we will make a class called Client that will handle instantiation and destruction of an instance of the .NET object (in our this case Peltarion.Deployed.GodCopBadCop). In this class we can also implement any access methods to provide communication with the managed object.
We will then use this Client class to instantiate an instance of the deployed Synapse component and evaluate a test sample from the police data file.
Fist off start Visual Studio and create a new C++ project. For this exercise we will use a Win32 Console Application. I'm calling this project NativeSyn. (Check empty project in the second page before you click finish.)
I have copied the Synapse deployment directory GodCopBadCop to the project folder for easy access. To use it though we must add a reference to it. In the Solution Explorer select the NativeSyn project and hit Alt+Enter to bring up the properties window.
Turn on Common Language Runtime Support under configuration properties
Then add a reference to the dll containing the deploys Synapse system. For us that will be GodCopBadCop.dll.
(If you just want the project and source files to play with on your own you can find them at the end of the post)
Now let's add a header file called Client.h and start crafting our Client class. We will need a private void *ref to keep track of the managed .NET object. (We can't point to it directly since it's in managed space but we will get to that.) We will also need an alloc and a free method that will be called from the constructor and destructor respectively. Finally we will need a test method to facilitate the testing of Dutch policemen.
For the actual implementation add a source file called Client.cpp.
Include windows.h , Client.h and in order to comunicate with the managed world, vcclr.h. We will also be using namespaces System and System::Runtime::InteropServices.
Next is the implementation of the constructor and destructor. This is particularly easy as all they have to do is call alloc() and free(). We will however add a #pragma unmanaged prior to their implementation.
The rest of the code will be devoted to dealing with managed interop so #pragma managed this time. To run anything .NET related we need a using directive to mscorlib.dll and we will need another to GodCopBadCop.dll.
The type we go through all this trouble for is Peltarion.Deployed.GodCopBadCop in C++ that becomes Peltarion::Deployed::GoodCopBadCop. Since it is quite long to type let's make a typedef.
alloc(), now the interesting things start. Our .NET type is managed and subject to the CLS garbage collector. If we just instantiate an instance of it and there is no managed pointer to it we can be pretty certain the GC will destroy and collect it so will need to notify the GC we want that object to stay alive. This is done through the concept of internal pointers and GCHandles. I will not go in to details here but the process is to use gcnew to create an object instance and then register it with a GCHandle and finally store a pointer to the GCHandle.
Now, every time we need to use the object we need to go through the GCHandle to find it. When we want to tell the GC we are done with the object, and that it can be safely collected, we need get our GCHandle and call free on it.
The implementation of alloc() and free() looks like this:
The test method also need to access the object so we need to use the Target property of the GCHandle to get an internal pointer to it. After that you can use it access all the methods of the .NET object. We will primarily be interested in the Set_CSV and the StepEpoch methods along with the properties exposing the system output (on this system the output function layer is called FunctionLayer4 so we will access the FunctionLayer4_Port0 property).
Using the Client in an application is strait forward. We add a main.cpp source file to our project, include Client.h and we are god to go. (If you want you can turn off Common Language Runtime Support for the main.cpp file and all other files that don't do explicit interop stuff.)
Now, the moment of truth! Ctrl+F5
This was a small example to get you going. You might want to mimic some of the deployed Synapse components API or if this was a wrapper class to cater for some other interop you would probably export methods for creation, destruction and access methods that suite that particular platform.
The Visual Studio solution that was created for this post can be downloaded here and Microsoft has published a video tutorial covering this same issue over at http://msdn.microsoft.com/en-us/visualc/Video/bb892742
Using a system trained in Synapse
One commonly asked question is how to best use a trained system with new data. There are three basic approaches:
- Using the probe post-processing component .
- Deploying the system (covered in detail by tutorial #2)
- Loading the new data into Synapse
-
As the first two ways are covered by existing tutorials, this post will cover 3) - how you load and and use new data within a solution in Synapse.
Synapse 1.5 released
Synapse 1.5 has been released and is available for download.
Main highlights:
- Full multicore support for optimizers.
- A new Fully Forward Connected Perceptron Array (FFCPA) advanced neural network block.
- New non-linear gradient optimization algorithms.
- Improved SQL interoperability and data loading performance improvement.
- Control system customization (for deployment)
- Many performance improvements and bug fixes.
-
If you have Synapse installed and automatic updates enabled, you'll get the 1.5 version just by starting up Synapse - for Windows 7 & Server 2008 installations, read note below. Customers can download the full installation package from the customer area. A 30-day evaluation version can be downloaded here.
Very important upgrade information
-
Due to recent changes to the way Windows handles file and directory permissions, if you have User Account Control (UAC) activated the Synapse automatic updates will fail. This is because it no longer has permissions to write to its own plugin directory. In order for the upgrade to work you need to right click on the Synapse icon and select "Run as administrator".
You will only need to do this once as the 1.5 version is compatible with the newer Windows permission policy.
News, updates and plans for 2010
It’s been a while since we published anything here on the blog so here is an update on what’s happening at Peltarion and what the near future looks like.
Two new products
We are currently working hard on the development of two new products. At this point the only things that we can reveal is that the products won’t replace Synapse, and that one is planned for a 2011 and the other for 2012.
Synapse 1.4
The next version of Synapse (1.4) is currently under development. It is feature complete but we have some work left to make it ready for release. It will among other things include multi-core support for optimizers – something that required a complete rewrite of the batch processing system. Synapse 1.4 is planned for release Q2/Q3 2010.
Industry collaboration
Finally, an exciting bit of news is that we have begun a collaboration with Intel. We are not allowed to say anything about it yet, but it involves a combination of their next generation technology and our next generation technology. There will be some seriously cool stuff there.
--The Peltarion Team
Synapse 1.3.6 out
We have released Synapse 1.3.6 which contains a collection of bug fixes. The primary purpose of the release is to consolidate the individual component updates that have been released since 1.3.5 and to fix a common installation problem that people have been running into lately. As releases go this is a minor one.
Among the components that have been patched are:
- The probe component (fixed crashes)
- Delta Terminator (fixed performance issues)
- RBF Layer (fixed GUI bug)
An important issue with the install of Synapse has now hopefully been fixed. When starting Synapse the first time on a Vista or Windows 7 machine and with User Account Control (UAC) running, trial version users have been getting "License System Corrupted" messages from Synapse. This was due to UAC blocking a part of the install of the system that occurs when you start Synapse for the first time. The workaround was to start Synapse with administrative privileges, but many missed the workaround and could not subsequently get the software running. In 1.3.6 when you start Synapse, it will check if it has enough permissions to do the install, and if not to start a new process with administrative rights (the user gets a prompt). Hopefully this will be the end of that particular issue.
New Year – New Updates
First, let us at Peltarion thank all of our customers for making 2008 a great year. The number of Synapse users nearly doubled and it is always great pleasure to see how people use the software to solve problems in a way we couldn't have imagined. We feel truly privileged to be able to help provide solutions across so many interesting domains. We hope that 2009 will be even better and promise to continue improving Synapse making sure it stays the best development environment for adaptive systems.
Now, for the updates: We've released Synapse 1.3.5. It's mostly a collection of under-the-hood changes that improve performance and usability:
- Improved GUI performance
- Multi-threading improvements
- Full 64-bit support
- Extended validation data set support
- New functions in the sensitivity analyzer and probe postprocessor.
- Algorithmic improvements in control systems and learning rules
- Faster data processing with SQL and CSV formats
A number of bug fixes are included as well.
If you have Synapse installed and automatic updates enabled, you'll get the latest version by just starting up Synapse. Customers can as always download the full installation package from the customer area. A 30-day evaluation version can be downloaded here.
We are already working on the next release which will include fully multi-threaded optimizers, new powerful adaptive systems blocks and new advanced learning algorithms.
Happy New Year! / The Peltarion Team
Synapse 1.3.1 updates
We have released Synapse 1.3.1 which contains a number of improvements.
The most visible change is to the Sensitivity Analyzer postprocessor which now has a new interface and functions for compensating for internal correlation between features.
There are two major groups of fixes that have been made. One concerns how validation sets are handled by control systems and filters. Only having one or more validation sets could cause inconsistent behaviour in some filters and that has been fixed.
The second group concerns data loading with major improvements in the SQL format and the CSV file format. In both cases threaded data loading speeds have been vastly improved. Also support for accessing a Synapse solution offline (i.e. when the data file/database connection is can't be accessed) has been added. The data unit input manager has been improved as well to better support threaded loading and offline mode.
Finally, on an unrelated topic, the Peltarion website now fully supports the Google Chrome browser.
--The Peltarion Team
Summer of Synapse
Summer is here and Peltarion would like for you to enjoy it as much as we do. Therefore we are currently offering a limited number of Synapse Licenses at half price during July and August! The first licenses each month are automatically sold at half price. There is only a limited number though, so act while there is still time.
Are there discounted licenses left for this month? Visit our web shop and see for yourself!
Update: All discounted licenses have now been sold out. Congratulations to everyone that got a discounted license!
Synapse 1.3 released!
Synapse 1.3 has been released and is available for download. This release is a big one with new features and improvements in over 50 components. Although there are hundreds of improvements in the new version there are three major features that you will notice right away:
- Integrated help system. On all blocks and filters you can now find a "Help" item in the settings browser. Clicking on it will take you to the relevant documentation in our new documentation system.
- Script Filter and Script Format components with an advanced Visual Studio-like code editor that allows you to write your own filters and formats directly from Synapse:
- LSTMs (Long Short-Term Memories) are advanced memory structures for use in dynamic adaptive systems. Unlike standard feedback loops LSTMs can preserve information over indefinite time gaps. With LSTMs previously unsolvable time-series problems can now be handled with ease.
If you have Synapse installed and automatic updates enabled, you'll get the 1.3 version just by starting up Synapse. Customers can download the full installation package from the customer area. A 30-day evaluation version can be downloaded here.
Server upgrades
We are currently in the process of upgrading our server hardware, software as well as launching a new version of the home page and a new version of Synapse. This will cause interruptions in our service for the next 24-48 hours. We apologize for the inconvenience but we are sure you will like the improvements.
The new documentation system (http://www.peltarion.com/doc) is online and you can reach it if your ISP's DNS entries have been updated (if not, they will within the next 24 hours). The forums (http://www.peltarion.com/forums) will remain offline for a short while until the upgrades have settled.
A new version of Synapse that features massive improvements will be released tomorrow as both download and automatic update. More on that tomorrow.
We apologize for any inconveniences during this upgrade and hope you will enjoy the new site and the new Synapse 1.3.
--The Peltarion Team
Deployed systems on Mono?
First, sorry for the lack of updates on the blog. We've been very busy working on a very large update package for Synapse as well as a new documentation system. We are also migrating to new servers, which does take some time. The good news is that we are seeing the light at the end of the tunnel and hope to have everything finished soon and ready for release. You'll be happy with the new documentation system that is a vast improvement over the existing stuff and it also features a community forum which I'm sure is good news as many have requested it.
Now to the point of this post which is a question that we get relatively often. The question is do systems deployed from Synapse work on mono? (Mono is a .NET framework clone that runs on Linux, Solaris, Mac OS X and a few other platforms.)
The short answer is: No.
The long answer is: Not yet.
The primary problem is a bug in Mono that causes it not to recognize .NET Compact assemblies. Base level components in Synapse are all Compact compatible (so you can use a deployed system on a PocketPC or any Windows Mobile phone and a range of other devices).
We will look into the mono problem and try to come up with a solution. Until then, if you are using Linux (or FreeBSD or OS X etc), you can always use the WINE emulator to run systems. In that case you can probably use Synapse as well. It is of course completely unsupported on our part, but it may be worth a try.
Merry Updates and a Happy New Year
What better way to start the New Year but with a load of Synapse updates? The updates contain over 100 bug fixes, improvements and new features. Among the changes are:
- Wider file format support for CSV and SQL formats
- Improved Genetic and Swarm optimizer performance and stability
- Added loading of existing samples/manual entry to the probe component
- Improved control of Hebbian learning
- Threaded operation for loading of Synapse as well as large Synapse solutions
- Improved performance for several input formats
..to name just a few things.
If you have Synapse installed and automatic updates enabled, you'll get the latest version by just starting up Synapse. Customers can as always download the full installation package from the customer area. A 30-day evaluation version can be downloaded here.
Happy New Year! / The Peltarion Team
The Synapse Spiral
Consuming deployed components as Synapse plugins
We have received questions on how to load a deployed component into Synapse as a plugin and use it as a building block for new systems. This was something that was intended from early on, but was cut from the release and until now we have had few questions on the subject.
This post will almost be in the form of a tutorial and it will explain the interfaces needed to produce a plugin and to allow for standard signal flow. First we will create a minimal plugin, then fill it with a deployed component and lastly add some bells and whistles.
Peltarion @ ICANN’07
We will have representatives at the 2007 International Conference on Artificial Neural Networks in Porto, Portugal between 9/9 and 14/9.
For more information see: http://www.icann2007.org/
The Self-Organized Gene (Part 2)
In 2003 the Human Genome Project was completed, mapping the entire human genome. The project was started in 1990 and was estimated to take some 30-40 years to complete. What the initial predictions missed was that DNA sequencing was subject to what Kurzweil refers to as the law of accelerating returns. The power of DNA sequencing has been increasing exponentially while the cost of the sequencing has been falling exponentially. Thus the project was completed much earlier than expected.
The Human Genome Project is however not the only completed full genome mapping. Thanks to the fast and cheap sequencing a wide range of other organisms have had their DNA fully sequenced. In this second part of this tutorial we will look at yeast and how its genes control its metabolic processes. We will use DNA microarray data to look at this problem.
In the first part of the tutorial we introduced competitive algorithms and focused on the Self-Organizing Map (SOM). We showed how it can be used to visualize high-dimensional data in a very intuitive way.
In this part we will move on to meta-clustering: how and why to cluster a SOM using a neural gas. You will also familiarize yourself with the unified distance matrix (U-Matrix). We will then move on to the actual problem involving the microarray data. After we have done our clustering with the SOM Visualizer we will create a standard neural network based classifier based on the results.
If you haven't gone through the first part, it is strongly recommended that you do so before proceeding.
Although having Synapse is not absolutely necessary for this tutorial, it is recommended as interactivity helps a lot. You can download it here.
The Self-Organized Gene (Part 1)
Last year saw the 30th anniversary of Richard Dawkins' famous book, The Selfish Gene, the book that presented gene-centric evolution to a greater public. Controversial at the time, it is today a widely accepted theory that covers the connection between genetics and evolution through natural selection.
Dawkins' selfish gene should have the emphasis on gene - not selfish - as the primary point is that the gene is the basic unit that evolution through natural selection operates on. The selfish part is directly related to natural selection - genes that maximize their survival probabilities (which they do among other things through cooperation with other genes) live on in the gene pool while those less fit go extinct.
The title of this tutorial should be read in a different way: The Self-Organized Gene - emphasis on the self organized part. We are not going to be discussing the properties of the gene itself, but how gene functions can be analyzed using an adaptive method called self-organization. Our basic unit of operation won't be the gene, but the artificial neuron. In a way, there is a connection to the selfish part as well. While our units do not fall victim to natural selection, do not mutate and are not replicated, they do compete and interact which gives rise to the emergent global property of self-organization.
In more practical terms, in the tutorial we are going to explore unsupervised clustering of data. We will apply this to DNA microarrays, an exciting new technology that allows for very rapid expression profiling. We see how using adaptive self-organizing methods we can detect patterns in microarray data that can be used for understanding, detecting and fighting diseases caused by genetic factors.
In the first part of this tutorial we shall familiarize ourselves with the basic concepts of unsupervised learning, competitive learning and self organization. We shall also explore the self-organizing map as a powerful visualization tool and we'll take a look at a few simple examples to illustrate the principles.
In the second part of the tutorial we will cover meta-clustering before we move on to our target: the analysis of DNA microarray data. Once we have done that we will see how we can change our unsupervised clustering system into a supervised classification system in general and specifically in Synapse.
Synapse 1.2 out!
Synapse 1.2 has been released and is available for download. This release contains a large number of bug fixes in over 40 components making it the largest update yet in terms of number of changes.
There have been some features added as well - mostly minor usability features such as:
- Enhanced copy to clipboard functionality to visualizers
- Cropping by sample and seed support in crop filter
- Per channel equalizing with the equalizer filter
- Improved operator support in the expression filter
- More customization options (scaling, cropping, interpolation..) in image format
- Per sample mixing in the mixer filter
- Row concatenation support for the join format
- Integrated set support for the sink and output formats
- Support for seeds in the unit generation format
- Support for additional data types for the SQL format
Algorithm improvements include:
- NaN/ Infinity detection and prevention for gradient based update rules
- Improved selection algorithms for the GA optimizer
- Additional operators for the expression filter
- Thread securing of optimizable components (for multithreaded execution stability)
The update is about 5 Mb in size when upgrading from 1.1.
If you have Synapse installed and automatic updates enabled, you'll get the 1.2 version just by starting up Synapse. Customers can download the full installation package from the customer area. A 30-day evaluation version can be downloaded here.
Synapse 1.1 out!
We are happy to present a Christmas gift from us - a new version of Synapse. Version 1.1 includes over 400 improvements including new features and bug fixes. It would take up too much space to list them all, but here are a few highlights:
- A new visualizer, the SOM View that allows visualization and preprocessing of data using Self-Organizing maps. It can also produce clustering filters. For more details see this.
- A new powerful expression filter that allows you to create new features based on equation evaluation.
- New much requested "housekeeping" filters such as the reorder filter and rename filter.
- Windows Vista now supported
- Greatly improved support for data with a large number of features (such as images), including new ranged normalization and great performance enhancements.
- New binary compressed xml file format (.synx) for solutions (old plain xml still supported)
- The Error Analyzer can now send error (system metrics) data to preprocessing in the form of a full data unit.
and much, much more. Documentation for the new features will be published shortly.
If you have Synapse installed and automatic updates enabled, you'll get the 1.1 version just by starting up Synapse. Customers can download the full installation package from the customer area. A 30-day evaluation version can be downloaded here.
Merry Christmas and a Happy New Year from all of us at Peltarion!