Inspiration

We wanted to learn about machine learning. There are thousands of sliding doors made by Black & Decker and they're all capable of sending data about the door. With this much data, the natural thing to consider is a machine learning algorithm that can figure out ahead of time when a door is broken, and how it can be fixed. This way, we can use an app to send a technician a notification when a door is predicted to be broken. Since technicians are very expensive for large corporations, something like this can save a lot of time, and money that would otherwise be spent with the technician figuring out if a door is broken, and what's wrong with it.

What it does

DoorHero takes attributes (eg. motor speed) from sliding doors and determines if there is a problem with the door. If it detects a problem, DoorHero will suggest a fix for the problem.

How we built it

DoorHero uses a Tensorflow Classification Neural Network to determine fixes for doors. Since we didn't have actual sliding doors at the hackathon, we simulated data and fixes. For example, we'd assign high motor speed to one row of data, and label it as a door with a problem with the motor, or we'd assign normal attributes for a row of data and label it as a working door.

The server is built using Flask and runs on Floydhub. It has a Tensorflow Neural Network that was trained with the simulated data. The data is simulated in an Android app. The app generates the mock data, then sends it to the server. The server evaluates the data based on what it was trained with, adds the new data to its logs and training data, then responds with the fix it has predicted.

The android app takes the response, and displays it, along with the mock data it sent.

In short, an Android app simulates the opening and closing of a door and generates mock data about the door, which is sends everytime the door "opens", to a server using a Flask REST API. The server has a trained Tensorflow Neural Network, which evaluates the data and responds with either "No Problems" if it finds the data to be normal, or a fix suggestion if it finds that the door has an issue with it.

Challenges we ran into

The hardest parts were:

• Simulating data (with no background in sliding doors, the concept of sliding doors sending data was pretty abstract).
• Learning how to use machine learning (turns out this isn't so easy) and implement tensorflow
• Running tensorflow on a live server.

What we learned

• A lot about modern day sliding doors
• The basics of machine learning with tensorflow
• Discovered floydhub

What we could have improve on

There are several things we could've done (and wanted to do) but either didn't have time or didn't have enough data to. ie:

• Instead of predicting a fix and returning it, the server can predict a set of potential fixes in order of likelihood, then send them to the technician who can look into each suggestion, and select the suggestion that worked. This way, the neural network could've learned a lot faster over time. (Currently, it adds the predicted fix to its training data, which would make for bad results
• Instead of having a fixed set of door "problems" for the door, we could have built the app so that in the beginning, when the neural network hasn't learned yet, it asks the technician for input after everytime the fix the door (So it can learn without data we simulated as this is what would have to happen in the normal environment)
• We could have made a much better interface for the app
• We could have added support for a wider variety of doors (eg. different models of sliding doors)
• We could have had a more secure (encrypted) data transfer method
• We could have had a larger set of attributes for the door
• We could have factored more into decisions (for example, detecting a problem if a door opens, but never closes).