She's a physicist, engineer, and basically a genius. And now she's going to teach you

about machine learning in a way that is accessible to absolute beginners.

What's up you guys? So welcome to Machine Learning for Everyone. If you are someone who

is interested in machine learning and you think you are considered as everyone, then this video

is for you. In this video, we'll talk about supervised and unsupervised learning models,

we'll go through maybe a little bit of the logic or math behind them, and then we'll also see how

we can program it on Google CoLab. If there are certain things that I have done, and you know,

you're somebody with more experience than me, please feel free to correct me in the comments

and we can all as a community learn from this together. So with that, let's just dive right in.

Without wasting any time, let's just dive straight into the code and I will be teaching you guys

concepts as we go. So this here is the UCI machine learning repository. And basically,

they just have a ton of data sets that we can access. And I found this really cool one called

the magic gamma telescope data set. So in this data set, if you want to read all this information,

to summarize what I what I think is going on, is there's this gamma telescope, and we have all

these high energy particles hitting the telescope. Now there's a camera, there's a detector that

actually records certain patterns of you know, how this light hits the camera. And we can use

properties of those patterns in order to predict what type of particle caused that radiation. So

whether it was a gamma particle, or some other head, like hadron. Down here, these are all of

the attributes of those patterns that we collect in the camera. So you can see that there's, you

know, some length, width, size, asymmetry, etc. Now we're going to use all these properties to

help us discriminate the patterns and whether or not they came from a gamma particle or hadron.

So in order to do this, we're going to come up here, go to the data folder. And you're going

to click this magic zero for data, and we're going to download that. Now over here, I have a colab

notebook open. So you go to colab dot research dot google.com, you start a new notebook. And

I'm just going to call this the magic data set. So actually, I'm going to call this for code camp

magic example. Okay. So with that, I'm going to first start with some imports. So I will import,

you know, I always import NumPy, I always import pandas. And I always import matplotlib.

And then we'll import other things as we go. So yeah,

we run that in order to run the cell, you can either click this play button here, or you can

on my computer, it's just shift enter and that that will run the cell. And here, I'm just going

to order I'm just going to, you know, let you guys know, okay, this is where I found the data set.

So I've copied and pasted this actually, but this is just where I found the data set.

And in order to import that downloaded file that we we got from the computer, we're going to go

over here to this folder thing. And I am literally just going to drag and drop that file into here.

Okay. So in order to take a look at, you know, what does this file consist of,

do we have the labels? Do we not? I mean, we could open it on our computer, but we can also just do

pandas read CSV. And we can pass in the name of this file.

And let's see what it returns. So it doesn't seem like we have the label. So let's go back to here.

I'm just going to make the columns, the column labels, all of these attribute names over here.

So I'm just going to take these values and make that the column names.

All right, how do I do that? So basically, I will come back here, and I will create a list called

calls. And I will type in all of those things. With f size, f conk. And we also have f conk one.

We have f symmetry, f m three long, f m three trans, f alpha. Let's see, we have f dist and class.

Okay, great. Now in order to label those as these columns down here in our data frame.

So basically, this command here just reads some CSV file that you pass in CSV has come about comma

separated values, and turns that into a pandas data frame object. So now if I pass in a names here,

then it basically assigns these labels to the columns of this data set. So I'm going to set

this data frame equal to DF. And then if we call the head is just like, give me the first five things,

give me the first five things. Now you'll see that we have labels for all of these. Okay.

All right, great. So one thing that you might notice is that over here, the class labels,

we have G and H. So if I actually go down here, and I do data frame class unique,

you'll see that I have either G's or H's, and these stand for gammas or hadrons.

And our computer is not so good at understanding letters, right? Our computer is really good at

understanding numbers. So what we're going to do is we're going to convert this to zero for G and

one for H. So here, I'm going to set this equal to this, whether or not that equals G. And then

I'm just going to say as type int. So what this should do is convert this entire column,

if it equals G, then this is true. So I guess that would be one. And then if it's H, it would

be false. So that would be zero, but I'm just converting G and H to one and zero, it doesn't

really matter. Like, if G is one and H is zero or vice versa. Let me just take a step back right

now and talk about this data set. So here I have some data frame, and I have all of these different

values for each entry. Now this is a you know, each of these is one sample, it's one example,

it's one item in our data set, it's one data point, all of these things are kind of the same

thing when I mentioned, oh, this is one example, or this is one sample or whatever. Now, each of

these samples, they have, you know, one quality for each or one value for each of these labels

up here, and then it has the class. Now what we're going to do in this specific example is try to

predict for future, you know, samples, whether the class is G for gamma or H for hadron. And

that is something known as classification. Now, all of these up here, these are known as our features,

and features are just things that we're going to pass into our model in order to help us predict

the label, which in this case is the class column. So for you know, sample zero, I have

10 different features. So I have 10 different values that I can pass into some model.

And I can spit out, you know, the class the label, and I know the true label here is G. So this is

this is actually supervised learning. All right. So before I move on, let me just give you a quick

little crash course on what I just said. This is machine learning for everyone. Well, the first

question is, what is machine learning? Well, machine learning is a sub domain of computer science

that focuses on certain algorithms, which might help a computer learn from data, without a

programmer being there telling the computer exactly what to do. That's what we call explicit

programming. So you might have heard of AI and ML and data science, what is the difference between

all of these. So AI is artificial intelligence. And that's an area of computer science, where the

goal is to enable computers and machines to perform human like tasks and simulate human behavior.

Now machine learning is a subset of AI that tries to solve one specific problem and make predictions

using certain data. And data science is a field that attempts to find patterns and draw insights

from data. And that might mean we're using machine learning. So all of these fields kind of overlap,

and all of them might use machine learning. So there are a few types of machine learning.

The first one is supervised learning. And in supervised learning, we're using labeled inputs.

So this means whatever input we get, we have a corresponding output label, in order to train

models and to learn outputs of different new inputs that we might feed our model. So for example,

I might have these pictures, okay, to a computer, all these pictures are are pixels, they're pixels

with a certain color. Now in supervised learning, all of these inputs have a label associated with

them, this is the output that we might want the computer to be able to predict. So for example,

over here, this picture is a cat, this picture is a dog, and this picture is a lizard.

Now there's also unsupervised learning. And in unsupervised learning, we use unlabeled data

to learn about patterns in the data. So here are here are my input data points. Again, they're just

images, they're just pixels. Well, okay, let's say I have a bunch of these different pictures.

And what I can do is I can feed all these to my computer. And I might not, you know,

my computer is not going to be able to say, Oh, this is a cat, dog and lizard in terms of,

you know, the output. But it might be able to cluster all these pictures, it might say,

Hey, all of these have something in common. All of these have something in common. And then these

down here have something in common, that's finding some sort of structure in our unlabeled data.

And finally, we have reinforcement learning. And reinforcement learning. Well, they usually

there's an agent that is learning in some sort of interactive environment, based on rewards and

penalties. So let's think of a dog, we can train our dog, but there's not necessarily, you know,

any wrong or right output at any given moment, right? Well, let's pretend that dog is a computer.

Essentially, what we're doing is we're giving rewards to our computer, and tell your computer,

Hey, this is probably something good that you want to keep doing. Well, computer agent terminology.

But in this class today, we'll be focusing on supervised learning and unsupervised learning

and learning different models for each of those. Alright, so let's talk about supervised learning

first. So this is kind of what a machine learning model looks like you have a bunch of inputs

that are going into some model. And then the model is spitting out an output, which is our prediction.

So all these inputs, this is what we call the feature vector. Now there are different types

of features that we can have, we might have qualitative features. And qualitative means

categorical data, there's either a finite number of categories or groups. So one example of a

qualitative feature might be gender. And in this case, there's only two here, it's for the sake of

the example, I know this might be a little bit outdated. Here we have a girl and a boy, there are

two genders, there are two different categories. That's a piece of qualitative data. Another

example might be okay, we have, you know, a bunch of different nationalities, maybe a nationality or

a nation or a location, that might also be an example of categorical data. Now, in both of

these, there's no inherent order. It's not like, you know, we can rate us one and France to Japan

three, etc. Right? There's not really any inherent order built into either of these categorical

data sets. That's why we call this nominal data. Now, for nominal data, the way that we want

to feed it into our computer is using something called one hot encoding. So let's say that, you

know, I have a data set, some of the items in our data, some of the inputs might be from the US,

some might be from India, then Canada, then France. Now, how do we get our computer to recognize that

we have to do something called one hot encoding. And basically, one hot encoding is saying, okay,

well, if it matches some category, make that a one. And if it doesn't just make that a zero.

So for example, if your input were from the US, you would you might have 1000. India, you know,

0100. Canada, okay, well, the item representing Canada is one and then France, the item representing

France is one. And then you can see that the rest are zeros, that's one hot encoding.

Now, there are also a different type of qualitative feature. So here on the left,

there are different age groups, there's babies, toddlers, teenagers, young adults,

adults, and so on, right. And on the right hand side, we might have different ratings. So maybe

bad, not so good, mediocre, good, and then like, great. Now, these are known as ordinal pieces of

data, because they have some sort of inherent order, right? Like, being a toddler is a lot closer to

being a baby than being an elderly person, right? Or good is closer to great than it is to really

bad. So these have some sort of inherent ordering system. And so for these types of data sets,

we can actually just mark them from, you know, one to five, or we can just say, hey, for each of these,

let's give it a number. And this makes sense. Because, like, for example, the thing that I

just said, how good is closer to great, then good is close to not good at all. Well, four is closer

to five, then four is close to one. So this actually kind of makes sense. And it'll make sense for the

computer as well. Alright, there are also quantitative pieces of data and quantitative

pieces of data are numerical valued pieces of data. So this could be discrete, which means,

you know, they might be integers, or it could be continuous, which means all real numbers.

So for example, the length of something is a quantitative piece of data, it's a quantitative

feature, the temperature of something is a quantitative feature. And then maybe how many

Easter eggs I collected in my basket, this Easter egg hunt, that is an example of discrete quantitative

feature. Okay, so these are continuous. And this over here is the screen. So those are the things

that go into our feature vector, those are our features that we're feeding this model, because

our computers are really, really good at understanding math, right at understanding numbers,

they're not so good at understanding things that humans might be able to understand.

Well, what are the types of predictions that our model can output? So in supervised learning,

there are some different tasks, there's one classification, and basically classification,

just saying, okay, predict discrete classes. And that might mean, you know, this is a hot dog,

this is a pizza, and this is ice cream. Okay, so there are three distinct classes and any other

pictures of hot dogs, pizza or ice cream, I can put under these labels. Hot dog, pizza, ice cream.

Hot dog, pizza, ice cream. This is something known as multi class classification. But there's also

binary classification. And binary classification, you might have hot dog, or not hot dog. So there's