Mobile Robots Programming: Retriever

During my third quarter as a computer science grad I took a course in mobile robot programming. Students were required to use the Player network server to control a Pioneer 2 DX (differential drive) robot with an 8-point sonar array and bumper array built into the front of the robot.

Using the Player interface, programs can be written on a laptop attached to the robot via an ethernet cable. In such a setup the laptop provides most of the processing power while communicating with the robot's sensors and actuators via an IP connection. Programs can be tested before controlling the hardware using the Stage simulator, which can simulate sensor readings and objects in a 2-D bitmapped environment.

Teams of students were asked to write control software capable of guiding the robot to a number of predetermined locations on the third floor of the GCCIS building, making sure to avoid other robots and innocent human bystanders on the way as well as successfully maneuvering along walls and through door frames when required. The idea was that there were items at each intermediary location that needed to be retrieved before traveling to a final destination.

To accomplish this the robot needed to perform 3 major tasks: localization, path planning, and path execution. The robot was guaranteed to start in one of 8 known poses (location and orientation), however, it did not know which of those locations it started in. We had the robot determine its starting pose by detecting known landmarks in the environment near its starting location, such as pillars and walls, and narrowing down the set of possible locations until it was left with the most probable one.

After localization the robot planned a path to the destinations specified in a user-provided input file. Path planning was aided by the fact that the environment was known a priori. The robot was provided with a black and white raw image file of the layout of the third floor of GCCIS that it converted to a rudimentary obstacle map. A probabilistic road map (PRM) approach was employed to plan a path from one location to another using the obstacle map.

Each path that was planned consisted of a series of waypoints. The entire path itself may have been complex, but the path between any 2 waypoints is nothing more than a straight line. The robot navigated the path between each pair of waypoints by using potential field motion. This addressed the issue of obstacle avoidance because the robot was repulsed by obstacles in its environment while being attracted to its current goal.

Resources:

• Technical paper (PDF)

NeuroEvolution of Augmenting Topologies

During my second quarter as a computer science grad I took a course on neural networks. As mentioned in a previous post, I had previously taken a course in pattern recognition. Since I already knew quite a bit about neural nets I decided to research the topic of NeuroEvolution of Augmenting Topologies (NEAT) instead of work on the scheduled class project (comparing the performance of feed-forward, recurrent, and radial basis function neural nets).

NEAT is a genetic algorithm for evolving artificial neural networks that protects innovation by dividing network types into species based on similar characteristics. During crossover new networks inherit nodes and node connections from their parent networks to form a new network structure. Node genes and connection genes are labeled with innovation numbers so that as those genes can be tracked as they are passed on to future generations. After crossover new networks undergo mutation where new nodes or new connections are added to the network and connections weights are adjusted by a random process.

Unlike traditional learning where connection weights are adjusted via a backpropagation technique, NEAT selects members from the spawned population, called genomes, for breeding. The evolved members are composed of nodes with sigmoidal activation functions that behave in the same way as traditional multi-layer perceptron networks.

Using jNEAT, a Java implementation of NEAT, I attempted to solve 2 different classification problems. The first problem was to classify 150 iris samples as 1 of 3 breeds based on 4 features. The second problem was to classify 178 wine samples as originating from 1 of 3 batches of wine based on 13 features. After conducting a number of different experiments using various configurations settings, I was able to generate a network with 96% correct classification for the iris test dataset and a network with 85% correct classification for the wine test dataset.

About a year later I went on to apply the concept of speciation to a genetic algorithm in my masters thesis.

Resources:

• Research report (PDF)
• Presentation (PPT)

Handwritten Digit Recognizer

During my first quarter as a computer science grad I took an incredibly enlightening course in pattern recognition. Teams of students were assigned the task of implementing a handwritten digit recognizer. Like humans, computers need to determine the content of handwritten information before it can be used in a meaningful way. This is accomplished through a form of optical character recognition (OCR).

The postal service accepts packages and envelopes with handwritten addresses which must be read and interpreted in order to sort mail and send each item to its intended destination. It's both impractical and expensive to have humans sort large volumes of mail so automated computer systems are often used instead. The systems often consist of cameras which take pictures of the addresses and feed the images into program for processing.

My team decided to implement a convolutional neural network similar to Lecun's LeNet-5.

• The first layer is the input layer and consists of one neuron per pixel in a 29x29 padded version of the sample image.
• The second layer applies 6 feature maps to the input layer. Each feature map is a randomly distributed 5x5 convolutional kernel.
• The third layer applies 50 feature maps to all 6 of the previous feature maps after sub-sampling. Again, each feature map is a randomly distributed 5x5 convolutional kernel. These 2 layers are referred to as a trainable feature extractor.
• The fourth and fifth layers are referred to as a trainable feature classifier. These 2 layers are fully connected and compose a universal classifier.

A convolutional neural network exploits the spatial structure of digits and attempts to train weights to identify spatial differences between digits. We calculated classification error rates using standard backpropagation, which played a major role in training the system.

After running the network with 100 hidden nodes for 5 epochs over 60000 MNIST training samples and 10000 test samples, our network misclassified 851 samples and had a 91.4% success rate. Not bad.

While this project focused on recognizing handwritten digits, the concepts and algorithms covered can be easily extended to apply to all alphanumeric characters.

Resources:

• Technical paper (PDF)

Work History Part 4: Xerox Corporation

Employer: Xerox Corporation

Location: Webster, NY

Position: Software / Firmware Engineer

Period: June 2008 - August 2008

Xerox is a global document management company specializing in the production of workstation printers, large scale printing presses, multifunction systems, and the supplies required to run such devices.

Nowadays Xerox seems to be shifting its focus to collaborative web technologies to make it easy to share, edit, and print digital media.

Xerox is named after the process of xerography, which was invented by Chester Carlson in 1938. The Center for Imaging Science (CIS) at RIT is named in honor of Mr. Carlson. A little over a year after I worked for Xerox I was hired to perform research on a flat plate xerographic printing press for the Print Research and Image Systems Modeling Laboratory in CIS.

While working for Xerox I was part of the Platform Development Unit / Control Systems Platform group and was part of the Xerographics / Image Path Software team. I helped maintain and develop the Nuvera Digital Production System line of products; however, my primary task was to implement C++ code to control a down-shooting printhead fixture.

The down-shooting fixture was a digital coater device capable of printing clear gel ink on paper. Such a device allows users to coat specific areas of a document with gloss instead of performing a flood coat of the entire page. Also, such a device can print Braille on pharmaceutical bottles. The European Union has made it mandatory that the name of all medications be printed on the packaging in Braille.

Responsibilities and accomplishments:

• Migrated digital coater LabVIEW code to production-worthy C++ application code.
• Designed a software architecture for Controller Area Network communication.
• Analyzed and implemented solutions for problems with the Nuvera Digital Production System printer.

Computer Graphics II Projects

During my last year as a software engineering undergrad I took a graduate-level course in advanced computer graphics using OpenGL. Each student was required to implement a ray tracer from scratch in order to render a scene similar to Turner Whitted's classic example of transmissive and reflective spheres. A record of my progress is posted on the LiveJournal (tag: raytracer) I kept for the class. The image to the right was the final product.

My personal research project during the class was to implement a particle system from scratch to animate realistic looking fire. I applied a texture map to each particle to give it shape and definition detail. Also, the texture map was necessary to provide the alpha channel used for alpha blending. Various system parameters can be modified in real time to give the particle system the appearance of a lava lamp or even multi-colored fireworks.

The project details are posted on my LiveJournal (tag: openfire). I named the project OpenFire because the source code is available free of charge to the open source community. If modified, all I ask is that I be credited in the source code comments.

Resources:

• Research paper on simulating fire in computer graphics (DOC)
• OpenFire top-level report (DOC)
• OpenFire users guide (DOC)
• OpenFire technical document (DOC)
• OpenFire presentation (KEY ZIP)
• OpenFire source code (ZIP)

I also dabbled in a little bit of Pixar's Renderman technology. There was a student competition to see who could create the most interesting image. I won second place for my abstract rendition of a woman's head and brain! Check it out on my LiveJournal (tag: renderman).

Bachelors Senior Design Project: GridShell

My software engineering capstone project at the Rochester Institute of Technology involved developing a command-line shell to allow easy access to distributed computing environments, namely grid resources such as the TeraGrid. The project was part of a development effort put forth by the RIT Center for Advancing the Study of CyberInfrastructure (CASCI).

GridShell was one of many projects spearheaded by Cyberaide, a community of researchers and organizations interested in advancing cyberinfrastructure to promote collaboration between individuals and providing them with the computing power necessary to deploy and execute processor-intensive programs for scientific research.

The GridShell provides uniform syntax and semantics for creating, submitting, managing, and checking the status of tasks deployed to local and remote Unix resources. It simplifies workflow management by allowing users to execute tasks sequentially or in parallel and allowing users to specify dependancies between those tasks, which places a constraint on their order of execution.

Additionally, users can create scripts in Python to specify task order execution, which is useful for more complex jobs. This is because the GridShell front end is implemented in Python and can execute Python code natively in the command-line interpreter (CLI). Specifically, the CLI is based on the IPython environment. In turn JPype is used to establish a functional language binding between the Python front end and Java back end.

Java was chosen as the back end language in order to leverage existing web service technologies written in Java and utilize other Java utilities. Ultimately, our goal was to provide multiple interfaces to the underlying GridShell task management framework, including the traditional terminal interface as well as a web interface, MATLAB interface, Ruby interface, etc. For the web framework we decided to use a deployable Apache Axis2 web server with Rampart security.

Resources:

• Poster
• Technical paper (DOC)
• Demo notes (TXT)
• Demo 1
• Demo 2
• Demo 3

Finite State Process Autocoder

As a software engineering undergrad who was part of the honors program at RIT, I was required to complete an independent study. At the time I was taking a course in concurrent systems and was making extensive use of the Labelled Transition System Analyzer (LTSA), a concurrent system modeling tool which uses Finite State Process (FSP) algebra notation to represent component behavior.

Once a system is specified in FSP notation, the LTSA can parse and compile the FSP notation to generate a graphical Labeled Transition System (LTS) model. The LTSA also provides a means to “animate” the system by performing discrete or shared process behaviors one at a time and stepping through the states of the system. Under the hood, the LTSA generates and stores an internal state machine representation of the system.

One of the major difficulties encountered by software engineers who use the LTSA is deciding how to translate the FSP system representation into an executable implementation. A common practice is to use the LTSA as a system design tool and to deviate from the FSP during the implementation phase in order to create a custom-tailored system from the ground up. The major disadvantage is that the implemented system may no longer exhibit the same behavior as the FSP and therefore will need to undergo an entirely separate, and more complex, verification process.

Clearly, it is advantageous if the system implementation reflects the original FSP design. At the time when I was conducting my independent study there was no widely accepted procedure for converting the FSP into source code. I began developing the an automatic code generation backend called the FSP Autocoder to use the LTSA to parse FSP notation and perform semantic analysis to produce code stubs for primitive concurrent objects.

Before I could begin working on the compiler aspect of the autocoder, I needed to design a “universal” (i.e. widely applicable) concurrent system architecture that could be traced back to the FSP system representation and vice-versa. I considered many approaches, such as employing a state machine architecture, rendezvousing threads in conjunction with a round-robin thread scheduler, and using a Communicating Sequential Processes (CSP) library.

Resources:

• Technical paper (DOC)
• Presentation (PPT)