Deep Learning Full Course 2026 | Deep Learning Tutorial for Beginners | Deep Learning | Simplilearn

Key Takeaways

[Music] Hey there, welcome to our deep learning full course by simply learn. Have you ever wondered how Instagram knows exactly which filters you love or how Netflix always suggests that perfect movie for you? That's all because of deep learning. Now deep learning help computers recognize pattern and predict things and understand stuff like images, text and even speech. It's everywhere today and businesses in all sort of fields like e-commerce and healthcare are using it to build smarter system. And here's the exciting part. The demand for deep learning experts is growing fast. Don't worry if this sounds a bit complicated, we are here to explain it step by step. Whether you're just starting out or looking to improve your skills, this video will make deep learning easy and fun to understand. We'll kick things off by explaining what deep learning is and clear up the difference between machine learning, deep learning, and artificial intelligence. Then we'll dive into neural networks and even walk you through a hands-on tutorial using Python and TensorFlow. We'll touch on some basic math, explore recurren neural network and convolutional neural networks, and even show you how to use hugging face. We'll also help you prepare for deep learning interview questions. and by the end you will be ready to jump into the world of deep learning. So let's get started. Before we move on, if you're interested in growing your career in AI and machine learning, this course is a great way to start. The professional certificate in AI and machine learning by simply learn PR University online and IBM will help you master the key skills like chat GPT, LNMS, deep learning and agentic AI through live classes and hands-on project. And in just 6 months, you'll work on real world industry projects using 18 plus popular tools like Python and TensorFlow and earn certificates from Perdu and IBM. You'll also get career support including resume help, mock interviews, and job assistance. So whether you're switching careers or upskilling, this course will give you the latest AI knowledge and practical experience to stay ahead. So what are you waiting for? Hurry up and enroll now and you can find the course link below. Welcome to deep learning tutorial. My name is Richard Kersner with the SimplyLearn team. That's www.simplearn.com. Get certified. Get ahead. What's in it for you? We're going to go over applications of deep learning. What is deep learning? Why is deep learning important? What are neural networks? The activation function in our neural network. The cost function that comes in for processing our neural networks. How do neural networks work? deep learning platforms and then we'll do introduction to TensorFlow and a use case implementation using TensorFlow so you can see how it works and get some hands-on. So start off with the applications of deep learning. Deep learning helps us make predictions about the rain, earthquakes, tsunamis, etc. allowing us to take the required precautions. With deep learning, machines can comprehend speech and provide the required output. Deep learning enables a machine to recognize people and objects in the images fed to it. And with deep learning, advertisers can leverage data to perform realtime bidding and targeted display advertising. And these are just a small sample of the myriad of different uses for deep learning today. So what is deep learning? Deep learning is a sub field of machine learning that deals with algorithms inspired by the structure and function of the brain. And we look at this we have uh the larger category which is artificial intelligence very generic comprehensive um ideal and in there we have machine learning and then a subcategory of machine learning is deep learning. So when we talk about artificial intelligence this is the ability of a machine to imitate intelligent human behavior. So when we look at something can it solve a problem the way humans do? Can we take it to that next level so it's just not repeating some kind of uh simple output that we've programmed it to do? Can it actually start imitating human intelligence? And we look at machine learning. We have the application of AI that allows a system to automatically learn and improve from experience. So machine learning, the most basic machine learning is your linear regression model. You put a bunch of dots on the graph and you draw a line through them and you have a guess of what X and Y are. Based on where what X is, you can guess what Y is. And finally, we have our deep learning application of machine learning that uses complex algorithms and deep neural nets to train a model. Why is deep learning important? It works with unstructured data. Machine learning works only with large sets of structured and semistructured data. While deep learning can work with both structured and unstructured data. Handles complex operations. Deep learning algorithms can perform complex operations easily while machine learning algorithms cannot. Feature extraction. Machine learning algorithms use labeled sample data to extract patterns while deep learning accepts large volumes of data as input. Analyze the input to extract features out of an object. achieve best performance. Performance of machine learning algorithms decreases as the amount of data increases. So to maintain the performance of the model, we need deep learning. And this is always a challenge of when do you go from machine learning doing linear regression or other regression models to deep learning neural networks. It really centers around both uh the complexity as it becomes more and more complex or the problem becomes harder to solve along with the amount of data. So both of those play a huge part in deciding which would best serve your purposes to predict what your data is going to do and try to predict the outcome. So what are neural networks? With deep learning, a machine can be trained to identify various shapes. So here we have a square coming in. You can see we've broken it up into the pixels and we want the label to come out square. And if we turn the square slightly sideways, it's still a square and we want it to still say it's a square. With deep learning, a machine can be trained to identify various shapes or the different patterns of those shapes as they be in this case being rotated. But how is the machine able to do this? So we'll look at a nice grid 28x 28 784 pixels. And we look at that grid, we can look at each one of those pixels as inputs. So a neural network is a system modeled on the human brain. And so we have all our inputs kind of like your eyeball coming in there. It has the sensors in the back, your different input sensors which are your cones and rods. So each one of those is an input coming in with information and it goes into a neuron and then you sends out a pulse. So the data is fed as an input to the neuron. The neuron processes the information provided as an input. The information is transferred over weighted channels and this is very central to our neural network. Each one of those pulses coming in gets a different weight and the output is the final value predicted by the artificial neuron. In this image, we're only looking at one neuron. So remember, we're looking talk about a lot of neurons working together and we'll look at how those fit together in just a moment. When we look at one neuron, so let's just take a look at that one neuron. Let's dig a little deeper so we can get some concepts in here so we can understand the neural network. So what exactly happens within a neuron? We have an activation function. So within each neuron the following operations are performed. The product of each input and the weight of the channel it's passed over is found. Sum of the weighted products is computed. This is called the weighted sum. And a bias unique to the neuron is added to the weighted sum. And you can always look at that as if you have an xy graph where's your yin intercept? You know the old uh uklitian geometry x or y= 3x + 5. That's your plus five is that bias is where does that come in? And this is a little bit more complicated because it's not like 3x. It's more like 3x1 5x2 6x7. And usually you're dealing with float numbers. So it's not even it doesn't even look like that. It looks like 0.001 * x13 * x2 and so on. So the numbers get a little confusing, but the concept is very straightforward. We're going to multiply the weight times the value coming in and we're going to add that all together plus the bias. And the final sum is then subjected to the particular function known as the activation function. And the most simplest one is if it's greater than zero, it's one. If it's less than zero, it's zero. They usually use a lot of different there's a lot of other functions that are more uh reliable than that one. But that one gives you the most basic understanding of what you're looking at. 0 or one coming out. In most cases, you actually have a value coming out. And in some cases, we use like a tangent wave. so that there can be a value between zero and one, but it might be um it it tends to shoot right up to one rather quickly. But, you know, those are things you can fine-tune in your neural network as you start getting to the solution. Let's keep into the generals here and let's see what's the next step. We're going to look at the cost function. And this is so important in understanding how the current neural networks that we're working with are able to learn things. So, we end up with a cost value. The cost value is the difference between the neural net's predicted output and the actual output from a set of labeled training data. The least cost value is obtained by making adjustments to the weights and biases iteratively throughout the training process. And when you think about this, we're not just sending one set of numbers through. We're sending all kinds of data in here. So you might have a hundred samples or a thousand samples and each one of those samples comes in and then we look at the cost for that and we want to get that cost the minimal the average minimal among all the different samples. So we want a general answer on there. You can see here we denote the predicted output with a little half triangle over it and then the actual output is just a straight y on this. Let's learn how neural networks work. Let's dig in a little deeper in how we program them. How do neural networks work exactly? In this, we're jumping from a single node into a larger picture. So, our neural network will be trained to identify shapes. And we'll start with the square again, 28x 28 or 784 pixels. And this is kind of a one of the standard images we work with a lot of times. Our shapes are images of 28x 28 pixels. Each pixel is fed as an input to the neurons in the first layer. So, here we have our input layer. Each one of those, we might flatten that out. That's the most easiest way to process that, but not the only way to process. So, we flatten it out so it's just one long array. And then we have hidden layers that improve the accuracy of the output. And you can see here, we're not looking at just one neuron. We actually have a row, two hidden layers. And each layer is a row of neurons. And data is passed on from layer to layer over weighted channels. Each one of those inputs is then weighted to each of the next neurons in the next layer in the hidden layer. Each neuron in the first hidden layer takes a subset of the inputs and processes it. Let's look into what happens within the neurons. So here we have step one and we can see in here where we have x1 * weight 1 x2 * weight 2 plus b1. That's that top neuron up there. And then we have the next neuron down which is step two. And then in step two they denote the um with the Greek symbol fi. And fi is the activation function based on step one. So it might be um if it's close to zero it's zero. If it's close to one it's one and it might be a value in between. It's very common depending on what activation function you use. The results of the activation function determine which neurons will be activated in the following layer. So you can see here we have B1 as we looked at with X1 and weighted one, X2 and weighted two. And then you would compute B2 the same way and B3 the same way and B4 and B5 and so on. So each neuron has an input from all the input layers go into each of the hidden layer neuron the first hidden layer. The result of the activation function determines which neurons will be activated in the following layer. And then that activation number goes off to the next layer. So we see here B11, B12, B13 and B14. And the weights coming in from B1. So let's say B1 fires and it goes into B11. Usually you would see the weights going all the way down. So B2 would have their weights going into B1 and B2 would then go into B11. B1, B2, B3, and B4 and B5 would then go into B11. And they would have their weights depending on what came out. It might just be zero. So there's nothing coming through or it might be a value between zero and one and so forth for B12, B13, B14, and B15. And then we take those and they'll have weights attached to each one of those coming out and they go into the final layer. In this case, we have a neuron that represents a square, a neuron that represents a circle, and a neuron that represents a triangle. And just as before, the information reaching this layer is processed after which a single neuron in the output layer gets activated. But our input was a square. What went wrong here? Remember, we started with a square. What do we have coming out? It said a circle. Well, that's going to be a problem because we don't want it to tell us that squares are circles. Well, our network needs to be trained first. How do we train a network? The predicted output is compared against the actual output by calculating the cost function. Remember our cost function at the end. We take whatever we said it was going to be and what it actually is and we just subtract those two. And the most common way used to generate the cost function is as follows. Is we're going to take the actual value minus the predicted value where you have y and then you have y with the half triangle over it is the predicted and then y is the actual value. We subtract them. We square that value and then we divide it by two. So it's usually how they generate the cost function. The cost functions determines the error in prediction and reports it back to the neural network. So we're going to do some back propagation. That's what this is called back propagation. We're going back through the network the other way and we're sending that error back the other way. The weights are adjusted in order to reduce error. The network is trained with the new weights and you can see here we have C= 1/2 Y - Y predicted or Y actual - Y predicted squared. Once again, the cost is determined and back propagation is continued until the cost cannot be reduced any further. Now, keep in mind, you know, if we have one picture of a square and it goes through, we actually do just a little training. We don't change it all to match that first one. Otherwise, you'll have a what they call a bias. So, each of those data goes back with our back propagation. And we'll send hundreds of samples on there until we can get that cost as a whole down as low as we can get. So that our average cost is very low without it being biased towards one specific figure. And you can see here we have our input layer, hidden layer setup on here. Similarly, once we've trained it for our square, the network must also be trained to identify circles and triangles too. So we need sets of all of these. We need lots of squares, lots of circles, and lots of triangles. The weights are this further adjusted in order to predict the three shapes with the highest accuracy. We can now rely on our neural network to predict the input shapes. And you can see we have a triangle coming in here and it goes through. Here's our circle going through and it's going to light up the circle and so on for the square. So before we dive into some hands-on, let's take a look at some deep learning platforms. The primary programming language, we're going to look at four of these platforms and we're going to start with Torch. The primary programming language is Lua with an implementation in C2. Torch's Python implementation is called PyTorch. And this is interesting because Python has become one of the leads in data analysis. So you'll almost always see a PyTorch or any one of these will have a Python equivalent and that's slowly spreading throughout the languages. So I'm sure there's within torch it's also probably got a Java setup and definitely has a C because it's primary implementation is in C. And so we have KASS. Cross is a Python framework for deep learning and USP is reusability of code for the CPU and GPU processing. We have TensorFlow. TensorFlow is deep learning platform by Google. It was developed in C++ and has its implementation in Python. And just a quick highlight, KAS and TensorFlow have slowly been working together. So there's a lot of things that you can actually put KAS on top of TensorFlow and access TensorFlow. Although there are still some tools in TensorFlow that that KAS doesn't fully access but it is a great interface for doing that. And then there's the DL4J is the first deep learning library written for Java and Scala. It is integrated with Hadoop and Apache Spark. You remember Apache Spark is written in Scala. That's one of the reasons that DL4J came about is so that it would run on the Spark platform. So let's take an introduction to TensorFlow. Google's TensorFlow is currently the most popular deep learning library in the world. It has really once they open sourced it, it was just amazing how much it spread in use and how many tools are linked into TensorFlow. Tensors are vectors or matrices of n dimensions. And you can see here we have dimension five. We have a dimension 4x5 or 5x4 as the case says, five rows by four columns. Here's one where it's 3x3x3. And so this is kind of nice because when you're processing pictures, there's certain things you want to do where you want the pixels to be next to each other. That's very important. Uh same thing if you're processing say a movie, you might want a 3x3 grid coming in where you have the the layers of the frames coming in to be processed. So you can see how having different dimensions is really helpful in analyzing certain data structures. And this is what's so great about tensors is you can of course flatten them out like we did earlier or you can process them based on their location. In TensorFlow all computations performed involve tensors. So everything going through is always looked at as tensors as a matrix or matrices of n dimension. TensorFlow architecture is as follows. Pre-processing data build a model. Train and estimate the model. And what we'll do is we'll go ahead and dig into use case implementation with TensorFlow. To do that, I'm actually going to go into uh in this case, I'll be using the Anaconda Navigator. And you can use either Jupyter Lab or Jupyter Notebook. Most people are very familiar with Jupyter Notebook. It's very commonly web-based. The Jupyter Lab is the next version of Jupyter Notebook, and it just lets you have multiple tabs open when you're working on it. And if you're using Anaconda, you'll go under environments and you'll want to make sure that you have your TensorFlow installed. And you can simply uh we'll do this uh I have it installed. Uh but you could do all we'll do all. You can do a search under all for Tensor. And you can see all the different tensors. It's actually installed in here. Version 1.13.1. If it wasn't, you could check the box and then run the install on there and it'd bring it right in. But we'll go and start up our Jupyter Lab, which is going to open up. In this case, I use Google Chrome. And in our Jupyter lab or Jupyter notebook, if you're in the notebook, you only have one tab and you won't have the added options like there's a folder and different things you can do in the uh lab that you can't do in the notebook. But everything we're going to do, you can easily do in the notebook. And you'll start up a new project. Deep learning is what I'm going to call this. And if you're not familiar, you can definitely we have some tutorials out on the use of Jupyter Notebook and how to run it and set it up and things like that. The most basic is we put our code in here. It has a nice display and a nice interface. Uh especially for data science, I can display all kinds of things on this page. And then you can just run this page right here. There's no code in it. So it's not going to show any uh thing until I put some code in there. And of course you can cut your cells and things like that. So the first thing we want to do is we want to import our tools. Now if you haven't remember you got to install TensorFlow and we'll also use pandas. Pandas is a nice database setup and that again is underneath your environment and you can see here your um whatever you're working on my Simply Learn setup where I've installed TensorFlow and pandas in here and I'll simply go up here and run this not going to see anything. So we've just imported those into our notebook that we're working on. So those are now available to us and it helps to have some data to work with. And we have here I'm going to create a path and a test path. And um we'll go ahead and let's just highlight this whole path. And you can always post a note either down below in the YouTube video or you can post a note on simply.com and ask for this path if you're not quite picking it up, but it is over here at the um ucied edu on their setup and it's in their archive. So it's archive.ic.uci.edu/ml for machine learning/machine-arning-databases adult. That's quite a mouthful. And in this case, we have adult data and adult test. But let's go and just take a look at that. Let me just paste that right in there to our browser window. And here's our adult data. And if I click on there, it's going to come down as a download. I'm going to go ahead and open it as a text in my notepad. Um, and the guys in the back were kind enough to look up to find out what the actual columns were in this uh coming across. So, let me go and take that to pull that information. And it doesn't matter whether I put it before below because these are just variables. Uh, but we can see here that we have age, work class, final WGT. I'm guessing that's final. We'll look that up in just a second to see what that matches. In fact, let's pull that up and just put them next to each other so we can kind of see what we got here. So, we have age. We have our working class state gov. Maybe final wage 77516. Education of bachelors. Education number 13. Marital never married. Admin clerical relationship not in family. so on and so on. So it goes all the way across here. And so we've pulled out this information, native, country, label, etc. We'll go ahead and run this. And so now we've loaded all our different uh paths. And this path, by the way, this is the same columns on here. So I don't need to create a separate columns on the adult test. And once we've run this, we've set those variables. Let's go ahead and pull that data in. And to do that, we'll use pandas. And we'll create a df train, a df test. Uh, each one's going to have our PD for pandas read CSV. It'll have our path we put in there, our path test. The first one went ahead and skipped initial space true names columns. There's our columns in there. Index column equals false. There's no index column. Um, on the second one, if we went back into here and we open up adult test, let me just go ahead and open that up. Pad, you'll see there's an actual row up here. We want to skip 1x3 cross validator uh with all the same data in it. So, we're looking at the same data in there. And here, we're going to go ahead and bring in our data. And then once you bring it in, it's always nice to see what kind of shape your data is in. And of course, when we talk about shape, we're talking about how many rows and columns, not whether it's been lifting weights. We can see here we have each one has 15 columns. And that goes with our columns right here. If we counted them, there's going to be 15. And the first data set has 32,561 rows, where the second one has 16,281 rows. And it's also good to see just how the data came in. So we'll use the um pandas uh d types. We'll run that. And you can see here where age came in as an integer integer 64 uh working class as an object. Uh which makes sense. Uh and then we have our fnlwgt the education as objects or well this is an integer integer object so on all the way down. And if we flash back to the data we look at the last column it's less than or equal to 50k. And if we scroll down enough, we'll see it's also greater than or equal to 50K. So, we'd like to kind of give that its own special setup on that label. So, on that feature, we're going to set the label equal to um if it's less than or equal to 50K, it's going to be zero. And if it's greater than or equal to 50K, it's going to be one. Uh so, it's one or the other. That's always a easy easy thing to read. And then we can take this and we can go dft train.l equals label item for item and df train label. And this just loops through all the labels. There's a lot of ways we can do this. Pandas, this might be actually kind of a slower way. There's a way to do just that setup and do the logic within the um setup instead of doing a loop. Uh but for this this thing, it'll work fine. We're not dealing with a lot of data. You know, it's a large data set, but it's not that big of a data set as data goes. And we also want to do it for our test data. Um I didn't really mention that we created two we're looking at two different data sets. One, we're going to train the data and then we're going to take it and run the test data to see if it works. So, we have our two different data sets, and we didn't catch it off the bat. If if you were pulling up this, you're going to pull up one the um this is the training set. And if we go back in here and open up the test set, let me just go back and do that. Adult test. One of the thing that we didn't notice that you'll want to pull up is at the end there's a period. So, we're pre-processing our data. We want to make sure that we include that period in every line on the second setup. So, I go back to my Jupyter notebook. I've got to have a label t which is less than or equal to 50k period or greater than equal to 50k period for one. Otherwise, it's doing the exact same thing. We're going to change uh the df train label and the df test label to zero or one. We'll just run that. We'll go ahead and print uh the df train label value counts and the df test label value counts. This is always a good idea because we want to know is there any weird stuff going on there? if there's null values, stuff like that, this will turn up on that setup. And we can see here we have uh zeros, how many zeros, how many ones, and so on on there. Just a quick view of the data that we're going through. And if we go back up here, go ahead and print the uh train dypes again, and we run that, you can actually run it up there, and it give you the new answer cuz it's loaded this information. Uh we now see it's an integer. And if you go back up here, it was an object. So that makes life a little easier as far as what we're doing with this. Now, at this point, we're going to look at the data. We can see we have a lot of numbers and we have a lot of categories in here. Uh so categories would be United States male never married versus seven and we can also see that when we looked at this we have our integers we have our objects working class. So the next thing we want to do on there is we want to go ahead and take that uh where we have integers and the objects and we want to bring that down here. We want to create those categories in a way that the computer can see them. And we'll start with our uh continuous features like age. We can see age integer. FNL WGT is an integer. Capital gain is an integer. Educational number, there's our educational number as an integer and so on. Uh so if we're going to have these as continuous features where they're an integer, we also need to make a list of the categorical features we want to work with such as working class, education, marital, occupation, relationship, race, sex, and native country. And again, these are all objects. Uh, so that makes sense. And when we flip back over to the data, we can see here we're actually looking at United States. If we continue down, see if I can find another one. A lot of United States on this particular one. I was getting worried there for a second that we only had United States, and it was a very biased uh census, which it probably is for wherever it came from. And of course, bachelor's, associate, vocational, some college. Uh, so you can see this is more categorical versus an actual number. Uh so now we have our uh categorical and we have our continuous features and this is just the list of these. So let's go ahead and run that and load that list in there so we can now start manipulating our data with it. Now we get our first line of TensorH flow code which is exciting. And we're going to create a variable continuous features. And what we're doing in here is we're going to go into TF uh feature columns. So we have the feature columns. We're going to set those up. numeric columns K for K in continual features. So this is going to go in here and says each one of these is a continual feature and we're going to feed that into the feature column. Not very exciting on the output uh cuz we're just creating this variable here letting it know what columns are what. Then we're going to create a uh relationship uh setup. So we have continuous features and then we have a relationship and again we're doing TF but in this case we use feature column. Uh so just like this one we're telling it feature column and now we do categorical column with vocabulary list. Uh so it's one of the things we can do with tensorflow and we're going to feed it one we have uh relationship and so we're just drilling down to the relationship column and these are the options they had. So this is going to be the vocabulary attached to this column and we'll go ahead and run that. So we load up our relationship and then we're going to do one more uh way of loading. Uh, in this one we're going to do categorical features. And so in categorical features, we're going to do TF feature column. There's our um command we've already seen before. And it's going to be categorical column with hashbucket. We're going to create buckets. Uh, in this case uh for K and categorical features. So it's going to create a bucket for each one of these uh categorical features. And the bucket size is 1,000. So, we're looking at uh and we've actually kind of repeated something because relationship is also in the bucket setup on there, but we wanted to show you three major ways of loading in your different features. One is our features that we know where it's going to be a number. Uh so, our continuous features, then we can set it as a relationship. Uh in this case, we actually created a vocabulary, husband, not family, very clear vocabulary on there. And then we also are loading just general categories into buckets. You can set different bucket settings in here. We went ahead and just went with a thousand. So pretty much everything since there's not a huge number of categories, each one gets their own kind of bucket setup in there. And as far as the initial setup, we need to go ahead and create a model. And so this is where it starts to come together. We've um as far as the preset up, we have our TF, we have an estimator. We're going to do linear classifier on the estimator in classes equals two. So we know there's only two classes we're looking at. We have ongoing train feature columns. And then we have our different we have categorical features plus continuous features. Uh so this basically creates our model. What data is going in? And we'll go ahead and run this. And you can see here that it gives us a little information uh that we had our TensorFlow using default config. You can change a lot of defaults. You can change as far as a model directory uh random seed saving summary checkpoint. There's all kinds of things you can go in here and set up. Rewrite options keep checkpoint mix etc. this point the model hasn't done anything. All we've done is create the model. Uh so let's just do a real quick rehash of what we've done so far. What we started off with is we grabbed some data. In this case, uh adult and adult test. We have a a training data set and a test data set. Uh we set the columns up. We took a very short brief exploration of the data and its shape. Um, as far as what we're working with, we changed our label around a little bit so that the label makes a little bit more sense of 01 instead of um, for the machine it's easier to spit out a zero or one. We can look up here. We double check to make sure we how many zeros and ones we have. Double check our data, make sure it's integer 64. Nothing weird's going on. And then we looked at three different ways that we can kind of label the data as far as the way we're going to read it. Uh, we have our continuous features and a categorical features. Here's our relationship which is one of them. When we went ahead and created our model, we did not put the uh relationship in here. Uh which you can do. You can actually maybe take it out of um categorical and then have its own on here instead of having categorical features and continuous features and so on. Uh so we've created our setup for our model. The next thing we need to do is we need to go ahead and create a function letting it know how to read the data into our model. How are we going to train it? And let's go ahead and create two variables. Uh the first one is going to be features. This is just all the features that are in there. And then the second one is going to be our label. And this is basically um we're looking at all the different information we can put into it. And then is that person based on that information going to make less than or greater than 50k? That's what that comes down to. Now the next part uh the definition we're going to create has a lot in it and we're going to feed this definition into our model training. Uh so there's a lot of stuff that goes on here. First we'll call it get input in function. Def get input function. We have our data set number of epics equals none in batch equals 128 shuffle equals true. So we're running this and it's going to return a TF estimator inputs pandas input function. And in this case it's going to be x equals our pd dataf frame k data set k values for k and features. Y is PD series data set label values. Batch size equals inbatch. Number of epics equals number of epics. Shuffle equals shuffle. So in here we're passing in uh the number of epics. We're not too worried about we're going to just go once through the data. There's a lot of data in there. We don't need to rerun it. Epics is how many times do you cover all the data and then how many groups of data do you pull in and batch at a time. So we're only going to look at 128 do the reverse propagation like we talked about. Uh, and then it'll go to the next batch and the next batch and the next batch and it shuffles them. So shuffle means that we're randomly picking where they're coming from. Uh, and like again, we're only doing we're not too worried about the number of epics for this particular model depending on how much data you have and depending on what you're running depends on how many epics you need to run. And there's a lot of rules on how many epics you need to run. One of them is if your uh training data and your testing data because you'll check your testing data against your training data. If your testing data starts having a better results in your training data, that means you're no longer fitting towards the data, but you're fitting to the answer. Uh, so it's kind of these little weird things you start to on here. And TensorFlow is really cool because it actually checks a lot of that for you. Uh, but we're just going to set number of epics equal to zero. And then we have our data set going in. So we're creating our uh, get function. How do we get the data into training our model? And we'll go ahead and run that. So now we have our data function. And now it knows where the data is coming from. Uh so we need to go ahead and train it. And that's simply we take our model we created way up here. That's where we take the model there. We've told it what columns it's going to pull in. So it knows what columns it's looking at. Know what the definition where it's going to get the information from. So now we want to go ahead and train it. And here's our input function equals in this case get input function. And here we tell it that our data set is a df train. number of epics equals none, which is already automatically set up there. In batch equals 128, which is what we have up here. Shuffle equals false. And we're going to do 1,000 steps. So, we're actually going to go through 128 batches, but we're going to do that a thousand times. And we'll go ahead and run this. And I just ran an update, so it's going to be give me some warnings because of that update. And then we're back here, and it's still going. To construct pipelines, use TF data module. Not a big problem. Let me let it go ahead and run all the way through on here and it takes it just a moment. There we go. There's our thousand coming out. As you can see here, here's uh checkpoints for 10,00 ongoing training, 101 global steps. And this is just all the reverse propagation going on. That's what we're doing here. Uh one of the things we didn't cover is we do it in small increments. So it's not all done like one error goes all the way back. You'd only do a part of that error and each one sends back a little piece. and say slowly adjust your different weights going all the way back. And then if you're going to train your model, we want to know how it did. So we're going to do model evaluate and our input function equals remember our input function up here that we created way up here. We're going to take this input function and instead of the data set that's coming in, we put in the data set here for training. Where's our training? Input train. There we go. df train. Uh now we're going to go ahead and evaluate. And here it is. Uh get input function test. So we're going to test the data out. Number of epics one. We don't need to rerun it more than once. Per batch 128. Uh so on shuffle and steps a thousand. So we're going to go ahead and evaluate this. Let's just see how good our test data did. Uh how good our model was programmed on our training data and how it evaluates on the test. And we can see it going on down here where it's got the evaluating graph was finalized. Let me just highlight that ongoing model checkpoint TensorFlow running local init evaluate 100 out of a thousand and so on. And once it gets to the end, we get a nice uh output here. We have an accuracy in this case of.79 with a baseline of 76. So now we've created a model. Uh let's go ahead and tweak it a little bit. So we have our accuracy up here. What we're going to do is we're going to look at age. And let's just go ahead and create a new uh square value for age. And the reason we want to look into the square value of age is we know that if you really look through the data, you'll find that as a young person, the age keeps increasing. As you get close to retirement, it begins to decrease. Uh so we square the value of age. And that's very data specific. When we're looking at data, you'll find that any kind of data that has that kind of like uptick and down tick by squaring it or square rooting it, you can get some very different results. And so we're going to go and square our age. And this is kind of um it's interesting because at this point, even at the beginning of this, we're focused on deep learning and on TensorFlow. But before I would begin even looking at any of this, I would have probably run some kind of heat map or some kind of evaluation in R or sklearn in Python to find out the correlation between different features to see just how well they correlate to each other. And there certainly are some wonderful tools for that because sometimes you can just mark off some features and other features you bring in. But for the deep learning, we can see how we can just dump it all in there and let it uh sort it out itself. And we're going to just write a quick little function here to take the square variable. In this case, we have dft dft. This is our training and your test variable and the variable age coming in. And we just want to go ahead and create a new under dft. And the new is going to be the variable name, whatever we put in there, which will be age. Uh so let's load this. Here's our functions now loaded. And certainly we could have just done that as a line of code. Uh but you start to get the feeling that when you build these uh functions, you might use that. You can now use this function if you had a number of different features that had this kind of quality to them. And we have our DF train new. So we're going to create a new training and a new test. And it's going to equal the square variable DF train or DF test. And the variable name is age. And let's just go ahead and run that. And so now we have our new or DF train new and DF test new. And just like we did before, let's just double check the shape of our data and make sure it all matches. And when we look at the um output here, really what's important is that each one of these has 16 features in it. We want to make sure we're not getting something weird on there. And our training set has 32,561 rows in it. And this one has just over 16,000 in there. And everything's pretty much the same except that in our continuous features new, we now have the new column we put in there. So we need to change that. And we have our continuous features new down here, which we're going to load up with our TF feature column numerical. This should all look familiar because we just did this. And so we're going to load that up with the new being the new value in there. And let's go ahead and run that. And we'll create a model. We'll call it model one. And this is the same that we did before except now we have our continuous features new in here. Uh so here's our new model in this case model one instead of model. And we're going to build that model right there. Now we haven't trained it. All we've done is told it where to get the data and how to get the data and what features are coming in. We haven't actually told it everything on the features coming in because we still need to also build our full our um get input function. So where's the input coming from? So, we built the model with the features in it. And now we need to go ahead and create our get input function. This is the same as before, but you'll see um we now have it with the data set coming in is going to be the same data set up here. And so, if we scroll a little bit to the right, we should see the new. And there it is. Sure enough, there's our new on the right. And so, let's go ahead and run that. Now, we've defined our model. We defined where the information is coming from. And again, you can go back and review the first part because this is identical that we did before, except now we have new as the column for the age. And we'll go ahead and do our model one. And let's go ahead and train it. There's our input function. Get input function that we defined up here. DF train is going to be the same. And everything else is going to be the same. Let's go ahead and run that. And it should go through here and run the tensor info coming in. And it's going to go through uh in this case where we have steps 1,00 shuffling. So it's going to go randomly 128 per batch. Uh and then the epics is automatic. We're not worried about that today. So now we have a trained TensorFlow model. And with our new model, just like we did before, we want to go ahead and evaluate it. Uh so it's the same setup we had before with our same get input function with our DF test new in here coming in. So there's our new data coming in. And this is really common when you're doing these models. You make little tiny tweaks to see if you can improve it. One of the best articles I read recently was you build your model to fail. You want a running model so you actually have something to compare against and then you continually tweak it till you get a better accuracy. Now I don't expect the accuracy necessarily to get better on this uh because of the way we partition the data. We can see here we now have an accuracy of.76 which is a little bit over the baseline and it's about what I would have expected it to be kind of the same. The reason is because we split the data at the 50 the people making over 50k and those making less. And so the age factor shouldn't be a huge factor. It would be if we were looking at more discrete buckets like 40 to 50, 50 to 60, 60 to 70 when we create buckets. But in this, I didn't really expect it to go up that much. In fact, we could probably run it a dozen times, which would be very bad data science. And we see we actually had a slightly better one up here, but our baseline accuracy was 76. And we come down here, we still see uh uh here's our accuracy baseline 763. That didn't really change. And you know, the accuracy didn't really go up that much. I could hit the run button a few times. I would probably upbeat the one above. So, not a big change, but that's all right. This is how we learn. This is how we go through and figure out what's going to work with our data and what's not. What's going to improve the quality of our data so we have a better prediction and what's not. And we can now go ahead and utilize this model. This is where it gets exciting when you're actually working with somebody or with your clients and you come in, you say, "Okay, here's my predictions. We're going to take a create a list and we're going to use model one and we're going to predict and our input function is get input function df test new." Again, this probably doesn't make too big of a difference, but we'll go ahead and stick with the new data we created. Number of epics one batch 128. So, all this should look pretty familiar, but we're running the prediction. So, we're going to load all our predictions into the predictions. And let's go ahead and run that. And you'll see it go through the TensorFlow setup. So it's running done running local ops. And then let's just go ahead and print the DF test new iOS zero. So row zero. And we're going to look at the predictions also for the same location zero. Let's go ahead and run that. And we can see here that we have age 25 workass private. Um it has all the information coming in for that individual. And then it comes down here. We go ahead and get our um prediction. And in this particular instance, there's our label zero. Uh, and then we come down here and we see takes a little bit for the setup to look up, but there's our array, which also returns a zero. And it has information for us on there. Probabilities, logistics on here. So, you can see there's all kinds of additional information you can pull from this. And likewise, we could do it for position three. Let me go and run that. And what's kind of nice about this is you can now see here's label one, and here's our logistics output. And again, have to kind of hunt for it a little bit in this particular setup, but here's the output array, and there's our one. and they match label one one. So we predicted for the very first one uh location zero that it's going to be a zero on the label is going to make under 50,000 and the individual in two working class uh private whatever setup on here capital gain capital loss etc came up as one meaning they're going to make over 50,000 so we covered a lot I mean this is the basics and you can see as you dig deeper when you look at some of this code let me just go back up here we're way back up here at the very top a little too far overshot as you start working in here. We have uh one defining your features. And at this point, we didn't show this, but I would probably use either Python or R to show a relationship correlation because they have some really easy packages in there to pull that up. So, you can see what features are really connected and how they're connected. Uh and then we showed you different features like we have ones that are uh integers and then we have ones like sex that are objects. You're zero or one, you're male or female, you're uh same thing with race. uh probably have just a maybe 16 different races listed there. Ethnicities, things like that. Native country again, that's you don't have like infinite number of native countries. You just have a handful. So when we look at this, we have our features. We looked at that. We have our continuous features like age, which is a number or in this case an integer, an education number, how many years and so on along with your race, your sex, your relationship, which are just very abbreviated uh categorical data. Uh so we looked at that. We went in there and we showed you how to um where was it? Here we go. We go back up here. Uh so we create our model. The model has knows what categories are coming in. That's really important. And this is probably the one of the more complicated parts of this is our input function. And this input function is so important. So I want to just rehash th