Team Status Update for 03/21 (Week 5, 6)

Progress

This week, we lost access to our lab and our hardware, so we had to re-scope part of our project due to the recent situation. We wanted to transition to remote by keeping the integrity of the project but also having enough individual components for each of us to work on. We originally planned to do everything in simulation, but now we are shipping the hardware and building out each component individually. More information is attached in our statement of work.

Deliverables next week

Gesture recognition

We are working on ways to run the system locally. We lost remote access to our Xavier board, so we are figuring out alternatives on AWS or if we can get it shipped to us. The top priority will be to get the gestures we already recognize working again on the new setup. We are also waiting for our webcams and equipment to ship, as the webcam quality from the laptop is much worse.

Robot manipulation

We don’t have an access to the robot, so for the next couple weeks, we will work on the robot through simulation. This will give us some ideas on how the robot will behave with the algorithms. We hope to get some working 2D-mapping algorithm through the simulation.

Schedule

Behind schedule, but we have readjusted it for remote work.

Rama’s Status Update for 03/21 (Week 5, 6)

Progress

We had to make some changes to the project to deal with remote work. Taking into consideration Marios’ suggestions, we will be proceeding with the three major sections but will be decoupling the parts and communicating between them by sending prerecorded data around. I spent some time this week trying to get Webots to run on the Xavier board but was unable to get it to work with the unsupported ARM processor. After our decision to work with our original hardware, I pivoted to work on recognizing the Roomba and user. There is limited testing that can be done without videos from the new environment, but I am moving forward making large assumptions that can be tailored to fit our actual hardware once it is delivered.

Deliverables next week

I want to finish recognizing the Roomba and user and start to create a mockup of how the map will be represented.

Schedule

Readjusted expectations for remote work; waiting on hardware delivery.

Jerry’s Status Update for 03/21 (Week 5, 6)

Progress

These past two weeks were hectic as we tried to deal with transitioning our project to work remotely. Alot of time was spent to bouncing around different ideas for how we could change our project and doing research to see what of the methods were visible. We originally wanted to move the project to simulation, so we were looking into methods like Webots and Gazebo. After further discussion with Marios, we decided to still have the robot run locally at Sean’s place and have Rama and my parts run remotely, integrated with video editing.

On the technical side, I’m looking into streaming my webcam footage to the  xavier board to process the gestures. Even though latency is not as much of a concern, I want to make sure that is is fast enough for development. I am also working on evaluating the code to see how much we can reuse with the new project.

Deliverables next week

Next week, I want to make sure all the existing gestures can be recognizing through the home environment. (Everything except for the point) And I want to start gathering data again for the gestures and the point with my new home environment. I don’t know if I will receive the webcam and hardware from Quinn, but I’ll try to set that up if it arrives.

Schedule

Behind schedule, but we have readjusted it for remote work.

Sean’s Status Update for 03/21 (Week 5, 6)

Progress

This week, well, it was fairly unusual. I’m in Chicago with my parents and still trying to adjust to the new norm. That includes working on the robot without the actual robot. The Roomba will arrive here in approximately 1~2 weeks, so in the meantime, I am working on the simulator, Webots, to develop some basic versions of the algorithms. This is purely for the developing purpose, and the simulation will not appear on the demo or the final presentation.

Webots

Luckily, Webots, an open source simulator, comes with a nice model for iRobot Create. This lacks some sensors, such as light sensors or IR sensors, but it is good enough for the purpose of algorithm development. I was able to implement part of my previous 2D-mapping code into the simulator, and I plan to work on it for a while.

Deliverables next week

Next week, I will continue to work on Webots to implement 2D mapping algorithm and possibly start working on the path-planning.

Schedule

A bit behind; schedule updated

Team Status Update for 03/07 (Week 4)

Progress

This week, we made good progress towards implementing mapping and gesture recognition using ML methods like SVM.

Robot Mapping

This week, we (partially) implemented the 2D mapping algorithm. There are two phases to the algorithm: edge-following and scanning the rest of the room. The edge-following works fine, but we are still experimenting with the second phase. We need to continue tuning and potentially come up with a new algorithm. Since mapping is a significant part of the project and we don’t want any bottlenecking, we must complete the algorithm by the beginning of the week after the break.

Gesture Recognition

We deployed our data gathering pipelines to collect data for teleop and point data. We also trained both multiclass and one versus all (OVR) SVMs for each task and tried them with our main camera script. Our best teleop model gave around 0.94 accuracy with SVM params C = 10, gamma = “scale”, and polynomial kernel. It was interesting to see the cases that our models beat the heuristics, especially when the user is standing on the of the screen or not directly facing the camera.

Deliverables next week

Next week, we will continue working on gesture recognition with more features and explore 2D point tracking with models. We will also explore the possibility of tracking with multiple cameras. We also will start exploring methods to locate the robot from the image in order to start working on our 2D to 3D mapping synchronization.

Schedule

On Schedule.

Rama’s Status Update for 03/07 (Week 4)

Progress

This week I finished work on the reliability of our webserver and started work on structuring our data to handle JSON for passing information for the other requests that will be made. This involved straightening out the details of the communication between the three components of this project and the interfaces that they will implement and expect. The dashboard has been shelved since it is not as critical as laying server communication groundwork.

Deliverables next week

Continuing work on the APIs.

Schedule

On schedule, moving dashboard to a later date.

Jerry’s Status Update for 03/07 (Week 4)

Progress

This week, I explored machine learning methods for gesture recognition. We originally used heuristics in order to recognize gestures, but found that heuristics often fail when the user is not standing directly facing the camera or standing on the left or right edge of the camera view.  For example, an arm extended straight forward on the right edge of the screen has a large difference between shoulder X and wrist X compared to an arm straight forward on the center of the screen.

In order to collect more training and testing data, I improved our data collection pipeline to collect features by finding the x and y distances from each keypoint to the chest and normalizing the distances for a 22 feature vector.  The system has a warm up time of 200 frames before it starts recording data and then records every 5th frame of the keypoints as training data.

Because the amount of data we were using were low (~1000 examples), I chose to use SVM (support vector machine) models because of the promise they were converge with low amount of training data.  I built infrastructure to support multi class SVMs to take in a config file of hyper parameters and feature names, train multiple models, and measure the average performance. Online research showed that multiclass SVMs were not reliable, so I also implemented infrastructure for training and running one versus all (OVR) SVM models.

Because the model only recognizes teleop commands, the model is only used when heuristics detect that an arm is raised horizontally. I first tried using a multi class SVM to detect if the keypoint vector was left, straight, or right.

I tried the following hyperparameter combinations, with each row representing one run.

The SVM multiclass model worked great for the teleop commands, with an average test accuracy of 0.9573 over 5 runs. The best parameters were polynomial kernel and regularization constant C = 10. The regularization constant is inversely proportional to the squared l2 penality. After testing with the live gestures, it worked reasonably well and was able to handle many edge cases of not directly facing the camera and standing on the edge of the room.

I tested the OVR SVM method on teleop commands, building a SVM for detecting left, straight, and right. The test accuracy and mean average precision is measured over an average of 5 runs. I saw slightly higher accuracy using a polynomial kernel using C = 100 with a test accuracy of 0.961. It was interesting to see a dropoff in performance for the straight data. there may have been some errors in collecting that data so I may try to collect more.

SVMs worked well for teleop data, so I wanted to try it for pointing data as well. The idea is to divide the room into bins of 1ft by 1ft and use a model to predict which bin a user points to based on the user’s keypoints. I didn’t have enough time to collect data for the entire room, so I only collected data for a row of the room. Here are the results of experiments I tried:

The results for point were also pretty good at 0.95 test accuracy, but the spatial data is only along one dimension, it would be interesting to see the performance across two dimensions. It is also interesting that the performance between OVR and multiclass is more noticeable with more classes, as it’s harder for one SVM to optimize many decision boundaries.

Also worked on documentation for how OpenPose / Xavier board / Roomba communicate.

Deliverables next week

I want to try to do point detection with more than one row of the room. I’m not sure if SVM methods will scale to cover the entire room or another neural network model is needed.

Higher quality data is also needed, I will continue to gather data. I want to explore other feature engineering techniques like normalizing the points but also letting the model know where the user is in the frame. I also want to experiment with using keypoints from multiple camera perspectives to classify gestures.

Schedule

On Schedule. More time needs to be allocated to gesture recognition, but it is fine because we need to wait for the mapping to be finalized to proceed.

Sean’s Status Update for 03/07 (Week 4)

Progress

This week, I worked on implementing the mapping algorithm. Initially, I thought it would be an easy task given that 2D mapping simply implies scanning the room autonomously. However, it turns out it requires much more fine-tuning then that. There are 2 main phases to my mapping algorithm: edge-following and filling-in-the-rest.

Edge-Following

First, the robot performs “edge-following” to get the dimension of the room. The robot will first move forward until it detects an wall. Then, it rotate to the right(or left) in place until the wall is no longer visible. Once this is done, the robot will move forward in an arc steering to the left(or right). The reason for moving in an arc is to lead the robot toward the wall. If it moved straight instead, the robot will potentially travel away from the wall. The edge-following is “done” when the robot returns to its initial position where it detected the first wall. This task is done twice, once steering to the left and once to the right. Performing edge-following in both directions is necessary to scan the area that was potentially missed in one of the runs. Meanwhile, the XY-coordinate of the robot is being recorded to generate the map.

Filling in the Rest

Once the boundary of the room is set, the robot must travel the rest of the room to find any potential obstacles such as a furniture. This is a bit more tricky. First, it is hard to define the end-condition that guarantees enough samplings to generate a map. In addition, it is difficult to set the behavior of the robot that would work universally regardless of the shape of the room. It turns out that iRobot actually programmed Roomba to move “randomly”–move straight ahead, rotate random amount when bumped into something, and loop–to maximize the area being covered by it while cleaning. This works well if the the main function of the robot is to clean the room; there is essentially no limit on the time it takes, and it doesn’t matter too much even if some area is not inspected. However, when we need to generate a 2D map of the room, this can cause some problems. First, moving for a long time, especially including rotations, can introduce more and more error to the odometry. In order to use the map for path-planning, it is important to have a map that is as accurate and detailed as possible. Also, this algorithm doesn’t guarantee a completeness within a finite time. It might be the case that the robot cannot cover enough area within a reasonable time period. Thus, I decide to implement a more formulized behavior for the robot. I am defining the robot to essentially first move back-and-forth parallel to the first wall it detects. This will let the robot travel the room more efficiently. Then, it will do the same thing perpendicular to the first wall. This is to avoid potentially being trapped in a certain area of the room. More testing would be necessary to check the validity of this algorithm.

Deliverables next week

When I get back from the break, I plan to complete the 2D mapping algorithm

Schedule

On Schedule.

Team Status Update for 02/29 (Week 3)

Progress

We finished the first version of our MVP! We integrated all our systems together for teleop control and docking to the charging point. It was great to see all the components come together. The gesture recognition is still shaky and the home docking system needs to use our mapping system, but we will work on that next.

Software

We experimented with different cameras and are working on pipelines for data collection to train ML models to recognize gestures from keypoints.  In addition, the sockets we used for our webserver are unstable, so we did work to make sure that crashes were greatly reduced.

Hardware

It was good to see the hardware components coming together. We were able to control Roomba via headless RPi which was our MVP. Additionally, we began building the mapping algorithm for the robot. It would require a decent amount of testing and fixing, but we hope to finish it by spring break. 2D mapping is essential for the robot’s additional tasks, so we have to make sure the algorithm works correctly before starting to use the generated map.

Deliverables next week

Still a few fixes to finish our MVP and we want to start using a 2D mapping system from the Roomba.

Rama’s Status Update for 02/29 (Week 3)

Progress

I worked on the WebSocket communication between the gestures and the robot. There were some issues with the gestures crashing when the connection dropped, and I wrote a connection wrapper in python for the gestures and robot to use that should attempt to maintain a long-term connection. I’m also changing the format of messages passed to JSON to set up groundwork for passing more structured data around (i.e. mapping information).

Deliverables next week

1. Testing the WebSocket again to make sure there are no crashes

2. Planning WebSocket API spec

3. Starting working on the dashboard

Schedule

On Schedule.