Enoch Kumala

Continuing Software Engineer Intern within the Lazard Data Analytics Group.

Participated in the open-access H2 Ventures VC virtual internship

Completed the following modules:
1. Conducted investment prospecting and analysis;
2. Applied the VC valuation method to valuing a portfolio company;
3. Devised an investment selection process for the fund; and
4. Developed growth strategies for portfolio companies.

INTRODUCTION

As COVID-19 creates unprecedented challenges that have never been seen before, the Emory University and Georgia Tech communities have the opportunity to help. The Emory Global Health Institute, the Coulter Department of Biomedical Engineering at Georgia Tech & Emory, CREATE X, and the Emory University School of Medicine are partnering to host a virtual hackathon with students from both universities to pursue solutions to challenging problems sparked by the COVID-19 pandemic.

This hackathon will include teams comprised of Georgia Tech and Emory students who will develop solutions for multiple COVID-19-related problems. Three winning teams will each receive a $10,000 cash prize, the opportunity to take their solution to market through Georgia Techs CREATE-X Startup Launch accelerator, and other potential investment opportunities.

An internationally-diverse, multidisciplinary group of 3 girls and 3 boys, our team could not be more fitting considering the circumstances as we humbly join forces to battle our common global enemy on the frontline. We are even privileged to have a Special Forces First Sergeant of the Israel Defense Forces as part of our team!

Our team's project is a platform for nontraditional suppliers of PPE to connect with organizations in need and facilitate all transactions between users.

Skills used: flask, javascript, MySQL, react

GitHub: https://github.com/trevor-pope/covid19-supply-network

* Started my internship at Amazon Artificial Intelligence (Translate division) within Amazon Web Services (AWS) as the youngest engineer in the companys history at age 15, Amazons minimum age requirement

* Collaborated with experienced cross-disciplinary Amazonians to develop, design, and bring to market innovative devices and services

* Designed and built innovative technologies in a large distributed computing environment and helped lead fundamental changes in the industry

* Created solutions to run predictions on distributed systems with exposure to cutting-edge technologies at incredible scale and speed

* Built distributed storage, index, and query systems that are scalable, fault-tolerant, low cost, and easy to manage/use

* Amazon Translate within the Amazon Web Services (AWS) is a neural machine translation service that delivers fast, high-quality, and affordable language translation. Neural machine translation is a form of language translation automation that uses deep learning models to deliver more accurate and more natural-sounding translation than traditional statistical and rule-based translation algorithms. Amazon Translate allows clients to localize content - such as websites and applications - for international users, and to easily translate large volumes of text efficiently.

https://aws.amazon.com/translate/

https://www.linkedin.com/posts/activity-6664197822193168384-WKZn

https://www.linkedin.com/feed/update/urn:li:activity:6665684922621063168/

https://www.linkedin.com/posts/activity-6664195093181849600-KCBP

https://www.linkedin.com/posts/activity-6664177282028044288--3t-

https://www.linkedin.com/posts/activity-6675304082556649472-Bzgl

https://www.linkedin.com/posts/activity-6675294104995303425-2rnp

Continuing Software Engineer Intern within the Lazard Data Analytics Group.

Youngest Wall Street Professional: Enoch Kumala sets world record

Sillona Gramon | World Record Academy Jan 20, 2020

NEW YORK CITY, New York, United States--On May 27, 2019, Enoch Kumala, 14, started working as a Software Engineer Intern as the youngest hire in Lazards (NYSE: LAZ) 171-year history and Wall Street's history, thus setting the new world record for being the Youngest Wall Street Professional, according to the WORLD RECORD ACADEMY. Enoch Kumala worked within the Data Analytics Group with the primary responsibility of designing, building, testing, and maintaining large-scale software applications and data products. Enoch worked closely with data scientists, investment bankers, and senior management across the firm. Lazard (NYSE: LAZ) (https://www.lazard.com/) is a financial advisory and asset management firm that engages in investment banking, asset management, and other financial services primarily with institutional clients. It is the world's largest independent investment bank, with principal executive offices in New York City, Paris, and London.

As the lead software engineer of the 1-year long Junior Capstone project, I was responsible for recruiting and training the team on the technology used and led my team to win the Runner Up Winner award of the Georgia Tech College of Computing Fall 2019 Junior Design Expo, with judges representing Stryker, NCR, Walmart, State Farm, and GT's College of Computing. The Upper Oconee Watershed Network (UOWN) is an organization that monitors water quality in the Athens-Clarke County area and have done so for 21 years. My team and I created a web application, StreamViz, that allows the public to view stream data including plotting data to look at relationships between water quality metrics (xy scatter plots, bar plots), view summaries of data, and also display our site locations on a map that allows one to select a location on the map and bring up the data for that site.

Skills used: ReactJS, Flask Framework, Python, Matlab, D3.js.

GitHub Repository: https://github.com/ekumala1/streamviz
Application: http://184.154.120.154/raw
Presentation: https://www.linkedin.com/posts/activity-6523655091109588992-SQdw
LinkedIn: https://www.linkedin.com/posts/kathleen-schaag-phd-a1b794144_im-so-proud-of-my-georgia-institute-of-technology-activity-6612773291734155264-2nQe
Georgia Tech: https://serve-learn-sustain.gatech.edu/sls-winners-fall-cs-junior-design-capstone-expo

Returning Fall Data Analytics Software Engineer Intern within the Lazard Data Analytics Group.

* Started my internship as the youngest hire in the firms 171-year history at age 14, the earliest legal age to work in the state of New York.
* Work within the Data Analytics Group and collaborate closely with data scientists, investment bankers, and senior management across the firm.
* Work on projects that implement predictive technologies such as data science and artificial intelligence to assist corporate clients in investment banking activities such as mergers and acquisitions, restructuring, shareholder advisory, and corporate preparedness.
* Responsible for designing, building, testing, and maintaining large-scale software applications and data products.

BuildGT is back for its second iteration, and it will be better than ever! More hardware, more workshops, and more time to create! Feel unprepared? Don't worry! We'll have plenty of mentors on hand to help with projects and tooling. Also, check out BuildGT Week - a week-long celebration of hardware hacking that will feature hands-on workshops from HackGT and our partners. On the day of the event, the Invention Studio and The Hive will be open to provide you with the tools and assistance to turn your ideas into reality! Join us as HackGT ventures into the world of prototyping. Create something novel, something hilarious, or something that changes the world!

T-Mobile in partnership with Microsoft is hosting a Closer to the Customer hackathon at The Georgia Institute of Technology in Atlanta, GA. March 29-30, 2019. We invite fresh and seasoned developers alike to join us to invent the future of AI & ML while mingling with our technologists, product folks, and talent scouts.

Whether you're into business, data, or design, we want you to come to learn something new and lend your own creative energy to making amazing things. At the end of the day, the ideas that change what we see tomorrow come from all of us. Use your smarts, creativity, and innovation to come up with a demo or app to demonstrate your vision for what these technologies can do. The opportunities to transform the way we interact with our customers are limited only by your imagination.

Challenge Theme: Softball Moneyball Help GT Softball win analyzing opponent data/games (Category: Athletic Performance)

The Challenge: Using game play-by-play score sheet data from the NCAA's website, build an opponent scouting report. The current process is manual and time-consuming. In the current format, coaches handwrite in-game play-by-play for upcoming opponents' last 15 games. This may take 6 plus hours from start to finish, per opponent. In the preseason month of February, this could take up to 20 hours a week to produce.

Currently there are companies that produce these types of scouting reports, however, the data and information are incomplete. Visually we want a better product, with information that is unique to our in-game goals and strategies. These opponent scouting reports are an instrumental aspect of our in-game decisions, and ultimately help us to win games.

Scope:
- Importing all GT opponent play by play data into a data-set (sample of NCAA play by play data shown below)
- All data is public information and can be found through the NCAA Stats website
- http://stats.ncaa.org/teams/312390
- Generate player tendency chart based on play-by-play results, which will display:
- Hit location area
- Hit type
- Situational offensive strategies (bunt frequency, steal frequency, etc.)

SUPPLEMENTAL INFORMATION:
Current sheet: There is one sheet, per player, per opponent. Roughly 24-30 sheets per team.

* Inspeee is a social venture startup based in Tokyo, Japan, with the goal of connecting Japanese investors and borrowers from across Asia.
* Inspeee's mission statement is "Financial Freedom for Everybody."
* Worked remotely from Atlanta, Georgia, and was responsible for recruiting and training the software engineering team and led the development of the startup's minimum viable product (MVP) from scratch targeted at seed investors and potential partners to show Inspeee's Proof of Concept.

Site: https://inspeee.com/

GitHub: https://github.com/ekumala1/inspeee

* Started my internship as the youngest software developer in the firms history at age 13.
* ChildPlus Software is rated #1 most widely used Head Start management software by the US Office of the Administration for Children & Families.
* Stemming from President Lyndon B. Johnson's 1964 declaration of The War on Poverty, the Head Start program was designed to help break the cycle of poverty by providing preschool children of low-income families with a comprehensive program to meet their needs.
* The ChildPlus software allows Head Start agencies to go paperless, perform self-monitoring checks, manage multiple programs all in one database, create modules directly in ChildPlus.net to meet the agencies exact needs, monitor family goals and outcomes, ensure all health requirements are met and enroll the neediest children based on eligibility requirements.
* Assigned the task of migrating report-generation function from Windows-based to a Web-based environment. Specifically, the task involved converting a key section of the Windows user interface to an Angular-based web interface to enable accessibility of software on mobile devices. It also involved refactoring the C# backend to correctly serve the new interface. The goal of the task was achieved by collaborating with senior members of the design and software departments to ensure the new interface and backend match the desired specifications and overall software architecture.

Part of a team of 4 in creating a Space shooter game with primary objectives and a level-based system in Unity3D. Most assets were made in Photoshop and Illustrator, and 3D models were made in blender.

Skills used: Unity3D, C#.

* Started working for the Design & Intelligence Laboratory remotely from Denver when I was 11 years old.
* Assigned to work on a problem related to visual perception, embodied cognition, and interactive learning with the task of programming the algorithm initially developed by Patrick W. Yaner as outlined in his publication "Visual Analogy: Viewing Analogical Retrieval and Mapping as Constraint Satisfaction Problems" to apply the mapping system on the action and perception of a real robot.

In this project, my team will implement a detailed mobile-based prototype of our interface. We can use any prototyping tools that we like to assist this process (e.g., Adobe XD, InVision, Framer, Sketch, etc.). We would be able to get much of the interface functionality working, but clearly we will not be able to implement all back-end application functionality. Additionally, we must provide a set of initial usability specifications for our system and a plan for an evaluation of it. To develop usability specifications, we would consider the objectives of our design. For example, if we are working on a calendar manager, we might specify time limits in which we expect a user to be able to schedule or modify an appointment, or a maximum number of errors that we expect to occur. Basically, we would list a set of criteria by which our interface can be evaluated. Further, this part of the project should include an initial evaluation plan for the system. What kinds of benchmark tasks would we have users perform to help evaluate the interface? What kind of subjective questions would we ask if we were to deploy our system and have a user critique the interface? We will need to actually carry out some of this evaluation in the next project, so we should do our best to set it up now. The key here is not to do some exhaustive description of a usability evaluation plan, but to motivate why the particular plan we propose is appropriate for this interface. Note that developing an initial evaluation plan is also a good way to figure out how much of the interface we need to develop. We should be able to build and connect enough of the application functionality to be able to conduct an initial usability evaluation with the benchmark tasks as we are proposing here. Our write-up for this project would include a description of our system prototype. We can include screen dumps to help explain it and text to describe how a user would interact with it. We discuss the implementation challenges we faced. Were there aspects that we wanted to build but were unable to do so? The key component to include in our project report is a justification of why we settled on the design that we chose. What's special about this particular design with respect to our problem? The report for this project also includes the usability specifications that we established and a description of the evaluation that we are planning. This need not be too detailed here as the actual evaluation will occur in the next project.

In this project, my team will write up all the documents required for conducting the evaluation of the prototype. We will create a full testing plan, with simple benchmark tasks and protocols for interacting with our interface. We devise questionnaires to get subjective feedback about the interface and interaction. We will also plan how we would do data analysis. The write-up includes the following components:  * A description of the testing protocol from how we intend to recruit participants to evaluation techniques, tasks, and users involved in our study, to the post-evaluation techniques being used. * Design rationale for the evaluation tasks and materials we employed. Explain why we chose the benchmark tasks that we did. Why did we ask users what we asked? * Provide the evaluation materials: Provide the questions we are using during evaluation and any pre- / post-questionnaire evaluation materials.  * Provide a description of the data analysis techniques we intend to use and provide the rationale. We may also conduct 8-12 user evaluations of our prototype. Our evaluation will involve other students from class or around campus. Using usertesting.com or alternative methods (e.g. sending the prototype to our friend and Skyping with them as they use the tool + screen capture of their screen), we would be able to draw conclusions about the usability of our prototype. We will perform a cognitive walkthrough or other discount usability method. The write-up for this part includes the following components:  * Description of the results of the study (data presentation)  * A discussion of the results  * The implications that we make from the results with respect to our design  * A description of how the prototype design could be improved in light of the implications  The key to this part of the project is not to simply describe our evaluation methodology but to rise above that and describe what we learned from it. What conclusions can we draw from the studies? What aspects of our design "worked" and what failed to meet our specifications? If we had more time to work on the design, what would we now change and improve? Remember, no designer ever gets a system "just right" the first time.

The project assumes that we are quant researchers in a new credit company, "50K Credit". We are tasked with the responsibility of coming up with a screening system that lets our employees know if an individual is eligible for the "new and exciting" credit card that our company is going to launch in July 2020. After much deliberation amongst all researchers, we come to the conclusion that any individual that earns more than $50K annually should be given the credit card. Our task is to use the decision tree algorithm to predict if an individual earns more than $50K annually and is therefore eligible for the new credit card. Skill used: Python, NumPy

Artists and entertainers often make use of multiple sensory outlets that closely interplay to effectively communicate their ideas. For example, in lyrical compositions, lyrics and melody are both essential components that express the musician’s emotions or experiences. A popular trend on YouTube is to generate compositions of music based on the lyrics from popular songs. We know from this that some genres of music are relatively predictable in their mood/melody. We want to understand how these components interact to make meaningful music that audiences love and relate to. Skill used: Python, TensorFlow, scikit-learn

The key goal of the project is to use the knowledge gained to develop a set (3+) of design alternatives for my problem. This is the stage of "informed brainstorming". These multiple design alternatives should explore the potential design space and user experience for the problem. In this part of the project, I will develop mock-ups, storyboards, and sketches of at least three designs and user experiences. That is, I would provide pencil-and-paper or electronic images of the interface at various stages; I do not need to build a working prototype. My design sketches should be sufficiently detailed for a potential user to provide useful feedback about the design, however. Along with my design mock-ups, I would provide a brief narrative walk-through of how the system will work. Perhaps most importantly, I would also include my justifications for why design decisions were made, and what I consider to be the relative strengths and weaknesses of my different designs. The design process I follow here is important. Don't do the following: The group splits up and everyone creates one design, then these are all my alternatives to be turned in. This is not how a good, creative design process should work. It should be more like a brainstorming session with all team members present. I would seek to create some fundamentally different design ideas on different technology platforms, concepts all over the potential design space for the problem I have chosen. The key is to push the boundaries of the space of design possibilities. My project report should include all the explanatory material mentioned above as well as all the design sketches, drafts, storyboards, etc., that I generated. If some of my sketches are on paper, either scan or photograph the material and convert it to an appropriate electronic format. I will make sure that my report adequately reflects the design process that my group undertook. The key in this part of the project is to come up with many different design ideas, not just a small set of wiggles from some basic design. I would plan on turning in at least three different designs. We will utilize one full class day as a poster session near the end of this part of the project. Each group will post their design ideas on a poster in class. Everyone will then circulate and interact with the designers. 

The key goal of this project is to deeply understand the problem space that I am addressing, its set of pertinent users, and the issues and constraints that are involved in the problem. If the task has an existing system/interface, I would perform an interpretive evaluation of that system to help me learn more about it. Most important is to identify important characteristics of the problem that will influence my subsequent design. I will utilize the different techniques for acquiring this kind of information that I feel are most appropriate to the particular task I am examining. My report and deliverable would deeply examine the problem of study. Who are the potential users and stakeholders? What tasks do they seek to perform? What functionality should the system provide? Basically, I am setting up a set of constraints and user requirements for my subsequent design. What criteria should be used to judge if my design is a success or not? More specifically, I would develop the following items in this project, and I would communicate them through my report: * Motivation: An overview of the problem my team is tackling and why it's needed. * I would ground this in research and literature. Start to quantify how impactful the problem is on society. * I would leverage methods such as interviews, observations, surveys, etc to get a better idea of what problems my users are having. Use these techniques to understand what the boundaries of my problem space are. * User definition: A description of the important characteristics of the users of the system. * I would ground this in research and literature. What have people already done in the research domain? * I can leverage methods such as interviews, observations, surveys, etc to get a better idea of my users. * An analysis of an existing system, which can consist of: * Automated or manual, including its strong points and deficiencies. * A task analysis consisting of one of the following: * A description of the important characteristics of the current tasks performed by users. * A description of important characteristics of the current task environment. * A simple structured task analysis of the problem. * A description of the larger social and technical system or context in which my design will intersect. * An initial list of user requirements, that should be used in the eventual evaluation of my design, including a high-level description of how I could measure the successful adherence to these principles. * A brief description and justification of how the above information was gathered. * A discussion of the implications of what I learned above.

The goal of this project is two-fold. The first is for me to be able to effectively analyze tools through the lens of Norman, such that I can start to identify the right problems to solve. The second is to be able to conduct a hierarchical task analysis (HTA) so that I can start to establish foundations for my projects. Pairing up into groups of 2 or 3, we choose a category of a tool to review (e.g. toasters, toaster ovens, blenders, ATM machines). It must have at least three affordances. These do not have to be physical products but can be user interfaces as well (e.g. Spotify / Pandora, PowerPoint / Keynote). The category of a tool has to align with the starting point of the HTA -- defining the user goal. I will thoroughly analyze my tool through the lens of Norman, discussing through these 6 principles of design: Visibility, Feedback, Constraints, Mapping, Consistency, and Affordance. I will also discuss the tradeoffs between Norman principles and conduct a hierarchical task analysis of the tool I chose.

In this project, I will use the K-Means algorithm to do the clustering of candies. Imagine that I am the CEO of a candy company. I want to create a new product. However, I am fairly conservative, so I do not want to make a radically new product. Instead, I want to make a product that is similar to other best-selling candies. The way to do this is simple. I look at all of the candies in the market and cluster them by properties like sweetness, sourness, and nuttiness. I pick one of the centroids of this cluster (the cluster with the absolute best sellers), and that is the candy that I should make. The market research has been provided for this project. The features are: The name of the candy. It will almost always have spaces. The candy sweetness. This is a float between 0 and 1 (where 0 = not sweet, 1 = extremely sweet). The candy sourness. This is a float between 0 and 1 (where 0 = not sour, 1 = extremely sour). The candy nuttiness. This is a float between 0 and 1 (where 0 = no nuts, 1 = all nuts). The candy texture. This is a float between 0 and 1 (where 0 = smooth, 1 = hard and crunchy). The rating. This is a float between 0 and 5 to measure its popularity (e.g the "stars") I would cluster candies by their sweetness, sourness, and nuttiness attributes. We want to keep 3 features so that we can visualize our results in 3D. I will find the average rating of each cluster and pick the centroid of that cluster as the desired candy I would manufacture. Skill used: Python

In this project, I design a learning trading agent. I used a Reinforcement Learner-based approach, and create a Q-learning-based strategy using my Q-Learner. My learner works in the following way: In the training phase, my learner will be provided with a stock symbol and a time period. It should use this data to learn a strategy. In the testing phase, my learner will be provided a symbol and a date range. All learning should be turned OFF during this phase. I will use exactly the same indicators as in the manual strategy project so I can compare my results. I optimize my indicators for time (vectorization), but there should be no changes to lookback windows or any other pertinent parameters. If the date range is the same as used for the training, it is an in-sample test. Otherwise it is an out-of-sample test. My learner should return a trades dataframe like it did in the last project. Overall, my tasks for this project include: * Devise numerical/technical indicators to evaluate the state of a stock on each day. * Build a strategy learner based on one of the learners described above that uses the indicators. * Test/debug the strategy learner on specific symbol/time period problems. * Write a report describing my learning strategy. Skills used: Python

As the lead software engineer of the 1-year long Junior Capstone project, I was responsible for recruiting and training the team on the technology used and led my team to win the Runner Up Winner award of the Georgia Tech College of Computing Fall 2019 Junior Design Expo, with judges representing Stryker, NCR, Walmart, State Farm, and GT's College of Computing. The Upper Oconee Watershed Network (UOWN) is an organization that monitors water quality in the Athens-Clarke County area and have done so for 21 years. My team and I created a web application, StreamViz, that allows the public to view stream data including plotting data to look at relationships between water quality metrics (xy scatter plots, bar plots), view summaries of data, and also display our site locations on a map that allows one to select a location on the map and bring up the data for that site. Skills used: ReactJS, Flask Framework, Python, Matlab, D3.js. GitHub Repository: https://github.com/ekumala1/streamviz Application: http://184.154.120.154/raw Presentation: https://www.linkedin.com/posts/activity-6523655091109588992-SQdw LinkedIn: https://www.linkedin.com/posts/kathleen-schaag-phd-a1b794144_im-so-proud-of-my-georgia-institute-of-technology-activity-6612773291734155264-2nQe Georgia Tech: https://serve-learn-sustain.gatech.edu/sls-winners-fall-cs-junior-design-capstone-expo

Computer games are used to benchmark our progress on artificial intelligence. Games are dynamic environments requiring real-time response, problem-solving, and sometimes the ability to make strategic decisions several time steps into the future. To make games more like the real world, we further require our algorithms to use vision to process all information from the screen pixels, just like a human, and to also use the same control inputs that humans use. In the last few years, 1 particular technique, Deep Reinforcement Learning, has been shown to be able to master many computer games, including most Atari Games, DOTA2, and StarCraft II. Reinforcement Learning (RL) is a class of algorithms that solve a Markov Decision Process. That is, the agent is given: S: A set of all states the agent could encounter. In the case of computer games, S is all configurations of pixels that the game engine can render A: A set of all actions. In the case of computer games, this is all keyboard commands. T: A transition function that indicates the probability of transitioning from one state to another state if a particular action is chosen. We will assume that T is unknown. R: A reward function that computes a score for every state in S. In computer games, a reward is given either based on the in-game score, or for finishing a level, or achieveing an objective. A reinforcement learning agent learns a policy π(s) = a that indicates the optimal action a that the agent should take if it is in state s and acts optimally from that point forward in order to acquire the greatest expected reward. To learn the policy, RL agents enact a strategy of trial-and-error learning where the agent tries different actions in different states to see what gets it more reward. In this assignment, I will implement a deep reinforcement learning agent that plays a platform game CoinRun. In CoinRun an agent must walk and jump to collect a coin at the end of the level. Skills used: Python, NumPy, PyTorch

In this project, I develop a trading strategy using my intuition and Technical Analysis and test it against a stock using my market simulator. In a later project, I will use the same indicators but with Machine Learning (instead of my intuition) to create a trading strategy. Part 1: Technical Indicators Develop at least 3 and at most 5 technical indicators. I create a single, compelling chart that illustrates the indicator. Part 2: Theoretically Optimal Strategy Assuming that I can see the future, but that I am constrained by the portfolio size and order limits as specified, I create a set of trades that represents the best a strategy could possibly do during the in-sample period. The reason for this is so that I will have an idea of an upper bound on performance. The intent is for me to use adjusted close prices with the market simulator that I wrote earlier. For this activity, I use $0.00, and 0.0 for commissions and impact respectively. I provide a chart that reports: Benchmark normalized to 1.0 at the start. Value of the theoretically optimal portfolio (normalized to 1.0 at the start). I also report: Cumulative return of the benchmark and portfolio Stdev of daily returns of benchmark and portfolio Mean of daily returns of benchmark and portfolio Part 3: Manual Rule-Based Trader I implement a set of rules using the indicators I created above. I devise some simple logic using my indicators to enter and exit positions in the stock. I tweak my rules as best I can to get the best performance possible during the in-sample period, and I use my rule-based strategy to generate a trades data frame over the in-sample period, then run that data frame through my market simulator. Part 4: Comparative Analysis I evaluate the performance of my strategy in the out of sample period. I create a table that summarizes the performance of the stock, and the manual strategy for both in-sample and out of sample periods.

In this project, I implement the Q-Learning and Dyna-Q solutions to the reinforcement learning problem. I apply them to a navigation problem in this project. In a later project, I will apply them to trading. The reason for working with the navigation problem first is that navigation is an easy problem to work with and understand. My Q-Learning code really shouldn't care which problem it is solving. The difference is that I need to wrap the learner in different code that frames the problem for the learner as necessary. Overall, your tasks for this project include: Code a Q-Learner Code the Dyna-Q feature of Q-Learning Test/debug the Q-Learner in navigation problems Skills used: Python

For this project, I generate data that I believe will work better for one learner than another. This will test the strengths and weaknesses of various learners. My data generation uses a random number generator as part of its data generation process. Skills used: Python

In this project, I create a market simulator that accepts trading orders and keeps track of a portfolio's value over time and then assesses the performance of that portfolio. My simulator calculates the total value of the portfolio for each day using adjusted closing prices. The value for each day is cash plus the current value of equities. My code keeps account of how many shares of each stock are in the portfolio on each day and how much cash is available on each day. Negative shares and negative cash are possible. Negative shares mean that the portfolio is in a short position for that stock. Negative cash means that I've borrowed money from the broker. When a BUY order occurs, I add the appropriate number of shares to the count for that stock and subtract the appropriate cost of the shares from the cash account. The cost is determined using the adjusted close price for that stock on that day. When a SELL order occurs, it works in reverse: I subtract the number of shares from the count and add to the cash account. The following factors are reported: Price history plot over the trading period. Sharpe ratio (Assumes 252 trading days in a year. And risk-free rate = 0) of the total portfolio Cumulative return of the total portfolio The standard deviation of daily returns of the total portfolio Average daily return of the total portfolio Ending value of the portfolio Transaction costs are an important consideration for investing strategy. Transaction costs include things like commissions, slippage, market impact, and tax considerations. For this project, I consider two components of transaction cost: Commissions and market impact. Commissions: For each trade that I execute, a commission is charged according to the parameter sent. It is treated that as a deduction from my cash balance. Market impact: For each trade that I execute, I assume that the stock price moves against me according to the impact parameter. Skills used: Python

A Multiplayer Online Battle Arena (MOBA) is a form of Real-Time Strategy game in which the player controls a powerful agent called the "Hero" in a world populated with simple, weak, fully computer-controlled agents called "Minions." In this project, I will implement the decision-making for Minion agents. A MOBA has two teams. Each team has a base, which is protected by a number of towers. The goal is to destroy the opponent's base. In MOBAs, bases periodically spawn Minion agents, who automatically attack the enemy towers and bases. Towers and bases can defend themselves; they target Minions before targeting Heroes. Thus Minions provide cover for Heroes, who are much more powerful. In this project, I will implement a MOBA that only has Minions (no Heroes). Typically in a MOBA there are three routes Minions can follow to get to the enemy base—a route through the center with a large melee area, and two routes around the edges of the map—and minions would randomly follow one path. In the MOBA I am building, minions will use A* to follow the shortest path. Gates will randomly appear, sometimes blocking a route and Minions will need to plan paths along alternate routes. There will always be one route open. I will build off my previous navigation mesh and path network generation. A recommended minion decision-making procedure is as follows. If there are towers, Minions automatically navigate to within attacking distance of an enemy tower. If there are no enemy towers, Minions automatically navigate to within attacking distance of enemy bases. Minions can shoot at towers, bases, and enemy agents. Targets are prioritized as follows: closest enemy tower, closest enemy base, closest enemy minion. The bases will automatically spawn Minion agents, after a fixed interval of time; bases will be limited in the number of Minions that can be alive at any given time. Bases are invulnerable as long as there are towers remaining, so towers must be targeted and destroyed first. Skills used: Python

In this project, I implement the decision-making for Hero agents. In this version of a MOBA, Heroes have a number of special properties that make them more powerful than Minions: * Heroes have twice as many hitpoints as Minions. * Heroes have a more powerful gun. * Heroes have a secondary attack that does damage to all enemies within a certain radius. * Heroes can be healed if they return to the base. * Heroes can dodge bullets by "jumping" a short distance in a given direction (or a random direction). * Heroes can gain level-ups by killing enemy agents. A level is gained for each kill the Hero makes (the last agent to damage an opponent before it dies). The Hero gains one extra point of damage per level and maximum hitpoints increases by one for each level earned. In this project, I implement the AI for a Hero agent in a world similar to a MOBA. However, I will substantially change the rules so I can focus on Hero AI without all the complications of a MOBA. In this game, there are no towers and each team has a maximum of three minions at any given time. The minions wander aimlessly, but shoot at Heroes if they ever get too close. Heroes must hunt each other, and the game is scored by how much damage one Hero does to another Hero. Hero decision-making can be anything, but in a MOBA, typically the Hero focuses on gaining extra powers so it can take out enemy Minions at a faster rate. Eventually, a Hero will be powerful enough to quickly take down towers and bases. Since towers and bases target Minions before targeting Heroes, it is beneficial for Heroes to protect friendly Minions and use them for cover. By targeting enemy Minions, a Hero can make it harder for the enemy Hero to take cover. Heroes may engage each other from time to time to disrupt opponent advantage. However, in this assignment, I will only focus on the Hero vs. Hero aspects of a MOBA. I will implement a Behavior Tree for Hero agents. Skills used: Python

Procedural content generation is the use of algorithms (procedures) to create novel, and sometimes customized, game content from scratch. Examples of PCG include generation of levels, maps, tree, cityscapes, weapons, monsters, and quests. PCG is often used as a design-time tool to roughly sketch out level content to be refined by human designers. PCG can also be done at run-time to incorporate individual player differences such as skills or preferences. In this project, I look at run-time PCG to create Mario Bros. game levels customized to individual players’ play styles. This includes (a) learning a model of the player’s play style, and (b) using the model to create a custom level. I must focus on designing and implementing algorithms that use the player information to create something that will evaluate well. This project will be using the 2011 IEEE Super Mario Bros. Competition infrastructure (Level Generation Track). If that link is broken, view the archive of the site. The description of the competition and some documentation can be found there. I will write a procedural content generator in the provided Mario Bros. game engine that optimizes level content for different types of players such as those who like to jump, like to collect coins, or like to kill enemies. I will implement a genetic algorithm to tune the layout of the Mario Bros. level. Skills used: Java

The purpose of this assignment is to help provide some initial feel for risk, probability and "betting." Purchasing a stock is, after all, a bet that the stock will increase in value. In this project, I evaluate the actual betting strategy used at roulette in Las Vegas as follows: episode_winnings = $0 while episode_winnings < $80: won = False bet_amount = $1 while not won wager bet_amount on black won = result of roulette wheel spin if won == True: episode_winnings = episode_winnings + bet_amount else: episode_winnings = episode_winnings - bet_amount bet_amount = bet_amount * 2 Here are some details regarding how roulette betting works: Betting on black (or red) is considered an "even money" bet. That means that if I bet N chips and win, I keep my N chips and I win another N chips. If I bet N chips and I lose then those N chips are lost. The odds of winning or losing depend on whether I am betting at an American wheel or a European wheel. For this project, we will be assuming an American wheel.

In this project, I use what I learned about optimizers to optimize a portfolio. I will find how much of a portfolio's funds should be allocated to each stock so as to optimize its performance. While we can optimize for many different metrics, in this project we will maximize Sharpe Ratio. The function should accept as input a list of symbols as well as start and end dates and return a list of floats (as a one-dimensional numpy array) that represents the allocations to each of the equities. The following inputs are used for optimizing a portfolio: A date range to select the historical data to use (specified by a start and end date) Symbols for equities (e.g., GOOG, AAPL, GLD, XOM). The goal is to find allocations to the symbols that optimize the criteria given above. Assumptions: 252 trading days in a year and a risk-free return of 0.0 per day. Skills used: Python

I implement and evaluate three learning algorithms as Python classes: A "classic" Decision Tree learner, a Random Tree learner, and a Bootstrap Aggregating learner. The goal for my learner is to return a continuous numerical result (not a discrete result). I write my own code for Decision Tree learning, Random Tree learning and bagging. My learners should be able to handle any number of dimensions in X from 2 to N. All of the decision tree learners I create are implemented using a matrix data representation (numpy ndarray). Skills used: Python

A navigation mesh is a means to automatically identify points at which to place path nodes. A navigation mesh is a set of convex hulls (polygons) overlaid on an environment such that the area within each hull is guaranteed to be obstacle-free. The convexity of the hulls is important because an agent within the area of a hull can move to any other point within the hull without crossing a hull boundary. Furthermore, when two convex hulls are adjacent to each other (i.e., they share an edge), that edge can be thought of as a "portal"—an invisible door—from one safe navigation region to another. Connecting adjacent convex hulls into a network of safe passages results in a path node network through which an agent can travel between any two points in the environment without fear of collision. That is, a navigation mesh can be used to automatically place path nodes throughout a game map. The resulting network of path nodes creates a super-highway by which an agent can move from any safe area to any other safe area. There are many ways to convert a navigation mesh into a path node network. In the figure below, I have chosen to place path nodes at the center points of each portal and to generate edges between nodes that are on the same convex hull. This keeps the number of nodes and edges low and ensures that the paths are far away from obstacles. It does create a bit of inefficiency since the path network may take the agent a little bit out of its way. However, there are opportunities to "smooth" the path by taking shortcuts or cutting corners, resulting in conservative but naturalistic-looking navigation. I write the code to generate a navigation mesh for an arbitrary environment and to generate a path network for the environment. The path network should work on any given terrain of obstacles and allow the agent to traverse between any two points (as long as there exists a path wide enough for the agent to fit without colliding with an obstacle. Skills used: Python

This project is a problem of dynamic obstacles. When there are dynamic obstacles, the path must be found in real-time every time the agent wishes to move because we don't know if prior solutions are still valid. It is also possible for the environment to change while the agent is moving making the currently followed path obsolete. Thus, an agent in a dynamic environment must be able to re-plan at a moment's notice. Because paths must be found in real-time, algorithm speed is very important. One of the most commonly used pathfinding algorithms for computer games is A*. With an admissible heuristic, A* provides nice guarantees about optimality—it will find the shortest path—and keep the amount of unnecessary search to a minimum. I will have an agent play a game in which it must collect as many of the resources in the environment is as little time as possible. I will build off my previous navigation mesh and path network generation solution from previous projects. However, this time, the environment will be changing randomly as the agent attempts to gather resources. In this assignment, I will dynamically change the environment by spawning gates, which are walls that span between obstacles. Gates will randomly change positions over time. Note that sometimes the agent may simply become trapped and will have to wait for gates to move before proceeding. In this project, I will implement A* pathfinding to work on a navigation mesh in the dynamic gate-filled environment. Skills used: Python

One of the main uses of artificial intelligence in games is to perform path planning, the search for a sequence of movements through the virtual environment that gets an agent from one location to another without running into any obstacles. In order for an agent to engage in path planning, there must be a topography for the agent to traverse that is represented in a form that can be efficiently reasoned about. The simplest topography is a grid. Think of an imaginary lattice of cells superimposed over an environment such that an agent can be in one cell at a time. Moving in a grid is relatively straightforward: from any cell, an agent can traverse to any of its four (or eight) neighboring cells. In this project, I write the code to superimpose a grid over any given terrain so that an agent can navigate by moving left, right, up, or down from cell to cell. The code to generate the grid should work on any terrain such that an agent can never collide with an obstacle. The game engine is object-oriented. The primary object is the GameWorld, which is a container for all other obstacles. Most importantly, the GameWorld object contains the terrain of the virtual environment. The terrain is represented as a list of Obstacle objects, which themselves are polygons—lists of points such that there is a line between every adjacent point (and the first and last points in the list. The GameWorld also manages the agents, bullets, resources (things that agents can gather) and computes collisions between all objects and obstacles. The GameWorld also does important stuff like run the real-time game loop and maintain the rendering windows. Skills used: Python

One of the main uses of artificial intelligence in games is to perform path planning, the search for a sequence of movements through the virtual environment that gets an agent from one location to another without running into any obstacles. In order for an agent to engage in path planning, there must be a topography for the agent to traverse that is represented in a form that can be efficiently reasoned about. The simplest topography is a grid. Grid topologies discretize the environment and assumes an agent can be in one discrete cell or another. However, for many games such as 1st-person shooters, a more continuous model of space is beneficial. Depending on the granularity of the grid, a lot of space around obstacles becomes inaccessible in grid-based approaches. Finally, grids result in unnecessarily large number of cell transitions. A path network is a set of path nodes and edges that facilitates obstacle avoidance. The path network discretizes a continuous space into a small number of points and edges that allow transitions between points. However, unlike a grid topology, a path network does not require the agent to be at one of the path nodes at all times. The agent can be at any point in the terrain. When the agent needs to move to a different location and an obstacle is in the way, the agent can move to the nearest path node accessible by straight-line movement and then find a path through the edges of the path network to another path node near to the desired destination. In this project, I am provided with different terrains with obstacles and hard-coded path nodes. I must write the code to generate the path network, as a set of edges between path nodes. An edge between path nodes exists when (a) there is no obstacle between the two path nodes, and (b) there is sufficient space on either side of the edge so that an agent can follow the line without colliding with any obstacles. Skills used: Python

A multilayer perceptron is a class of feedforward artificial neural network. I created a neural network to label images from the MNIST dataset. I implemented the forward fill and backpropagation steps using purely NumPy, and tuned hyperparameters to reach an average accuracy of 94%. Skills used: Python, NumPy

In this project, I build a visualization that utilizes multiple coordinated views using brushing and linking. Given two scatterplots that show different attributes of my data, I add the interactivity that allows selections in one view to highlight corresponding data points in the other view (i.e., brushing and linking). The dataset I will use for this project consists of SAT scores. For the first scatterplot, SAT mathematics scores (SATM) should be mapped to the x coordinate and the SAT verbal scores should be assigned to y coordinate. For the second scatterplot, the ACT attribute should be mapped to the x coordinate and the GPA attribute should be mapped to the y coordinate. Each scatterplot is drawn in an SVG element of size 400x400px. Skills used: D3.js

The objective of this project is to implement and test path planning capabilities for Cozmo, specifically the RRT algorithm. Cozmo’s goal during this demonstration will be to find a specific cube face and navigate to it while accounting for obstacles. My implementation should identify a target cube and use RRT to find a path to a specific face, follow the path found by RRT, and re-plan (reset and run RRT again) to avoid any obstacle cubes that are added during navigation. As the behavior is running the map should be updated to reflect any new cubes that Cozmo sees. New cubes may become visible (or be added), but existing cubes will not move. Note that if the target cube is not visible from Cozmo’s starting location, Cozmo should navigate to the arena center to look for it and navigate to it once it is seen. Skills used: Python

An application system that stores information about the Atlanta BeltLine sites and events. The application is intended to keep track of the visitors who visit the different sites and events, users who take transits that connect various sites, and the employees who work in the Atlanta BeltLine system. Skills used: React, MySQL, JavaScript, D3.js.

For this project, my partner and I created a geospatial visualization to view airplane incidents. This visualization used brushing, linking, zoom, and filter capabilities. Skills used: JavaScript, D3.js.

In this lab, the robot will be tasked with automating a warehouse. It will have to collect cubes from the pickup zone and deliver them to the storage zone, avoiding the fragile obstacles in the way. The goal is to deliver as many cubes as possible within 5 minutes. Starting Conditions: The robot will begin near the center of the arena with a random orientation. It will first have to localize itself, then proceed to the pickup zone. Once in the pickup zone, the robot must indicate through an audio cue that it is ready to begin delivery. From that point on, cubes will be placed one at a time within the pickup area for the robot to deliver. Delivery: Once the delivery process has started (i.e. robot makes the request while in pickup zone), a cube will be placed in the pickup zone. The robot must pick it up and deliver it to the storage zone, avoiding the fragile zone along the way. A new cube will be placed in the pickup zone once the robot leaves the pickup zone with the previous cube. If the robot delivers all 3 cubes that come with the robot, cubes will be removed from the storage area (by hand) one at a time and placed back in the pickup zone for future deliveries. There will be at most two cubes in the storage area at any time. The identity of most of the localization markers remains random and unknown. The cubes will be placed in the Pickup Zone once the robot is ready to receive them. Only one cube will be placed at a time. The robot may enter the Fragile Zone while it is localizing before beginning the delivery process. Once cubes are being delivered, the robot must avoid the fragile zone completely. One can think of this as a safe zone for human workers to walk in. The Storage Zone is the destination for the cubes. The cubes can be placed anywhere in the storage zone as long as at least 50% of the cube is inside the storage zone.

I use Principal Component Analysis (PCA) to perform image compression, trying to find the most important pixels to keep while incrementally removing details. Skills used: Python, NumPy

In this project, I create two bar charts on the same web page. The bar charts show the total coffee sales for a chain of coffee shops. The first bar chart shows the total sales per region (i.e. Central, West, East, South). The second bar chart shows the total sales per product category (i.e. Coffee, Tea, Espresso, Herbal Tea). I need to aggregate the data for the region and category data attributes and then compute the total sales. Skills used: D3.js

For this project, I create an interactive visualization. Specifically, I create a filtering mechanism. The program reads data from a CSV file, and using D3, draws a bar chart for the provided data. I add a drop-down filtering mechanism on the page to allow the user to select a color for the filter. The program has drop-down menus (aka HTML Select), and gives a choice of at least 3 colors. I add a text-box to enter a numerical value for the cutoff. I add a Filter button on the page, and I animate the filtering behavior, utilizing both duration and delay methods provided by D3. Skills used: D3.js

In this project, I will enable Cozmo to localize within its arena using a Particle Filter. The main processing loop should: • Obtain odometry information • Obtain list of currently seen markers and their poses • Update the particle filter using the above information • Update the particle filter GUI (for debugging) • Determine the robot’s actions based on the current state of the localization system. For example, I may want the robot to actively look around if the localization has not converged (i.e. global localization problem), and drive to the goal if localization has converged (i.e. position tracking problem). • Have the robot drive to the goal. Note that the goal is defined in terms of both position (x,y) = (6 inches, 10 inches) and orientation h = 0 degrees. Once there, have the robot play a happy animation and then stand still. • Make my code robust to the “kidnapped robot problem” by resetting my localization if the robot is picked up. This should trigger both when the robot is on its way to the goal and once it has reached it (i.e. picking up the robot from the goal and placing it somewhere else should immediately cause it to try to localize itself and search for the goal again). Skills used: Python

Humor meets computer vision. This is a prototype of a device to wake up lazy bones. Using a camera equipped with a computer vision algorithm, the device first gently warns the user to wake up. After that, the device tries to wake the sleeping beauty with a light tap on the head. If that fails, the device will start pouring water on the person’s face. Skills used: ReactJS, Python.

An enormous problem within retail stores is the friction in the process of customer service. For example, every single time a customer enters a T-Mobile store, the representative must tediously record his/her profile. This causes disengagement from the customer and an increase in customer wait time. T-Mobile needs a more seamless approach to accommodate customers and fit them to T-Mobile's most appropriate products and services. My team and I aim to solve this problem with Artificial Intelligence / Machine Learning technologies. Skills used: Angular, Flask, OpenCV, Python.

In this project, I will implement two algorithms for clustering, namely the KMeans and Gaussian Mixture Model (GMM). I implement several mathematical functions that will be used later in my implementation for KMeans and GMM. I perform a comparison between KMeans and GMM on doing simple image pixel clustering to try to compress an image into 5 main colors. I use GMM to do MLE (maximum likelihood estimation), approximating the data using a set of Gaussian distributions. Skills used: Python

In this project, I draw SVG elements on a webpage and build visualizations from them. These visualizations are created using HTML, CSS, and SVG. The webpage I create will have four charts: a single bar, one bar chart, one line chart, and one pie chart. Each chart is drawn in an SVG element of size 400×400 pixels. Skills used: HTML, CSS

In this project, I am writing a Finite State Machine that encodes the following robot states and behavior: State: Idle (this is the starting state) Activity: Monitor stream of images from the camera. Classify each image using the model I developed previously. If one of the symbols is recognized (i.e. not “none”), use the built-in text-to-speech functionality to have the robot say the name of the recognized symbol, then switch to the appropriate state. State: drone (activated by showing “drone” symbol) Activity: The robot should locate one of the cubes (one will be placed in front of it within view), pick up the cube, drive forward with the cube for 10cm, put down the cube, and drive backward 10cm. Then return to Idle state. State: order (activated by showing “order” symbol) Activity: Use the drive_wheels function to have the robot drive in a circle with an approximate radius of 10cm. Then return to Idle state. State: inspection (activated by showing “inspection” symbol) Activity: Have the robot drive in a square, where each side of the square is approximately 20 cm. While driving, the robot must continuously raise and lower the lift, but do so slowly (2-3 seconds to complete lowering or raising the lift). Lower the lift at the end of the behavior, and return to Idle state. Skills used: Python

The objective of this project is to implement a Particle Filter (a.k.a. Monte Carlo Localization). I will work entirely in simulation to validate my algorithm. My job is to implement a particle filter which takes robot odometry measurement as motion control input and marker measurement as sensor input. I use the grid world map with the addition of localization markers on the wall of the arena. The grid world has the origin (0,0) at the bottom left, X axis points right and Y axis points up. The robot has a local frame in which the X axis points to the front of the robot, and Y axis points left of the robot. The localization markers will appear on the walls of the arena and represent the physical markers used in previous projects. The direction the marker is facing is defined as the positive X direction of marker’s local coordinate frame, and Y points left of the marker. The simulated robot is equipped with a front-facing camera with a 45 degrees field of view (FOV), similar to Cozmo. The camera can see markers in its FOV. The simulation will output the position and orientation of each visible marker, measured relative to the robot’s position. The simulated robot will also report its odometry estimates. The odometry measurement is the relative transformation of current robot pose relative to last robot pose, in last robot’s local frame. To simulate noise in real-world environment, the odometry measurement includes Gaussian noise. In addition to the noise in the odometry measurement, the marker detection may also be noisy. This is to simulate poor lighting conditions, camera issues etc. The marker detection is noisy in two ways. Either the robot could detect “spurious” markers or “drop” the correct markers. This corresponds to false positives and false negatives in my marker detector. Skills used: Python

The objective of this project is to use image processing and machine learning tools to correctly classify images. Specifically, I will develop an algorithm that will enable my Cozmo robot to distinguish a variety of symbols from each other, and from other random scenes the robot might see. My algorithm will be given images taken by the Cozmo as input. My algorithm must then determine which of the above symbols if any is in the image. The classifier algorithm that I develop in this project will be used on the Cozmo robot for future projects for behavior control and localization of the robot. Skills used: Python

In this project, my team and I in our Computing for Data Analytics (Machine Learning) course developed an algorithm that generates unbiased United States voting districts. The algorithm will use data from the US Census Bureau to randomly generate population clusters within a state (congressional voting districts) and then predict the voting outcome of these new districts using prior voting data. Skills used: scikit-learn, Python, pandas, geopandas

During this project, I will implement the simplest of Transport Layer Protocols, the Stop-and-Wait Protocol for the reliable transfer of data through an artificial network. Specifically I will: * Demonstrate how messages are segmented into packets and how they are reassembled. * Understand why a checksum is needed and when it is used. * Understand and implement the Stop-and-Wait Protocol with ACK (Acknowledgments), NACK (Negative Acknowledgments), and re-transmissions.

In this project, I will be implementing neural nets, and in particular the most common algorithm for learning the correct weights for a neural net from examples. Given the code structure for a Perceptron and a multi-layer NeuralNet class, I am responsible for filling in some missing functions in each of these classes. This includes writing code for the feed-forward processing of input, as well as the backward propagation algorithm to update network weights. Skills used: Python

In this project, I will be implementing a virtual memory system simulator. In most modern operating systems, user programs access memory using virtual addresses. The hardware and the operating system work together to turn the virtual address into a physical address, which can then be used to address into physical memory. The first step of this process is to translate the virtual address into two parts: The higher order bits for the VPN, and the lower bits for the page oset. The simulator simulates a system with 1MB of physical memory. The system has a 24-bit virtual address space and memory is divided into 16KB pages. Like a real computer, my page tables and data structures live in physical memory too! Both the page table and the frame table fit in a single page in memory, and I am responsible for placing these structures into memory.

In this project, I will implement a multiprocessor operating system simulator using a popular userspace threading library for linux called pthreads. The framework for the multithreaded OS simulator is nearly complete, but missing one critical component: the CPU scheduler! My task is to implement the CPU scheduler, using three different scheduling algorithms: 1. First In, First Out (FIFO) - Runnable processes are kept in a ready queue. FIFO is non-preemptive; once a process begins running on a CPU, it will continue running until it either completes or blocks for I/O. 2. Round-Robin - Similar to FIFO, except preemptive. Each process is assigned a timeslice when it is scheduled. At the end of the timeslice, if the process is still running, the process is preempted, and moved to the tail of the ready queue. 3. Shortest Remaining Time First (SRTF) - The process with the shortest remaining time in its burst always gets the CPU. Longer processes must be pre-empted if a process that has a shorter burst becomes runnable.

Pacman spends his life running from ghosts, but things were not always so. Legend has it that many years ago, Pacman's great grandfather Grandpac learned to hunt ghosts for sport. However, he was blinded by his power and could only track ghosts by their banging and clanging. In this project, I will design Pacman agents that use sensors to locate and eat invisible ghosts. I will advance from locating single, stationary ghosts to hunting packs of multiple moving ghosts with ruthless efficiency. In the Pacman version of Ghostbusters, the goal is to hunt down scared but invisible ghosts. Pacman, ever resourceful, is equipped with sonar (ears) that provides noisy readings of the Manhattan distance to each ghost. The game ends when Pacman has eaten all the ghosts. The blocks of color indicate where the each ghost could possibly be, given the noisy distance readings provided to Pacman. The noisy distances at the bottom of the display are always non-negative, and always within 7 of the true distance. The probability of a distance reading decreases exponentially with its difference from the true distance. My primary task in this project is to implement inference to track the ghosts. Naturally, we want a better estimate of the ghost's position. Fortunately, Bayes' Nets provide powerful tools for making the most of the information we have. Throughout the rest of this project, I will implement algorithms for performing both exact and approximate inference using Bayes' Nets. Skills used: Python

The datapath design that I implemented for the Datapath Project was, in fact, grossly inefficient. By focusing on increasing throughput, a pipelined processor can get more instructions done per clock cycle. In the real world, that means higher performance, lower power draw, and most importantly, happy customers! In this project, I will make a pipelined processor that implements the Bob-2200 Instruction Set Architecture. There will be 5 stages in my pipeline: 1. IF - Instruction Fetch 2. ID/RR - Instruction Decode/Register Read 3. EX - Execute (ALU operations) 4. MEM - Memory (both reads and writes with memory) 5. WB - Writeback (writing to registers) I will have to build the hardware to support all of my instructions. I will have to make each stage such that it can accommodate the actions of all instructions passing through it.

In this project, you will implement value iteration and Q-learning. I will test my agents first on Gridworld, then apply them to a simulated robot controller (Crawler) and Pacman.

This project is designed to give a good feel for exactly how a processor works. In phase 1, I will design a datapath to implement a supplied instruction set architecture. I will use the datapath as a tool to determine the control signals needed to execute each instruction. In Phases 2 and 3 I build a simple nite state machine (the \control unit") to control my computer and actually run programs on it.

I have spent the last few weeks implementing my 32-bit datapath. The simple 32-bit data path is capable of performing advanced computational tasks and logical decision making. Now it is time to move on to something more advanced - the ability for programs to be interrupted. In this project, I will fully implement and test interrupts using the provided datapath and Brandonsim. I will hook up the interrupt and data lines to the new timer device, modify the datapath and microcontroller to support interrupt operations, and write an interrupt handler to operate this new device.

In this project, my Pacman agent will find paths through his maze world, both to reach a particular location and to collect food efficiently. I will build general search algorithms and apply them to Pacman scenarios. Pacman lives in a shiny blue world of twisting corridors and tasty round treats. Navigating this world efficiently will be Pacman's first step in mastering his domain. Skills used: Python

In this project, my team and I created a Mass Transit Simulation app to be used by employees of MARTA (Metropolitan Atlanta Rapid Transit Authority) to allow them to create discrete-event simulations of buses, routes, and stops based on a premade dataset. We worked in teams of about 12 each, separated into "mini-teams" of 3 that worked on the Core Logic, Database, Data Analysis, and User Interface of the app. Skills used: The app was coded in Java, specifically JavaFX, and it used Graphviz for visualizations of data.

Created a Pacman agent with various algorithms including graph search traversal, Markov decision processes, and particle filtering. The Pacman agent was able to work under both fully and partially observable environments and action-stochastic areas. Skills used: Python

In this project, we use a Deep Convolutional Generative Adversarial Network (and 2 neural nets) to generate new faces based on the CelebA face dataset. Skills used: TensorFlow

This project used a convolutional neural network to interpret pictures of both humans and dogs to predict dog breeds and breeds of dogs closest to human faces. I used transfer learning on bottleneck features of the pre-trained Inception model, producing a much higher accuracy than I would without transfer learning. Skills used: TensorFlow, Keras

In this project, we generate The Simpsons TV script using previous examples. We use a recurrent neural network on 27 seasons of The Simpsons dataset of scripts. Skills used: TensorFlow

The project uses a basic neural network to predict bike-sharing data on any given day given a history of previous bike-sharing data. In this project, we must create the neural network from scratch without using any libraries other than NumPy and matplotlib.

I created a game for the Gameboy Advance on a simulator based on C. The game is a simple scrolling shooter modeled after the online game diep.io, modified to use the limited controls of the GBA.

In this project, I will be writing the dynamic memory allocation and deallocation functions of malloc, free, realloc, and calloc. When a program is loaded into memory there are various "segments" created for different purposes: code, stack, data, etc. In order to create some dynamic memory space, otherwise known as the heap, it is possible to move the "break", which is the first address after the end of the process's uninitialized data segment.

The goal of this project is to implement the LC-3 calling convention using assembly recursion. This will involve the use of the stack to save the return address (RA) and the old frame pointer (OFP). In each section, I'll act as a compiler, converting the provided pseudocode into assembly code that follows the LC-3 calling convention. Subroutines: 1. Right Bit Shift The idea is to `rotate' bits around and mask until we get the result we want. Define `rotating' as shifting a binary number B left 1 bit and then setting the new least significant bit of B to the old most significant bit of B before the shift. So, for example, if we rotate a 4-bit binary number abcd, where a; b; c; d are bits, then we get bcda. Notice that if we perform this 16 times for a 16-bit number, we loop around and get the original number back again. And if we `rotate' only 15 times for a 16 bit number, then we've bitshifted the number right 1 bit, with the most significant bit being the old least significant bit. 2. Fast Exponentiation We will implement the following O(log k) algorithm which calculates n^k where k >=0: pow(n; k) = ( pow(n; k=2)2 k is even n
pow(n; bk=2c)2 k is odd pow(n; 0) = 1 3. Recursive Bubble Sort Essentially, the idea is to iterate over an array n times, each time pushing the largest element to its correct position. Most implementations of Bubble Sort are done iteratively, where you have two nested loops, but that's just boring. Instead, we are going to do it recursively! In each recursive call, I will iterate over the array and push the largest element to the very end. Once I do that, I will recursively call the bubble sort method where I will decrease the size by one. Also, I will have to keep track of the number of swaps that I make and return the grand total.

For this project, I write in the C language a graphics library that is capable of drawing a variety of shapes, as well as a number of filters that can be applied to the colors of the pixels of an image.

This project involves building a functional computer, which will be able to run simple programs. The computer I will be building will be a modication of the LC-3 (the LC-M), which supports the following instructions: ADD, AND, BR, LDR, LEA, NOT, STR, and HALT. I will be creating various components: ALU, CC-Logic, PC, ADDR, and SRC2MUX. 1. Program Counter (PC) The PC is a 16-bit register that holds the address of the next instruction to be executed. During the FETCH stage, the contents of the PC are loaded into the memory address register (MAR), and the PC is updated with the address of the next instruction. There are two scenarios for updating the PC: 1. The contents of the PC are incremented by 1. 2. The result of the ADDR is the address of the next instruction. The output from the ADDR should be stored in the PC. This occurs if we use the branching instruction, (BR). 2. Instruction Register (IR) The IR is a 16-bit register that holds the machine code of the current instruction. During the FETCH stage, the LC-M interrogates memory for the instruction, which gets loaded into the memory data register (MDR). Then, the contents of the MDR are loaded into the IR. The contents of the IR are then decoded and executed. There are two LC-M instructions that use constants: ADD and AND. For example, ADD R0, R1, 2 adds the constant 2 to the contents of register 1 and stores the result in register 0. This constant is called imm5 (immediate 5) and is stored in the 5 least signicant bits of the instruction. These 5 bits are sign-extended to 16 bits so that imm5 can be used in other components of the LC-M. 3. ADDR The ADDR is used to calculate addresses during the following instructions: BR | 0000 | nzp | PCoffset9 | LDR | 0110 | DR | baseR | offset6 | LEA | 1110 | DR | PCoffset9 | STR | 0111 | SR | baseR | offset6 |

This project involves writing small programs, modifying memory, printing to the console, and converting from high-level code to assembly. 1. Odd vs Even To start off, I write a small assembly program to determine whether each element in the array (located in memory location x6000) is an odd or even number and print that to the console, as ODD or EVEN. If the element is zero, print ZERO to the console instead. I need to implement the odd/even check for an individual element in the array without using a loop - that means the odd/even/zero check for one given number should be O(1) (its runtime should not depend on the magnitude of the number) and thus the overall code should be O(n). Ex: array: [9, 27, 64, 0] will produce this output: ODD ODD EVEN ZERO 2. Add-Subtract In this problem, I will iterate over items in an array (located at memory location x6000) and either add or subtract them, depending on their index (numbers at even indices will be added, and numbers at odd indices will be subtracted). Therefore, the element at index 0 will be added, the element at index 1 will be subtracted, the element at index 2 will be added, etc until I reach the end of the array. Once I have the result, I save it at the memory location given by the label RESULT. Ex: array: [47, 36, 25, 9, 14, 11, 42] will result in + 47 - 36 + 25 - 9 + 14 - 11 + 42 = 72 3. Reverse String The next problem is to reverse a string. I am given the memory address of the first character of a string and the length of the string. Reverse the string IN PLACE and make sure to maintain `\n' as the last character (so that it prints to the console via PUTS correctly). The trailing newline character is included in the character count. I assume that the last character will always be a newline. Ex: string: \Ramblin Wrecknn" length: 14 will result in \kcerW nilbmaRnn". 4. Number Triangle For this problem, I am given a number in the label TRIANGLE and will build a decreasing number triangle from it.

All computer processors have a very important component known as the Arithmetic Logic Unit (ALU). This component allows the computer to do, as the name suggests, arithmetic and logical operations. For this project, I am going to build an ALU of my own. Objectives: 1. To understand digital logic 2. To use logic gates to perform various operations 3. To learn how to use sub-circuits For this project I: 1. Create a 1-bit full adder 2. Create a 4-bit full adder using the 1-bit full adder 3. Use my 4-bit full adder and other components to construct a 4-bit ALU 4. Create a 16-bit ALU

One of the struggles homeless people are facing is that they cannot find the homeless shelter closest to them, and even if they do, they might not be able to get a bed there because there are no vacant spots or because the shelter has gender, age, or other restrictions. The goal of this project is to create an app that homeless people can use (either on their own phone, if they have one, or by borrowing a friend’s) to find a shelter. As a part of a team of 4, we worked on an Android application for CS+Social Good to help automate this process through a variety of API’s and technologies, including maps and geolocation and databases to retain persistence in the app. Skills used: Agile, Android, Java, Firebase

I was assigned to work on the perception of a robot adapted for repeating tasks based on previous examples (e.g. making a cup of coffee) with the aid of a human. The robot would use template matching to determine similarities between the objects in the example and current working objects.

I and a group of 3 people created a free-roaming space shooter, with primary objectives and a level-based system. Most assets were made in Photoshop and Illustrator, and 3D models were made in blender. Skills: Unity3D, C#

The Music Records database is a platform to assist artists and performers in keeping track of the songs registered and when they were performed. Clients access the database through a simple web interface. Skills: WAMP, phpMyAdmin, MySQL, PHP, Relational Data Modeling, HTML

I worked on the Personal Health Management mobile application, which stores medical data including heart and respiration rates, step count, and exercise records. Skills: Java, Node.js, Android OS, MongoDB