U.S. markets open in 1 hour 44 minutes
  • S&P Futures

    4,160.50
    +30.00 (+0.73%)
     
  • Dow Futures

    34,202.00
    +207.00 (+0.61%)
     
  • Nasdaq Futures

    12,682.50
    +137.25 (+1.09%)
     
  • Russell 2000 Futures

    1,963.00
    +13.10 (+0.67%)
     
  • Crude Oil

    78.23
    -0.24 (-0.31%)
     
  • Gold

    1,894.20
    +3.50 (+0.19%)
     
  • Silver

    22.45
    +0.03 (+0.16%)
     
  • EUR/USD

    1.0770
    +0.0052 (+0.48%)
     
  • 10-Yr Bond

    3.6530
    0.0000 (0.00%)
     
  • Vix

    19.22
    +0.56 (+3.00%)
     
  • GBP/USD

    1.2160
    +0.0089 (+0.74%)
     
  • USD/JPY

    130.7500
    -0.5860 (-0.45%)
     
  • BTC-USD

    22,656.06
    -526.95 (-2.27%)
     
  • CMC Crypto 200

    521.72
    -15.17 (-2.83%)
     
  • FTSE 100

    7,947.39
    +62.22 (+0.79%)
     
  • Nikkei 225

    27,584.35
    -22.11 (-0.08%)
     

Future Forward: How Machine Learning and Human-in-the-Loop Approaches Are Expanding the Capabilities of Automation

Digital transformation efforts in a number of industries have driven massive adoption of robotic process automation (RPA) over the past decade. The hard truth is that RPA is a decades-old technology that is brittle with real limits to its capabilities. It will always have some value in automating work that is simple, discrete, and linear. However, the reason automation efforts often fall short of their aspirations is because so much of life is complex and constantly evolving – too much work falls outside of the capabilities of RPA. In this talk, Varun Ganapathi, Ph.D., Co-Founder and Chief Technology Officer of AKASA will discuss how exceptions and outliers can actually make automation stronger and how emerging machine-learning-based technology platforms combined with human-in-the-loop approaches are already expanding what it is possible to automate across a number of industries.

Video Transcript

VARUN GANAPATHI: Hello. I'm Varun Ganapathi, co-founder and CTO at AKASA. I'm going to talk to you today about how AI and human-in-the-loop approaches are expanding the capabilities of automation.

Hi. I'm Varun Ganapathi, co-founder and CTO at AKASA. I'm going to talk to you today about how AI and human-in-the-loop approaches are expanding the capabilities of automation.

The dream of automation is that you can tell a robot or a computer, do what I mean, and deal properly with anything that comes up while you're doing it, and it will do the right thing. In this short vignette, Mickey is telling a broom, clean the house. And unfortunately, things don't go as planned.

And that's the problem with automation. The reality is that things can go very wrong when unexpected things are encountered. I'm going to talk today about, how do we actually prevent that from happening? How do we make automation work as well as we actually wish that it could work?

So first, let's talk about a technology called Robotic Process Automation, or RPA. RPA is often proposed as a method of automating tons of tasks that people need to get done. And the basic approach to RPA is essentially to build a robot for each problem or path that you want to solve.

A human, or consultant, or engineer builds a robot to solve a specific problem. And essentially, that solution takes the place of, essentially, a sequence of steps that occur, the robot does. It looks at a screen, takes an action, repeats.

The problem that can often occur is that a change in the world, such as some sort of modification to a piece of software or anything like that, can cause these bots to completely break. So RPA robots often break in any sort of dynamic environment. And the solution often proposed is just don't change anything. Let it be exactly static.

But that's not often the world we live in. We can't actually just wait for-- you know, wait indefinitely to update our software. We need to keep changing things.

The other problem with these robots is that you need to create one for every problem that you want to solve. You essentially end up with a ton of robots all doing very menial little actions. And it's like a game of whack-a-mole. Every day, one of them is probably going to break because one piece of software is going to change, or something unusual is going to happen-- a dialog box is going to pop up, or a new sort of input is going to occur.

And so you have very expensive maintenance resources in order to keep these bots running. That's why Forrester Research says, for every dollar spent on RPA, an additional $3.41 is actually spent on consulting resources. In other words, the actual software for RPA is not the majority of the cost. Actually, it's all of the work that you have to do to keep it running all the time.

What we want to do is come up with a way to solve this problem. How do we actually automate things at scale without everything breaking all the time? And in addition, how do we expand automation to handle much more complex tasks that are currently too difficult to do?

Before I talk about that, I'm going to introduce something from the past of machine learning-- how machine learning used to work. In the old days-- you know, back in the '90s-- AI used to use-- be built using expert systems. An expert system is essentially a sequence of rules that are programmed by a person, or an expert, that tells a computer what to do in every situation. On the right side, I have a screenshot of an example expert system where the goal is to make $20.

And the problem with these expert systems is that you have to manually write in all of the different rules for all the different situations you want to handle. Essentially, you have what's called the knowledge acquisition problem. And the problem with that is, of course, that handling each situation, you need to actually write up a rule to handle that situation. And if anything changes, it all breaks.

And hopefully, this sounds familiar. Traditional RPA is essentially a highly simplified expert system. And these expert systems have had tons of difficulty solving lots of problems that we take for granted today that machine learning has solved, for instance, computer vision, speech recognition, natural language understanding, OCR-- optical character recognition-- and so on, even solving that CAPTCHA on the lower left. None of these applications can be solved with an expert system, or it's extremely difficult, perhaps impossible.

So we've tried to do this before. We've tried to automate things before using expert systems, and it ultimately failed. And so what can we do to learn from that, and not repeat those mistakes, and actually build automation today that takes advantage of those learnings over the years?

So the first solution to this problem is, split your tasks into easy and hard parts. You handle the easy parts using expert systems, or RPA, and you handle the hard parts with humans. So this is what COBOTS are. They're essentially collaborative robots.

And what I'm showing you here is an example in the physical world. I believe this is an Amazon warehouse. And these are Kiva robots, which are basically little, small robots that will pick up shelves and move them to people. And what they're doing here is essentially splitting the work into two pieces.

Part of the work is going and finding the item on the shelf where it is, and the other part of the work is grabbing the item and putting it into the box. And so, essentially, what we're doing is separating the work into pieces that humans can do really well and robots can do really well and handing them off between each other. And that's one way to solve the problem-- you essentially split it into two pieces.

But what if we could automate even the part that we consider too hard to do with an expert system, with RPA? What if we could actually replace that part as well? And that's what machine learning can do. So machine learning will enable us to automate the hard stuff.

Here are some examples of machine learning problems that have been solved recently, or have been close to solved, or great progress has been made. So in any machine learning task, the goal is to predict an output given an input. And in the case of automation, the output is some sort of action that you want to take, and the input is the screen or the world that you're looking at right now. And you follow step by step-- you look at the screen, you take it, you predict what you should do next, you take that action, and you repeat that. And that's how machine learning can be applied to automation.

Here are three examples. So skin cancer detection-- the goal is, take an image of a mole, and tell us whether it's cancerous or not. And machine learning is now currently state of the art. And it's something that no one could ever program by hand.

The game of Go-- an algorithm essentially will take moves on a Go game. And no one was ever able to build an algorithm by hand that was as good as the best humans. And now machine learning has enabled us to build-- to do that, to essentially beat the best Go players in the world using machine learning.

In self-driving cars, the same thing is happening. We need to figure out how to automate the action of driving. And it's a really tough problem. People have tried to hard code this, and it just doesn't work. There are too many exceptional things that can occur along the way. And so we need to use machine learning to help solve these problems.

What can happen in all of these cases, and with automation in general, is the problem is that of an outlier-- something unusual happens that breaks what we expect to occur, and it causes everything to not work anymore. So how can we actually leverage outliers to make our automation stronger? Rather than failing when an outlier occurs, how do we actually become better?

And so I'm turning to an example from the natural world of a system that actually does get better over time, with every single outlier that it encounters. It's called the immune system, and it learns from every pathogen it has ever defeated, generally becoming stronger through exposure. The right side is a simple schematic of how the immune system works.

But essentially, what it does is detect an intruder and then learn to build antibodies against that pathogen. And so over time, every time an unusual situa-- an unusual pathogen occurs, the system will learn to essentially protect itself against that new pathogen and never had that problem occur again.

I want to take these ideas and apply them to automation itself. So let's build an immune system for automation. An ML immune system will treat domain drift and edge cases as pathogens. So the pieces are, how do we actually detect an intruder or a pathogen? And in this case, our solution is very simple. We sample 2% to 5% of examples. And you can, of course, choose the exact percentage you want to sample. But you sample a percentage of cases, and you always check with humans what the algorithm is doing.

The other way you can sample cases is by thresholding the confidence on every example to make sure that when the algorithm isn't sure about what it should do, it actually goes to a human instead. The humans label those examples, and they identify cases not handled by the current model. If every time a human labels an example, the AI got it right already, that's great. Everything's working perfectly.

But for every example where a human catches a problem, that's a case that the machine is obviously not handling properly. And so what we should do is add that data, that new example, to our data set and then retrain the machine learning models to handle that new situation. And now, over time, the machine learning model is essentially building up resistance, essentially, to these new edge cases.

And so you continuously have a system that's always robust to new outliers or exceptions that are occurring and actually getting stronger with time. Every single one of those cases makes the model able to handle that case in the future. And so automation can get better and better, and the amount of human intervention will go down over time.

Let me use a concrete example to explain what I mean by high and low confidence. So one task that AKASA solves involves reading insurance cards. And on the left side is a really easy insurance card. Our machine learning models can extract all of the information from this insurance card very quickly and easily and correctly.

On the right-- and this is a fake example. I just took the insurance card on the left, and flipped it around, and made some color modifications. But you can imagine similar things, where insurance cards are photocopied, maybe there is writing all over them, and so on. And this example would be very low confidence. It looks very unusual compared to all of the examples in the training set.

And so rather than just trusting what the algorithm outputs in this case, we threshold the confidence, and we send it to a human being. The human will then label the data. And then the algorithm can proceed using that human output. So essentially, we have a human in the loop correcting and handling all of the edge cases for the algorithm.

So essentially, this is an intermediate state between COBOTS, where every single hard task is going to a person, and full automation, where automation is attempting, perhaps incorrectly, to do everything by itself. We're basically getting the best of both worlds. We can handle really hard cases, but we are still automating things at a very high rate.

There are a lot of real-world examples where this is being used. I'm going to talk about a few of them right now. The first example is the self-driving car.

In self-driving cars human drivers will operate the cars that are instrumented with tons of sensors-- lidar, microphones, normal cameras, and so on. And they record all of the surroundings and actions performed by the drivers. This creates a large data set of everything that the car has ever seen in the real world from all directions.

People then go and label that data-- identify cars, pedestrians, traffic signs, lane markers-- all of the things that a person, when looking outside, just sees instantaneously. That labeling drives machine learning algorithms. The machine learning networks are trained-- neural networks are trained to essentially identify all of those items in the screen.

After learning to identify all of those obstacles, the car can then learn to drive by itself. Essentially, it can find all of these items and avoid them if necessary or figure out what to do-- navigate a new path, and so on.

No matter how good these models are, there always will be exceptions still. There always will be something unusual that can occur that we've never seen before. And we need to be able to solve that problem. We need to make sure the car doesn't just fail or crash when that happens.

And so California had a rule that you can have driverless testing, but only if the cars can be operated remotely. When something really unusual occurs, a human being can take over. Assuming the car detects it, a human being can be pulled in virtually over the network to essentially drive the car.

One problem, of course, with the self-driving car is that remote access to the car could be difficult. You know, there could be a network failure, and so on. But with normal automation, like the type we're doing on a computer, we don't have to worry about those problems. We can pause the world and wait for a person to come help the algorithm and make sure it operates properly. And in practice, this is what very successful automation endeavors do.

Here's another example of human-in-the-loop. Amazon AWS Textract is an ML service that uses AI to automatically detect and extract text, handwriting, tables, forms, and data from scanned documents. What the service does is use deep learning to automatically convert all sorts of documents into structured forms that we can process with algorithms.

They use human-in-the-loop by thresholding examples based on confidence or random selection and sending them to people, as I talked about before. When these examples are selected to be looked at by people, you get better results essentially because those examples are now going to be labeled correctly. And this data can then be used to retrain the algorithms so that they perform better.

Another example is Pilot. Pilot provides bookkeeping services for startups and small businesses, leveraging AI and machine learning. What the service does is use AI and humans to essentially offer bookkeeping as a service. This is so startups can focus on their normal work instead of focusing on bookkeeping. And they use AI strategically in order to flag unusual situations or to automate standard situations and send unusual cases to humans, as per usual. The humans label the data, and the AI can become better.

We at AKASA do the same thing. Our mission at AKASA is to build a brighter future for health care using artificial intelligence. We call this human-in-the-loop methodology Unified Automation. We believe wherever money or life is on the line, you have to couple AI with the human touch in order to make sure that you're doing everything correctly.

The types of things we automate are everything involving bureaucratic work in health care-- filing claims, appealing claims, and so on. And so we use the approach that I described earlier in order to solve these difficult automation problems.

The way we use human-in-the-loop is we first observe how people perform the work, we train our automation to emulate people and perform the work the same way, and we pull out the hardest parts of the work that require human decision making and make sure those are sent to people. In doing that, we're collecting label data that trains the algorithms in how to perform those tasks completely automatically.

And then finally, we are able to replace a lot of that work with machine learning entirely. So what was originally fully done by people is now done almost completely by computer. But still, we make sure that outliers and edge cases are constantly handled. And we also make sure that we have quality control. Because we're always randomly sampling cases, we can make sure on a daily basis that everything is performing correctly, or even hourly basis.

So our systems-- we've built a lot of machine learning algorithms to enable us to do this. And we publish our work at conferences like International Conference on Machine Learning, the NLP Summit, and the Machine Learning for Healthcare Conference. And it's really enabled us to bring automation to an area that's been traditionally very difficult to automate.

I want to close out with a few last words. First, we're hiring at AKASA, so please visit this website, akasa.com/careers, for more information. And I want to thank you for your time today. And I wish you the best of luck with your automation endeavors. Thanks.