## Descriptors in numl

As some of you know I have been working on a machine learning library for .NET called numl. The main purpose of the library is to abstract away some of the mundane issues surrounding setting up the learning problem in the first place. Additionally sometimes the math in machine learning seems to be a bit daunting (some of it is indeed daunting) so the library allows you to either get into the math or trust that these things are implemented and run correctly.

In order to facilitate this type of abstraction I came to realize that the best way to bridge this gap was to use constructions that most would have already either used or understood: classes. The learning problem, as I understood it, was taking a set of things and trying to learn a way to predict a particular aspect of these things. The best approach therefore was to allow for an easy way to markup these things (or classes) in order to produce an efficient technique for setting up the learning problem.

## Codemash 2.0.1.3

It was absolutely a blast to be able to present my new machine learning library at CodeMash this year. One of the key goals of the library is to ensure that it is readily accessible to all of its users. Machine learning can often be an intimidating subject with its esoteric terms and complex math. This library is designed to ease the process of feature selection (more on that later) and training. This is obviously a work in progress and any input is welcome (and wanted). If you'd like to get started head on over to the site to learn how to get started using nuML.

## Thinking in Points

Consider this little plot generated by python.

## Supervised Learning

In supervised learning, the algorithm is given labeled examples in order to come up with an appropriate model that defines the data and can also correctly label future examples correctly (or adequately). Supervised learning can be grouped into the following depending on the actual label type:

1. Binary Classification (think yes/no)
2. Multi-class classification (any answer from a finite set)
3. Rgression (any answer from an infinite set)

In the machine library I am trying to put together, each of the three groups mentioned above can be separated into distinct .NET data types as follows:

## Introduction

I had the priviledge of presenting at CodeStock. It was absolutely great. I was surprised and humbled at the reception of my session regarding Machine Learning. As such, I wanted to do a series of posts regarding what it is I wish to accomplish.

## Machine Learning is Hard

Because the stuff is so intriguing, I have spent the last number of years trying to figure the stuff out! I would certainly not classify myself as an expert (by any means), but I think I have a general idea of the field.

Machine learning can be seperated into roughly 3 classifications:

## Purpose

This is part 3 of a series going through the process of creating an advanced control for the ASP.NET MVC system. I've decided to create a schedule control that allows a user to schedule and item on a calendar control as well as add some meta-data information to the scheduled date. Together with the debugger we have built, this should not be too difficult

## Purpose

As mentioned in the previous post, in order to create good client side controls that interact well with the ASP.NET MVC system, we need to have a way to visualize data that the control either generates, or passes to the controllers. I found this difficult to acheive in IE as well as Firefox. I did not need/want all of the complexities of Firebug or IE's Developer tools (which are great btw). I just wanted to see my data! The problem with the previous version of the debugger was that it was too dang simple! If I were to use it like this:

```_('Test').clear()
.write('(Simple)')
.set(complexArray)
.write('(Complex Array)')
.set({ one: { a: 'Hospital', b: 4, c: {x:3,y:5}}, two: 'test'})
.write('(Complex Object)')
.set(function(arg) { alert('HI!' + arg); })
.write('(function)')
.set({ one: new Array('Happy', 'debugger', 'array'), two: 'test'})
.write('(Complex Object)')
.set(
new Array(
new Array(
{a: 1, b: 2, c: 3},
{a: 4, b: 5, c: 6},
{a: 7, b: 8, c: 9}),
new Array(
{a: 'one', b: 'two', c: 'three'},
{a: 'four', b: 'five', c: 'six'},
{a: 'seven', b: 'eight', c: 'nine'})))
.write('(Complex Array)');

});```

the debugger would simply not be good enough!

## Purpose

In previous posts, I started creating an html grid helper that was really just an experiment to see how one would accomplish such a thing. Here, I wanted to delve into a more generic approach to creating html controls for the ASP.NET MVC paradigm that would accomplish the following:

1. be highly interactive on the client side, while
2. minimizing the client-server interaction