Skip to main content
Loading Explore guides…
Perceptron Coding Challenge · Acedra
Home
Explore
Computer Science
Perceptron Coding Challenge
Sign in to save
Chat
If YouTube asks you to sign in, open the video on YouTube.
Watch on YouTube
Reload player
Transcript
80 segments
Copy
Hide video
0:00
Hello welcome to Coding Challenge in this Coding Challenge I'm going to attempt to make a Perceptron this is part of a whole bunch of videos that I'm doing about neural-network-based learning and, but in this video I'm not kind of getting into too much about the whole broader landscape of everything history-wise and future wise about what's happening with neural network based learning in this example I just want to build with code the simplest
0:23
model of an artificial neural network possible known as a Perceptron. Perceptron, uh, the concept of perceptron was invented by Frank Rosenblatt in 1957 at the Cornell Aeronautical Laboratory, there's a link here to the original paper which I will include in this video's description if you want to take a look at that, and of course you can always find more on the perceptron Wikipedia page. What is a Perceptron? Why am I even here talking about this?
0:53
So ultimately I want to look at Artificial Intelligence, machine neural network based machine learning systems that are inspired by and modeled loosely off of the idea of the actual brain. The actual brain being this thing with like neurons and axons that connect other neurons and dendrites that receive input Actually, I don't know what I'm talking about just reading whatever is on this diagram Ultimately where I'm going to start building examples and show you
1:22
examples of lots of these components that are all interconnected and inputs are coming in and and outputs are flowing out but I want to start with this idea of the perceptron being a model of a single neuron the simplest possible artificial neural network that we could build and this will serve as the building block for future examples that it will make in future videos. Okay, So let's come over to the white board for a second so if the idea of a
1:53
perceptron is that there is a single neuron, call this a neuron. That neuron could have inputs let's say there are two inputs I'm going to call them X[0] X[1] so inputs zero and one. They come into the neuron some type of mathematical process happens in the neuron. And then, there is an output which I'll call Y or output. So these are inputs. And again this diagram it might looks familiar to you if you've watched some of my other videos because I often
2:38
talk about this idea of. There is some amount of input so long list of inputs that go into some machine learning recipe that processes all those inputs and performs a task maybe it tries to classify or perform a regression but make some sort of output some sort of prediction so this is exactly what this Perceptron is designed to do. Okay here's the thing. In order for us to understand and look at all of the pieces of what's happening in here we need some scenario
3:13
so let's come up with a scenario that we can use so let's say I have a two-dimensional space you could think of this this will be my canvas my window and what I'm going to do is I'm going to arbitrarily divide the space with some line. Some points will be on one side of the line and other points will be on another side of the line. So essentially what I want to do is use this perceptron for a classification problem. I want to say that these belong to you know Class
3:50
A and these belong to Class B so and I'm going to use a supervised learning strategy. So for background not some of this you could go and watch session three of my intelligence and learning series where I do some other videos about classification and regression using a linear regression model there's a lot of crossover here but anyway you could stay here if you want I'm going to kind of talk through everything but the idea is I want to classify these so I
4:18
want these inputs to be so x0 or any points right here like this X comma Y it's a little bit confusing the way I'm using it I don't I think I don't love this because I should really think it'd be the X is input zero the Y is input one right the X is input zero the Y is input 1 the output is Class A or Class B the Y so I'm using x and y in two different places and slightly different ways which is a bit confusing but hopefully we'll make sense as we
4:52
continue to go along here okay so but I actually want to say instead of instead of A and B what I actually want to say is plus one and negative one so the idea is that my perceptron is going to output a plus one if the point belongs to group A and it's going to output a negative one if the point belongs to group B. So how does – and we're going to use the technique known as supervised learning and what supervised learning involves is I am going to ask
5:31
the perceptron to say here is some input give me a guess but I know the correct answer I'm going to give the perceptron a point that I know should be in A and it's going to guess either A or B if it guesses A I'm going to say great job perceptron you keep on going! If it guesses B I'm going to say perceptron you made a mistake let's tweak something about your algorithm to try to get you to the correct answer and this tweaking is a process known as gradient descent and
6:04
it's something I've also covered in a couple different videos that I will also link to down here where to go through it as I get through here okay so that's the supervised learning process. Okay so what is the actual algorithm here, what happens here inside the neuron? So here there's here's the missing piece there's a few different missing pieces that I'm get to over time I was stepping on some of these you can think of as connections the inputs flow into this neuron but our
6:35
weighted weighted weighted as they flow in so each one of these connections has a weight let me say W0 W1 so these inputs are weighted and what the perceptron does its algorithm is to create a sum of all of the inputs multiplied by the weights that sum is X input times sorry input 0 times weight 0 plus input 1 times weight 1. Now in this case the perceptron only has two inputs so this is a very easy formula to write as you're going to see as I get into
7:20
future videos you might realize like oh there's a hundred inputs or a thousand inputs or a hundred thousand inputs but this same formula is always going to apply. A weighted sum of all the inputs input 0 times weight 0 input 1 times weight 1 add them all up together so that step one is the sum. Step two before so you could say like okay we'll take that and that's the output but this isn't the output step 2 is something called an activation function. Activation
7:54
function. And this is a key concept in neural network based machine learning as I get into future videos we're going to see there's a variety of different kinds of activation functions and why might you use this one or this one and what do they do and why – but typically what an activation function does is it allows you to conform the output to some desired range and do thing and another way actually another way to think about it is if you think about that idea of
8:26
the brain like you can think it does the does the neuron fire and continue to send its data along, or does it not? So what happens as the data comes out of that neuron? We're going to use in this particular example we're going to use a very very simple activation function you could think ok well I only want two outputs I want a plus one or a negative one. How could I take any number I can take any number and convert that number into plus one or negative one?
8:51
How would I do that? How about a function called sign? Take the sign of any number n. If that number n is positive then I get a plus one, if that number n is negative then I get a negative one, okay? So that's the activation function this is the whole process, it's often referred to as feed-forward. The inputs come in they get multiplied by the weights they get added together and then that weighted sum gets passed through an activation function and then that
9:30
activation function gives us a plus one or negative one should the neuron fire or not fire and that gets sent out and that's the output ok I'm back from I was just checking a live chat that's going on if you're watching this in archives I live chat doesn't exist but there are two important questions before I move on number one is what do you do with 0? I don't know we could just pick we could just arbitrarily right now let's just say this is greater than or equal so 0
9:54
will will consider +1 I mean in the case this is just like a toy example just to demonstrate the idea it's a building block you know I don't know how meaningful it is to be able to like classify points into these state space or a line in your app but but so it just wanted to make an arbitrary determination for that if it's on the line you know is it above or below I'll pick one. The other question that was asked is well how do you pick these
10:16
weights? So this is the essential question and this is where I have to get to. So the idea is that what we – through the supervised learning process we want to search for – we're basically doing the search to find the optimal weights the optimal weight values that will get the best results, the results with the least amount of errors and so to start we have to pick something to start. In this case we could pick random values we could just start with the weight at zero
10:44
that could be problematic so there's different ways this is a big topic in the field of machine learning when you start a neural network based system how do you how do you initialize the weights? Randomly? What distribution of random numbers you do some other kind of like learning process that gets to like a good starting point for the weights? That's a big topic of discussion and research but for us I'm going to pick random weights and start to tweak
11:07
them okay so there's a lot more pieces of this still but I think I'm going to go and start writing some code and we'll come back to pieces that we're missing I'm going to do this in Processing which is a Java based programming language and environment you can find out more about it at processing.org I will also release a JavaScript version of this that you can run in the browser so check this video description for links to both source codes after it's over. Okay so
11:34
what I want to do, I want to create a perceptron class. So we can see here by the way I have this slide here this is the same algorithm I just talked through let's just make sure we have it right the algorithm is for every input multiply input by the corresponding weight. Sum all the weighting – weighted inputs and then compute the output based on that sum passed through an activation function, the sign of the sum. So we can see we can think of like this could be
12:01
the point at 12 comma 4 and these could be the weights of the perceptron so what I'm going to do for this particular perceptron is I am going to create an array to store all of those weights and I'm going to say it's an array with two elements in it and in the perceptron constructor I'm going to loop through all of the weights and give them a random value between negative 1 and 1 so whoops you don't say void with a constructor I don't remember how to
12:39
program in Java based languages okay so this is the constructor and what I want to do in the constructor is initialize the weights randomly. Okay now what are some things the perceptron should do? Well I – one of the things it should do is it should be able to receive inputs and then compute a guess, an output we'll call that a guess okay? So let's write a function I'm going to call it guess and it should return an integer plus one or negative one and
13:18
it should receive inputs which could also be in the form of an array. Now I could if I wanted to because the simplicity of the example I could have done something like float w0 and float w1 I could just sort of have individual variables for the weights instead of an array but the nice thing about doing this way is this is more flexible that this we could happen if we reuse this code later with we can adjust the number of inputs and that sort of things within
13:44
our array okay so first thing I need to do is compute that weighted sum so I'm going to create a variable called sum and initialize it at zero then I'm going to loop through all of the weights and
14:01
I'm going to say sum plus equal – what do I want to do? The sum of all the inputs multiplied by their corresponding weights, so inputs index i times weights index i, so this is now that weighted sum I say that second step start with a summit zero loop through and multiply all the inputs by the weights. Then what I'm going to do is I am going to return – ah! I need to get the – so then I'm going to say the output is sign of the sum so it doesn't know what sign is
14:43
there probably is like a Java based function I could call automatically but let's just write our own up at the top of this code here I'm going to write a function I'm going to say int sign and it gets I guess I could say it gets any float I'm going to say if n is greater than or equal to zero return a positive one otherwise return a negative one so this is just that this is the so I could I could write here as a comment this is the activation function I could call it
15:14
activate or something instead the activation function is a function that receives some value if it's greater than zero positive one if it's zero negative one so no matter what number goes in to the what other inputs come in whatever that's weighted sum is no matter what the only thing this perceptron can ever output is a 1 or negative 1 so and then I can say return output so now I have basically if I kind of give myself – help! I really want, I
15:46
guess this is it, I really want to see the whole thing this is if I have all the code for the almost all the code for the perceptron a perceptron has a bunch of weights it initializes the weights randomly and it can perform a guess by receiving all the inputs doing a weighted sum that's passing through the activation function. Ok so now if I were to just create something arbitrary just to sort of test if this is working I'm going to say float inputs equals I'm going to just
16:14
create some random values like negative 1 0.5 and I'm going to say print line Oh first I'm going to say I'm going to have a perceptron I'll just call it P for perceptron P equals a new a new perceptron and then I can say P guest inputs and I can say output I can say guess and I can say what's wrong here what doesn't it not like oh so this should be sorry that should syntax wise that should these are the input that's an array and
16:57
I should say sorry a print line guess so if I run this – how come I can't – here we go if I run this we should see, oh it outputted a 1, let's run it again I got a 1 run it again eventually I should be able to to run it a bunch of times and I got a negative 1 negative 1 okay so this I believe is working the system works I have a perceptron object I could feed-in inputs and I can get – make a guess. Okay so we have the overall structure now for the perceptron and it works but
17:46
we need some we need to do more so here's the thing we need to create an if I had an actual data set if I were to try to classify flowers and these were sunflowers and these were days and this x-axis was like petal length and this was sepal length or something I could use a real data set here I'm going to do something really phony-baloney I think I'm going to like kind of almost be really ridiculous about it which is that I'm going to say I'm going to actually
18:17
just say that anything do like do I really want to do this I'm going to do it this way let's do anything that is let's just consider the line y equals x anything that's above y equals x is a plus 1 anything that's below y equals x should be a negative 1 so I want to create a known data set a known data set that I could use to train the perceptron so let's do that really quickly what I'm going to do is, let me think about this, I'm going to – there's so many different ways I could do this
18:58
whoops sorry it got stuck in my eye, uh, so many different ways I could do this I'm going to do I'm going to make a tab called training and I'm going to make a class called point and the point is actually just an input array that has three values in it no no no no let me think about this let me actually have the point have an X and a Y and also a I don't want to call it class a label we'll just call it a label okay so if I make a new point when
19:50
I make a new point I'm going to say x equals a random with y equals random height – am I going to run into trouble without just using the pixel coordinates? Let's try just using the pixel coordinates, I don't know if that's going to be a problem. And then the label I could say if X is greater than Y the label is one else the label is negative one right that should give me that should give me everything about I don't know what's above what's below so let's
20:29
do that and then let's do let's write a little function called like show where I'm going to say stroke zero and I'm going to say if label equals one fill 255 else fill a zero and then I'm going to draw a little ellipse at X comma Y a small ellipse okay so what I'm going to do is I'm going to make an array of points
21:09
I'm going to make a hundred of them and I'm going to initialize them
21:23
and I'm going to say points index i is a new point and then I let's make the size a little bit bigger 500 comma 300 then I'm going to do a background 255 and for every point in points this is an enhanced loop in Java for every point in points I'm going to say p.show() so if I run this we can see yeah I mean let's make this a square so it looks a little less weird and I can also draw just to sort of like see correctly I'll draw a line from 0 0 to width comma height so
22:18
you can see I picked all these points half of them are on this side and half of them are on this side alright so now that I have all these points and I can see them correctly categorized this is my known training data so what I need to do process wise is I need to take all of my known training data one at a time I need to pass it in ask the perceptron to give me a guess. Is it in one is it in one or is it in negative one? And then I need to do something based on whether
22:53
it's correct or incorrect. What is it that I need to do? Okay let's establish something there are still some missing pieces here I need to that I – that I need to add but I'm going to keep going let's talk about training let's talk about supervised learning. Here's what I need to do I need to take all of that known data. I'm going to take each and every piece of known data I'm going to take the X&Y point and I'm going to pass it in, again it's going to do the weighted sum it's going
23:27
to it's going to pass through the activation function and it's going to guess plus 1 or negative fun – one. Plus fun or negative fun! Are you having we're having some negative fun right now I'm pretty sure. So this is going to give me a guess but I also have the answer, right? So I have both the perceptron's guess and I have the answer. If I have both of those things I can compute something known as the error. The error I can think of as let's let's say
24:03
the answer, I always get this wrong backwards one way or the other but it's the difference between the correct value and the incorrect sorry – between the correct value and the guess right because if it's if the guess is a plus one and the answer is a plus one what's that error? 1 minus 1 that error is 0 and I actually have a little bit of a diagram here over here where you know you can sort of see these are the only possible correct answers
24:34
negative 1 or plus 1 so there's only four possibilities if it's supposed to be a negative one I could guess a negative one or a plus one if it's supposed to be a plus one I could guess a negative one or a plus one so these are all the possible errors the error is either zero or the error is negative 2 or positive 2 or 0 so this is a start this is a good starting point I need to have this error the idea here oh come back let me come back to the whiteboard
24:59
okay so remember what I'm trying to do is find the optimal weights so ultimately what I want to do is I want to figure out if I want to say well the weight should equal itself plus some change in weight. I want to adjust the weight if there's a mistake I want to make a tweak I want to like make the weight a little bit higher or a little bit lower right because maybe my weighted sum got me below negative 1 but it should be a plus 1 if I make that
25:33
weight higher maybe that will push the output up to positive so the issue becomes how do I calculate that Delta weight? How should this weight change based on – how should the weight change for weight zero for weight one and if there were many many many more weights? So the way that this is calculated with it is with a process called gradient descent and I have a couple videos where I go through this in in pretty large detail one way of
26:04
thinking about this which I'll kind of duplicate here in this video is this really relates back to a lot of my steering examples so I have all these steering examples where I have a vehicle that has a given velocity and it's seeking a given target so this vehicle has a velocity and it also has a desired velocity right because if it should be going towards that target its desired velocity is to go towards that target so you can think of just steering formula
26:34
if you go back to that Craig Reynolds steering formula the steering formula equals the difference between the desired velocity the way that I want to go and the current velocity which is kind of like my guess and if I get this a steering formula if I get the steering function if I get this steering vector and I add it to the velocity it's going to cause me to turn and go towards that target so essentially that's what I want to do here this steering vector is the
27:03
error the desired velocity is the answer that's where I want to go the velocity is my guess that's where I'm going right now I want to steer in the direction of the error so Delta weight the Delta weight is actually equal to the error multiplied by the input so it's filtered through the it but what's that error filtered through the input that's how I change the weight itself so that's the process that I'm going to do over and over again
27:30
and I have a slide here that I think will walk through that and it looks I'm in the wrong keyboard here so this is the process this is the supervised learning algorithm. Provide the perceptron with inputs for which there is a known answer and ask the perceptron to guess. Okay the perceptron guessed what's the error? Is it right or wrong? Is the error zero is it, is it two, is it negative two? Adjust the weights according to the error and go back and do it again and
27:58
again and again and this is the formula the weight is changed according to the air multiplied by the input and there something called learning rate which I'll get to in a second so let's see now I've kind of explained that in pieces let me see if I can now add that to the code so I'm going to here whoops I'm going to now create a function in the perceptron and I'm not going to call it guess I'm going to call it train. So this is going to receive some inputs and
28:42
a target. Right the difference between the guess is the guess something like oh I just want to receive these inputs and provide a guess with training I want to receive the inputs and the known answer so I can adjust the weights accordingly okay so the first thing actually that I should do is just get the guess which is actually guess with those inputs so since I already have a function that does the guess I can ask for the guess from that guess then what I want to do
29:13
is get the error the error equals the error equals the target minus the guess that's the error so now that I've done that what I can do is I can go through all of the weights and say each weight should change according to that error multiplied by its corresponding input so this is that particular algorithm this is tune all the weights. Okay so this is like basically supervised learning says put the data in, get the result, if the result is right just move on move along
30:07
nothing to see here. If the result is wrong twist some dials in here to try to get it closer to the correct answer and do it again and again and over and over again here keep twisting dials eventually to find that optimal result now there's something important here though. If I go back to this steering example you could think about okay so this is the vehicle it's going in this direction it should seek the target it knows what the error is the error is the
30:31
difference between the way it should go and its current velocity how much should it steer? If I steer a lot I could actually like overshoot and start going the wrong way in the other direction but if I steer just a little bit maybe I'm going closer – but I'm, but you realize that we're going to doing this with lots and lots of data so one thing that's actually optimal here is not to steer the full amount all the way according to the error but just some percentage of the way and that
30:58
percentage is referred to it's a key concept here and it's called where's a learning rate. So what I would actually do here is say that Delta weight what's this plus 1 here is the error times the input multiplied also by a learning rate. So that's a key concept here so let's add that into our code if I come back over here I'm at the perceptron is going to have a variable called LR for learning rate I'm just going to say 0.1 so now I'm going to say also
31:32
multiplied by learning rate. So there we go now this is going to adjust all of the weights so we should be able to if I go back to here I should be able to now train the perceptron. So let's go here and say for all of the points oh I did something terrible though I was doing some awful stuff here which is not I used P for perceptron and then I'm using a local variable P for point so let's call this PT for points let's actually just call this I'm going to call
32:12
perceptron I'm going to call this like the brain probably like a bad variable name but at least so it says something more than P so for every point what I want to do is I want to say brain.train the point the inputs associated with that point, and the target pass in the target associated with that point right? The point oh it has an X and a Y and a label so uh-huh so the target is actually the label and can I do this I want to make something
32:55
called inputs which is an array which just has point.x and point.y in it. Is Java going to let me write that? I think so so this is what I want to do I want to train the perceptron I want to send in every point as input so X the x and a y make the zero on the one input and then I want to send it into the train function with the label which is the known answer so if I do that okay so in theory it's training and it's doing
33:31
this I can't see anything so now I need some sort of way of tracking how well it's doing. This is going to be tricky but I have an idea for how to do this. Somebody the chat just pointed out that you know why am I doing the uh, why am I doing the same loop twice yeah that's kind of unnecessary here but I'm really just trying to separate out different parts of the code ultimately I probably don't need this original loop but so there's a couple things I do one
34:01
is I could actually calculate the overall error like I could actually look and this wouldn't be such a bad idea and just sort of print that out I could I could calculate the total squared error and kind of evaluate how well it's doing but I want to just actually look at it visually for a second so I think what I want to do is let me see here what's a good way so I'm going to just actually say guess equals inputs brain.guess(inputs) and then I'm going to
34:32
say if guess equals point.label let's just call this looks like target equals points points label just to have these in separate variables if guess equals target what I'm going to do is I'm going to draw um, I'm going to say I'm going to draw something that's green I'm going to say no stroke I'm going to draw an ellipse at X – like I just keep typing p5 – Y that's like a smaller size else fill red. Well everything became green instantly that can't be right
35:37
all right let's not train it. Okay so we can see I guess it's just working better than I had imagined I'm trying to think visually if there's a better this is like okay so let me let me make the window bigger and let me make all of the points let me make all the points much bigger so it's a little easier to see and let's run this again okay so you can see without any training everything is wrong so I'm not if I add the Train function back in everything is correct
36:34
now I guess it just like this is such a simple scenario it's like trained and worked so so quickly in like a matter of like one or two iterations me I am so me in the chat had an excellent suggestion which I could demonstrate the training process with a mouse click so I'm going to quickly do that so what I'm actually going to do is I'm going to take this training out here I'm going to take this whole loop and they'll just delete this line of code that actually does the
37:03
training and I'm going to run it so now it's not training and you can see it's got every time it you know when I run this it's all wrong right but what I can do now is I can say void mousepressed and I can just run the training algorithm so now what I did is only when I click the mouse is it going to run through all the data and actually adjust the weights so now if I run this you can see you can see look at this it's got most wrong but it's got some
37:37
right, it's got most right but some wrong and now if I click the mouse ah a few more correct but some more wrong click the mouse again OOP click the mouse again click the mouse again click the mouse again so you can see it's like changing and eventually now it's got everything right and so you can see how that learning process happens over time it only took five or six cycles. One other thing that I could do is just train one
38:00
point at a time so I would draw everything but I could here I could say I could say int training index equals zero so what I'm going to do in draw now is I'm going to say point training equals points training index so I'm just going to take one point and train it off at one point okay and then what I'm going to do is I'm going to say training index plus plus and if training training index equals points.length like if I get to the end of the array I will just
38:46
reset training index back equal to zero. So this now in the draw loop what did I get wrong here I'm just a spelling training wrong Oh double equals sorry so now in the draw loop it should be training one point at a time and you can see like it's kind of weird all sorts of weird flashy stuff is happening but over time it should eventually settle into at getting everything correct but as it makes these little adjustments it's going to get some things wrong and some
39:13
things right and you can see now so again there's so many other ways you can think about visualizing the training and you could actually visualize the one thing you might try is actually visualize the perceptron itself like visualize the weights visualize the connection visualize the data flowing through it so I'll leave that to you creative people watching this video so I'm coming towards the end of this particular video and I think I need to
39:34
do I'm going to give you some exercises and I think I'm going to do a follow-up one that kind of adds I'm gonna give you some exercises and then I'm going to come back and do another video where I add this these answers in but there's a couple things here one is I've got a serious problem a very serious problem with everything that I've done here let's just say I'm going to let's say that this space that I'm in is actually this. 0 0 forget about pixel space or anything there's a coordinate
40:12
space where zero zero is in the middle right here and I want to categorize us data as above or below this line or maybe you know I want to use the same system but I want to categorize data as above or below this other line so I want to use a perceptron to categorize the same exact code to categorize both of these two scenarios well in one case in the orange case zero zero should be a plus one in the black case zero zero should be a negative one but notice
40:48
something here if I'm actually feeding in 0 0 into this perceptron system no matter what the weights are the only thing I can ever get out of here is a 0 this is a problem because sometimes 0 0 is going to be above or below, sometimes it's going to be in class A sometimes it's going to be in class B that can't possibly be right and this is where this idea of a third – I'm going to go and get another color here this perceptron will actually not work or perform correctly with this genetic
41:24
generic scenario other than with having something called a bias so I need another input, a third input into the perceptron that is always going to be a 1 input 0 is X input 1 is y and the bias is 1 and actually if you think about this this is really I'm really working through the same problem that's from my linear regression with gradient descent videos or what I'm trying to do is solve the formula I'm trying – neural networks are designed to generalize a
42:10
function to solve a function and in this case, this very simplistic scenario it's actually just looking to solve the formula for this line y equals MX plus B and M being the slope is kind of like rise over run and B being the y-intercept so this weight the biased weight is really there to solve that y-intercept and these weights are really solving the slope the rise over run so that's what we're doing we're essentially doing linear regression with
42:45
gradient descent again but just through this perceptron model so if you didn't watch those other videos you could go back and watch them to some connect all these systems so what I want you to do is I have an example here from the nature of codebook this is essentially the same code that I've been writing but it does two different things one is it visualizes what the brain thinks the current line is and also it adds that bias so if you're watching this video
43:22
I'm going to release the code for this video this I get to part one of a perceptron coding challenge if you're watching this video you could go right to the next one and I'm going to add the bias in and maybe do a bit more with sort of visualizing what's going on here and have a generic formula for a line but what I might suggest you do is see if you can add those things yourself to this particular perceptron and then when I get to the end of the next video I'm
43:47
going to talk about why this is such a limited system that can barely actually do anything meaningful in machine learning but it could be a building block for a much more complex system that can do a lot more interesting and powerful things so I hope you've got a sense of what a perceptron is what the algorithm for how a perceptron works is and how the feed-forward supervised learning training process of a model perceptron works because this exact
44:13
building block this scenario is what I'm going to use in the future videos restart to build more complex neural networks ok thanks for watching and I look forward to your feedback and thoughts in the comments
44:31
you
Here to help you learn
Sign in to keep a private conversation with your course tutor.
Ask me anything about the material…
Sign in to chat