In this group project for artificial intelligence II, we used Stable-baselines to run experiments on our thoughtfully-designed state space. It works by providing an environment in which actions are taken by an agent and rewards are returned. Our setup is such that one observation from the environment is a text vector, the action space is the predicted rating from 1-10 (then normalized), and the reward is based on the difference between the predicted rating and the actual rating. The substantial setup was in training classification models (using Machine Learning/ NLP methods) to then better predict the best content for the user based on their recent ratings concerning the content features (topic/sentiment). Our reward function then effectively allows us to create a policy for the agent-user interaction using methods described with the Bellman Equation instead of focusing on an online weight vector such as a Multilayer Perceptron in ML would.  *This is unpublished work. Although this was for class credit, the project topic/work was unique to my group. For viewing this project, please  Contact me.

The goal of this work was to present a sampling of the state of the art technologies in the field of conversational agents, along with models used and the algorithms implemented for each model. Cutting edge technologies for each main category of conversational agents (​question answering agents, task-oriented dialogue agents, and social bots) were reviewed. Then models for such agents were explored, followed by a look into the algorithms and neural network structures that can effectively implement such models. ​Fi​naly, a few open problems were proposed to expand on this knowledge. It was anticipated that this literature review will provide a suggestion of starting points for researchers in the field of conversational agents to reference. *This is unpublished work. Although this was for class credit, the project topic/work was unique to myself. For viewing this project, please  Contact me.

This paper analyzes a spam filter approach using the scikit-learn python library in conjunction with the text file preparation needed for the given spam filter agent to perform at its best. Two agents used in this library are the naive Bayes’ classifier and the Support Vector Machine (SVM) classifier. The results are then compared between the two after running both agents on ling-spam and euron public files. This paper discusses the overall process of how these spam filter agents are used and what the corresponding results conclude for now and future improvement ideas. It was found with experiments that when the spam filter agents are trained with a reliable train matrix, both Bayesian and SVM agents perform remarkably well. Although there are many directions to approach the improvement of these filters, one very relevant method would be the standardization of spam filter setup to be designed for a given email interface (e.g. Gmail, Apple mail, Thunderbird, etc.). In this way, the issue different text formats can be addressed directly, enabling the reliable spam filters to do what they do best after being correctly trained on these file types. This was done before my research and application of NLP, so I believe that this paper could now be further expanded to analyze these filters after greater care is taken into NLP preprocessing of input data. *This is unpublished work. Although this was for class credit, the project topic/work was unique to myself. For viewing this project, please  Contact me.

This project was a bit more structured from the course it was completed for. However, the approach to complete the requirements was still very individual. Thus, I will highlight it here. This project was focused on simulating an environment with Braitenberg vehicles. The overall goal of the software project was to develop a simulator where robot behavior is visualized within a graphics window for observation and documentation of the results of experiments involving the entities in the simulator. Braitenberg Vehicles use a simple design to realize complex behavior. The environment had multiple robots, as well as stimuli such as lights and food. Robots exhibited different behavior when they sense the stimuli in the environment, depending on their sensor-motor connections related to that stimulus. For example, some robots were attracted to the light while others feared it. Implementation of the entities required the use of factory, strategy, and decorator design patterns to enable abstraction. At a high level, this was done to learn the software development cycle and how to develop code that can be expanded upon rather than changed for future additions/improvements. Other skills heavily practiced were the use of Git, Doxygen, Google Style (cpplint), unit testing (test-driven development) GUI, json & csv parsing, UML documentation, and design documentation. *This is unpublished work. Although this was for class credit, the project work was unique to myself. For viewing this project, please  Contact me.

As a course group project for CSCI 4061 , myself and two other students were able to tackle this head on with our own unique collaborative approach. This program is a multi-threaded web server made to use POSIX threads to handle a variety of file types. Using dispatcher threads and worker threads in the C language, we accept incoming connections from clients and place requests into a queue (implemented as an array). The worker threads retrieve requests from the queue and fulfill them. Our cache replacement policy is random replacement. Requests are logged in a web_server_log file. Git source control was used heavily in this group setting. *This is unpublished work. Although this was for class credit, the project work was unique to my group. For viewing this project, please  Contact me.

Theory behind my implementation (project Introduction from the course): 

Suppose that a word  is a string of one or more lower case Roman letters a through z, without accents, blanks, or punctuation marks. Also suppose that the letter a corresponds to 0, that b corresponds to 1, etc., up to z that corresponds to 25. (These are not the ASCII or Unicode codes for those letters!) For each word, we make an array of 26 integers, called a summary of that word. In the summary, the element at index k tells how many times the letter corresponding to k appears in the word. For example, if we have the word present, then its summary looks like this, where the large numbers are array elements, and the small numbers are array indexes.
Note that present has two e’s (at index 4), one n (at index 13), one p (at index 15), one r (at index 17), one s (at index 18), and one t (at index 19).
00002000000001010111000000:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Now, two words are anagrams if and only if their summaries are equal. For example, repents and serpent have the same summary as present. To test if two words are anagrams, we construct summaries for both words, then test their summaries for equality. We can construct a summary of a word with w letters in O(w) time, and we can test two summaries for equality in O(26) = O(1) time. As a result, we can test if two words are anagrams in
linear time. 

*The above theory was given as a prompt to us students at the time of project handout. My solution was implemented using Java as my unique interpretation . Although this was for class credit, the project work was unique to myself. For viewing this project, please  Contact me.