The-Hello-World-of-Machine-Learning

Machine learning is simply a computer learning from data instead of following a recipe. It's meant to mimic how people (and perhaps other animals) learn while still being grounded in mathematics.

This post is meant to get you started with a basic machine learning model.

A chatbot.

Now, we're not re-creating Alexa, Siri, Cortana, or Google Assistant but we are going to create a brand new machine learning program from scratch.

This tutorial is meant to be easy assuming you know a bit of Python Programming.

Watch the entire series that corresponds to this post.

Step 1: What's our data?

Machine learning needs data to actually, well, learn. Machines don't yet learn like you and I do but they do learn by finding patterns in things that may seem non-obvious to you and I. We'll see a lot of that in this entire post.

Before we define our data, let's talk about the goal of this ML (machine learning) project:

To answer somewhat "random" questions with pre-defined responses.

Here's what we'll try and solve:

Scenario 1

Bill: Hi there, what time do you open tomorrow for lunch?

Bot: Our hours are 9am-10pm everyday.

Scenario 2

Karen: Can I speak to your manager?

Bot: You can contact our customer support at 555-555-555.5

Scenario 3

Wade: What type of products do you have?

Bot: We carry various food items including tacos, nachos, burritos, and salads.

Let's put this into a python format:

conversations = [
    {
        "customer": "Hi there, what time do you open tomorrow for lunch?",
        "response": "Our hours are 9am-10pm everday."
    },
     {
        "customer": "Can I speak to your manager?",
        "response": "You can contact our customer support at 555-555-5555."
    },
     {
        "customer": "What type of products do you have?",
        "response": "We carry various food items including tacos, nachos, burritos, and salads."
    }  
    
]

Without machine learning our bot would look like this (uncomment next cell to run):

# while True:
#     my_input = input("What is your question?\n")
#     response = None
#     for convo in conversations:
#         if convo['customer'] == my_input:
#             response = convo['response']
#     if response != None:
#         print(response)
#         break
#     print("I don't know")
#     continue

Right away, you should see the huge flaws in this recipe; if a customer doesn't ask a question in a specific pre-defined way, the bot fails and ultimately really sucks.

A few examples: - What if a customer says, when do you open? What do you already know the response to be? - What if a customer says, Do you sell burgers? - What if a customer says, How do I reach you on the phone?

I'm sure you could come up with many many more examples of where this really falls apart.

So let's clean up our conversations data a bit more by adding tags that describe the initial question.

convos_one = [
    {
        "customer": "Hi there, what time do you open tomorrow for lunch?",
        "tags": ["opening", "closing", "hours"],
    },
     {
        "customer": "Can I speak to your manager?",
        "tags": ["customer_support"],
    },
    {
        "customer": "The food was amazing thank you!",
        "tags": ["customer_support", "feedback"],
    },
     {
      "customer": "What type of products do you have?",
       "tags": ["products", "menu", "inventory", "food"],
    }  
    
]

convos_two = [
    {
        "customer": "How late is your kitchen open?",
        "tags": ["opening", "hours", "closing"],
    },
     {
        "customer": "My order was prepared incorrectly, how can I get this fixed?",
        "tags": ["customer_support"],
    },
    {
        "customer": "What kind of meats do you have?",
        "tags": ["menu", "products", "inventory", "food"],
    }
]

convos_three = [
    {
        "customer": "When does your dining room open?",
        "tags": ['opening', 'hours'],
    },
     {
        "customer": "When do you open for dinner?",
        "tags": ['opening', 'hours', "closing"],
    },
    {
        "customer": "How do I contact you?",
        "tags": ["contact", "customer_support"]
    }
]

Do you see a trend happening here? It's really easy to come up with all kinds of questions for a restaurant bot. It's also easy to see how challenging this would be to try and hard-code conditions to handle all the kinds of queries/questions customers could have.

I'm sure you've heard you need a LOT of data for machine learning. I'll just add one thing to that, you need a lot of data to have awe-inspiring machine learning projects. A simple bot for a mom-and-pop store down the street doesn't need awe-inspiring just yet. They need simple, approachable, easy to explain. That's exactly what this is. It's not a black box of millions of lines of data points. It's like 20 questions with made up on the spot tags.

In so many ways, machine learning today (in the 2020s) is like the internet of the 1990s. People have heard about it and "sort of get it" and feel like it's just this magical gimmick that only super nerds know how to do. Ha. Super nerds.

Now that we have our starting data, let's prepare for machine learning.

First, let's combine all conversations:

dataset = convos_one + convos_two + convos_three
dataset

[{'customer': 'Hi there, what time do you open tomorrow for lunch?',
  'tags': ['opening', 'closing', 'hours']},
 {'customer': 'Can I speak to your manager?', 'tags': ['customer_support']},
 {'customer': 'The food was amazing thank you!',
  'tags': ['customer_support', 'feedback']},
 {'customer': 'What type of products do you have?',
  'tags': ['products', 'menu', 'inventory', 'food']},
 {'customer': 'How late is your kitchen open?',
  'tags': ['opening', 'hours', 'closing']},
 {'customer': 'My order was prepared incorrectly, how can I get this fixed?',
  'tags': ['customer_support']},
 {'customer': 'What kind of meats do you have?',
  'tags': ['menu', 'products', 'inventory', 'food']},
 {'customer': 'When does your dining room open?',
  'tags': ['opening', 'hours']},
 {'customer': 'When do you open for dinner?',
  'tags': ['opening', 'hours', 'closing']},
 {'customer': 'How do I contact you?',
  'tags': ['contact', 'customer_support']}]

Our conversations have the keys customer and tags. These are arbitrary names for this project and you change change them at-will. Just remember that customer equals input and tags equals output. This makes sense because in the future, we want a random customer input such as What's the menu specials today and a predicted tags output like menu or something similar.

Machine learning has all kinds of terms and acronyms that often make it a bit confusing. In general, just remember that you have some inputs and some target outputs. Here's what I mean by that:

• customer: These values are really the input values for our ML project. Input values are sometimes called source, feature, training, X, X_train/X_test/X_valid, and a few others.
• tags: These values are really the output values for our ML project. Output values are sometimes called target, labels, y, y_train/y_test/y_valid, classes/class, and a few others.

We're using a machine learning technique known as supervised learning which means we provide both the inputs and outputs to the model. Both data points are known data that we came up with. As you know, the tags (or labels/outputs) have been decided by a human (ie you and me) but can, eventually, be decided by a ML model itself and then verified by a human. Doing so would make the model better and better. There are many other techniques but supervised learning is by far the most approachable for beginners.

Prepare for ML

Now that we have our data, it's time to put it into a format that works well for computers. As you may know, computers are great at numbers and not so great at text. In this case, we have to convert our text into numbers.

This is made simple by using the scikit-learn library. So let's install it below by uncommenting the cell.

# !pip install scikit-learn

First up, let's turn our customer and tag data into 2 separate lists where the index of each item corresponds to the index of the other.

X = [customer_convo_1, customer_convo_2, ...]
y = [convo_1_tags, convo_2_tags, ...]

This is very standard practice so that X[0] is the input that corresponds to the y[0] output, X[1] is the input that corresponds to the y[1] output and so on.

inputs = [x['customer'] for x in dataset]
print(inputs)

['Hi there, what time do you open tomorrow for lunch?', 'Can I speak to your manager?', 'The food was amazing thank you!', 'What type of products do you have?', 'How late is your kitchen open?', 'My order was prepared incorrectly, how can I get this fixed?', 'What kind of meats do you have?', 'When does your dining room open?', 'When do you open for dinner?', 'How do I contact you?']

outputs = [x['tags'] for x in dataset]
print(outputs)

[['opening', 'closing', 'hours'], ['customer_support'], ['customer_support', 'feedback'], ['products', 'menu', 'inventory', 'food'], ['opening', 'hours', 'closing'], ['customer_support'], ['menu', 'products', 'inventory', 'food'], ['opening', 'hours'], ['opening', 'hours', 'closing'], ['contact', 'customer_support']]

assert(len(inputs) == len(outputs))

If you have an AssertionError above, that means your inputs and outputs are not balanced. Check your data source(s) to ensure every input has a corresponding output value.

Let's verify the positions of this data to show how little we actually changed the data:

idx = 4
print(inputs[idx], outputs[idx])
print(dataset[idx])

How late is your kitchen open? ['opening', 'hours', 'closing']
{'customer': 'How late is your kitchen open?', 'tags': ['opening', 'hours', 'closing']}

The Prediction Function

The goal of machine learning is to produce a function that takes inputs and produces outputs (predictions). Below is, at a conceptual level, a representation of that:

def my_pred_function(inputs):
    # pred
    outputs = inputs * 0.39013 # this decimal represents what our model will essentially do.
    return outputs

Now we need to turn each inputs list and outputs list into matrices so our machine learning can do machine learning.

scikit-learn has a simple way to do this. First, let's focus on the inputs (aka customer conversations) as they are the most simple.

from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer()

X = vectorizer.fit_transform(inputs)

Technical note: scikit-learn converted our data into a collection of 1 dimension matrices. We need to use matrices so we can do matrix multiplication (that's how machine learning works under the hood). In numpy speak, X is an array of arrays. If you want to see the actual vectors created, check out X.toarray() and you'll see it.

X.shape

(10, 43)

X.shape is useful to describe our data.

X.shape[0] refers to the number of conversations from our final_convos list. So, X.shape[0] == len(final_convos) and X.shape[0] == len(inputs)

X.shape[1] refers to the number of words our data has. The `CountVectoriz