Learn Machine Learning in a way that is accessible to absolute beginners. You will learn the basics of Machine Learning and how to use TensorFlow to implement many different concepts.

✏️ Kylie Ying developed this course. Check out her channel: https://www.youtube.com/c/YCubed

⭐️ Code and Resources ⭐️
🔗 Supervised learning (classification/MAGIC): https://colab.research.google.com/drive/16w3TDn_tAku17mum98EWTmjaLHAJcsk0?usp=sharing
🔗 Supervised learning (regression/bikes): https://colab.research.google.com/drive/1m3oQ9b0oYOT-DXEy0JCdgWPLGllHMb4V?usp=sharing
🔗 Unsupervised learning (seeds): https://colab.research.google.com/drive/1zw_6ZnFPCCh6mWDAd_VBMZB4VkC3ys2q?usp=sharing
🔗 Dataets (add a note that for the bikes dataset, they may have to open the downloaded csv file and remove special characters)
🔗 MAGIC dataset: https://archive.ics.uci.edu/ml/datasets/MAGIC+Gamma+Telescope
🔗 Bikes dataset: https://archive.ics.uci.edu/ml/datasets/Seoul+Bike+Sharing+Demand
🔗 Seeds/wheat dataset: https://archive.ics.uci.edu/ml/datasets/seeds

🏗 Google provided a grant to make this course possible. 

⭐️ Contents ⭐️
⌨️ (0:00:00) Intro
⌨️ (0:00:58) Data/Colab Intro
⌨️ (0:08:45) Intro to Machine Learning
⌨️ (0:12:26) Features
⌨️ (0:17:23) Classification/Regression
⌨️ (0:19:57) Training Model
⌨️ (0:30:57) Preparing Data
⌨️ (0:44:43) K-Nearest Neighbors
⌨️ (0:52:42) KNN Implementation
⌨️ (1:08:43) Naive Bayes
⌨️ (1:17:30) Naive Bayes Implementation
⌨️ (1:19:22) Logistic Regression
⌨️ (1:27:56) Log Regression Implementation
⌨️ (1:29:13) Support Vector Machine
⌨️ (1:37:54) SVM Implementation
⌨️ (1:39:44) Neural Networks
⌨️ (1:47:57) Tensorflow
⌨️ (1:49:50) Classification NN using Tensorflow
⌨️ (2:10:12) Linear Regression
⌨️ (2:34:54) Lin Regression Implementation
⌨️ (2:57:44) Lin Regression using a Neuron
⌨️ (3:00:15) Regression NN using Tensorflow
⌨️ (3:13:13) K-Means Clustering
⌨️ (3:23:46) Principal Component Analysis
⌨️ (3:33:54) K-Means and PCA Implementations

🎉 Thanks to our Champion and Sponsor supporters:
👾 Raymond Odero
👾 Agustín Kussrow
👾 aldo ferretti
👾 Otis Morgan
👾 DeezMaster

--

Learn to code for free and get a developer job: https://www.freecodecamp.org

Read hundreds of articles on programming: https://freecodecamp.org/news

Kylie Ying has worked at many interesting places, such as MIT, CERN, and free code camp.

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.

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.

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 1 called the magic gamma telescope data set.

So in this data set, if you don't 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 a 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 04 data, and we're going to download that.

Now over here, I have a collab notebook open.

So you go to collab dot research.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 code camp magic example.

So with that, I'm going to first start with some imports.

So I will import, you know, I always import NumPy.

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.

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

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.

So it doesn't seem like we have the label.

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.

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 1, we have F symmetry, FM3 long, FM3 trans, F alpha, what else do we have f dist and class?

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 is comma 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 5 things.

Now you'll see that we have labels for all of these.

So 1 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 0 for G and 1 for each.

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 that would be 0, but I'm just converting g and h to 1 and 0, it doesn't really matter, like, if g is 1 and h is 0, 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 1 sample, it's 1 example, it's 1 item in our data set, it's 1 data point, all these things are kind of the same thing when I mentioned, oh, this is 1 example, or this is 1 sample, or whatever.

Now, each of these samples, they have, you know, 1 quality for each or 1 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 0, 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.

Alright, so before I move on, let me just give you a quick little crash course on what I just said.

Well, the first question is, what is machine learning?

Well, machine learning is a subdomain 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.

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 1 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.

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.

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's not gonna 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.

We can train our dog, but there's not necessarily 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.

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 1 example of a qualitative feature might be gender.

I know this might be a little bit outdated.

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 1 and France to Japan, 3, etc, right, there's not really any inherent order built into either of these categorical data sets.

Now, for nominal data, the way that we want to feed it into our computer is using something called 1 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 1 hot encoding.

And basically 1 hot encoding is saying, Okay, well, if it matches some category, make that a 1.

So for example, if your input were from the US, you might have 1000 India, you know, 0100 Canada, okay, well, the item representing Canada is 1 and then France, the item representing France is 1.

And then you can see that the rest are zeros.

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.

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.

Like, being a toddler is a lot closer to being a baby than being an elderly person.

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, 1 to 5, 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 than good is close to not good at all.

Well, 4 is closer to 5 and 4 is close to 1.

And it'll make sense for the computer as well.

All right, 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.

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 1 classification, and basically classification just saying, okay, predict discrete classes.

And that might mean, you know, this is a hot dog.

Okay, so there are 3 distinct classes and any other pictures of hot dogs, pizza or ice cream, I can put under these labels.

This is something known as multi class classification.

And binary classification, you might have hot dog, or not hot dog.

So there's only 2 categories that you're working with something that is something and something that's isn't binary classification.

So if something has positive or negative sentiment, that's binary classification.

Maybe you're predicting your pictures of their cats or dogs.

Maybe you know, you are writing an email filter, and you're trying to figure out if an email spam or not spam.

Now for multi-class classification you might have you know cat, dog, lizard, dolphin, shark, rabbit, etc.

We might have different types of fruits like orange, apple, pear, etc.

But multi class classification just means more than 2.

Okay, and binary means we're predicting between 2 things.

There's also something called regression when we talk about supervised learning.

And this just means we're trying to predict continuous values.

So instead of just trying to predict different categories, we're trying to come up with a number that is on some sort of scale.

So some examples might be the price of aetherium tomorrow.

Or it might be okay, what is going to be the temperature?

Or it might be what is the price of this house, right?

So these things don't really fit into discrete classes.

We're trying to predict a number that's as close to the true value as possible using different features of our data set.

So that's exactly what our model looks like in supervised learning.

Or how can we tell whether or not it's even learning.

So before we talk about the models, let's talk about how can we actually like evaluate these models?

Or how can we tell whether something is a good model or a bad model?

So this data set has, this is from a diabetes, a Pima Indian diabetes data set.

And here we have different number of pregnancies, different glucose levels, blood pressure, skin thickness, insulin, BMI, age, and then the outcome, whether or not they have diabetes.

So here, all of these are quantitative features, right, because they're all on some scale.

So each row is a different sample in the data.

It's 1 person's data, and each row represents 1 person in this data set.

Now this column, each column represents a different feature.

So this 1 here is some measure of blood pressure levels and this 1 over here as we mentioned is the output label.

So this 1 is whether or not they have diabetes and as I mentioned this is what we would call a feature vector, because these are all of our features in 1 sample.

And this is what's known as the target, or the output for that feature vector, that's what we're trying to predict.

And all of these together is our features matrix x.

And over here, this is our labels or targets vector y.

So I've condensed this to a chocolate bar to kind of talk about some of the other concepts in machine learning.

So over here, we have our x, our features matrix.

So each row of this will be fed into our model, right?

And our model will make some sort of prediction.

And what we do is we compare that prediction to the actual value of why that we have in our label data set, because that's the whole point of supervised learning is we can compare what our models outputting to Oh, what is the truth actually, and then we can go back and we can adjust some things.

So the next iteration, we get closer to what the true value is.

So that whole process here, the tinkering that, okay, what's the difference?

That's what's known as training the model.

Alright, so take this whole, you know, chunk right here, do we want to really put our entire chocolate bar into the model to train our model?

Because if we did that, then how do we know that our model can do well on new data that we haven't seen?

Like if I were to create a model to predict whether or not someone has diabetes, let's say that I just train all my data, and I see that all my training data does well, I go to some hospital, I'm like, here's my model, I think you can use this to predict if somebody has diabetes.

Do we think that would be effective or not?

Because we haven't assessed how well our model can generalize.

Okay, it might do well after you know, our model has seen this data over and over and over again.

Well, how do we how do we get our model to assess that?

So we actually break up our whole data set that we have into 3 different types of data sets, we call it the training data set, the validation data set, and the testing data set.

And you know, you might have 60% here 20% and 20%, or 80, 10, and 10.

It really depends on how many statistics you have, I think either of those would be acceptable.

So what we do is then we feed the training data set into our model, we come up with, you know, this might be a vector of predictions corresponding with each sample that we put into our model, we figure out, okay, what's the difference between our prediction and the true values, this is something known as loss, losses, you know, what's the difference here, in some numerical quantity, of course.

So then, once you know, we've made a bunch of adjustments, we can put our validation set through this model.

And the validation set is kind of used as a reality check during or after training to ensure that the model can handle unseen data still.

So every single time after we train 1 iteration, we might stick the validation set in and see, hey, what's the loss there.

And then after our trainings over, we can assess the validation set and ask, hey, what's the loss there.

But 1 key difference here is that we don't have that training step, this loss never gets fed back into the model, right, that feedback loop is not closed.

Alright, so let's talk about loss really quickly.

So here I have 4 different types of models, I have some sort of data that's being fed into the model, and then some output.

Okay, so this output here is pretty far from you know, this truth that we want.

See all freeCodeCamp.org transcripts on Youtube

Machine Learning for Everybody – Full Course