SPRINGLab/asr-task-data · Datasets at Hugging Face

audio audioduration (s) 0.62 28.4	text stringlengths 2 287
	now essentially through this whole thing what we are doing is what is called as gradient
	descent learning so in this gradient descent learning what happens is that you have your
	w and and if you look over this is what is the gradient over there now as you see this
	the direction of this gradient which goes down now in that what essentially happens
	what happens in the weight space itself so if i plot down to different plots over here
	say that i have a very simple neuron we just associate two features to one single output
	with some random initial value over there and with this random initial value so we will
	have a point on the weight space as well as in this space of epochs versus my cost now
	based on my update rule over there on the gradient descent now with that i will get
	down a different value of cost coming down over here accordingly i get down to my next
	is the major fallacy which comes down and as we go down deeper and deeper we will come
	is that maybe you are at some value of w which is not exactly the minima so in case you are
	that implementation you will be able to relate down the ways of connecting these input images
	via certain features to or class of outputs now finally if you want to read more in details
	you are also welcome to use down matlab with the neural network toolbox which is has a
	much better gui and given the fact that a lot of people are most experienced on matlab
	you might be able to use it much faster but we would be sticking down to our options of
	doing it on python the other implementations are obviously based on lua torch which also
	so its a syntax and and the base library of torch which is one of the fastest ones as
	of date integrated within python to work it out ah so thats all i have for this particular
	so welcome to todays lecture and as from we will continue with what we have done on the
	last class so today is a practical lab based session in which we would be doing coding
	exercise so if you have followed down the last four lectures which we have finished
	off so the earlier lecture was on actually getting you introduced to a very linear perceptron
	which was basically a coding exercise and there we had implemented one particular code
	set as well as on the test set of c p od minus and then that was also stored down as a pickle
	file which is your local file used within python in order to store down your recorded
	matrices now today what we are going to do is build
	up on top of that so in the last class and i had concluded on the point where all of
	onwards where you have all the files which are saved down and then appropriately from
	those i am going to take it forward and create a new perceptron model and use these features
	which were already stored in a pickle file by loading it from the pickle file and subsequently
	go down to run a classification so the location is still the same so you will
	have to get it down from the github link where we have been keeping all our codes posted
	but the reason we preserved it if you would like to have all the earlier computation also
	and once you have calculated out the features you would go into it then this header actually
	needed as well as you will no more be requiring direct access to the torch vision data set
	because all the required information have been stored down in your pickle file itself
	so these are optionals but always a good guide to keep them keep going on
	now in the last class what we had done was we had trained them and we had stored them
	with your features from the training data there is another pickle file which stores
	such if i am not giving down a very explicit location this means that all these files reside
	some other location then you can just append down the extra directory location from where
	load this one so this is where you just define a file pointer as f and then you use that
	file pointer in order to load your pickle and you get your ah basically your arrays
	,nd to just display whether your matrices have been fetched out so lets keep on running
	one by one so this is the first model which has to be executed so once thats done so it
	works out you get your first instance which has been executed over there
	now we go from the comment on to the next one which is about loading so it shows that
	go down to the next one which is to define my network architecture ok so within my network
	architecture how it goes down is if you remember from our simple neural network so what we
	a ten class classification so it means that there are ten neurons on which the output
	will be coming down and these are a one hot neuron kind of a thing so what that technically
	is going to have a zero value over there ideally thats what is present on my training data
	set whenever you are predicting you will get one of the neurons which will have a very
	high value which is close to one all the other neurons are going to have a value which is
	there so the first part is to define an initialization part so first we will start by defining a
	class so this class definition is basically trying to define your container within python
	of saying that this is a particular one which i am using so what i am going to do is that
	we are going to import down my n n library so within n n i have a particular data type
	this initialization is trying to say down that what is the number of inputs which goes
	down into my neural network over here that is the on the input side of it and that
	is equal to my number of channels which i call over here as an underscore channels so
	this is exactly if you look over here so this n underscore channels it is supposed to be
	sort of like within the perceptron model over here which is the starting point of my pointer
	on the constructor and which is my end point of the constructor ok so the starting point
	of the constructor is what gets defined by this ,nd of super or which is just a superior
	constructor over there so over here the first part is that i will
	be defining my perceptron which has this and then my next part over there is that the perceptron
	the neurons which i have on my output side and how this is connected is that i have n
	number of channels in my input set which equals to the length of the feature vector and they
	connect down to all the ten neurons on my output side over there
	now typically for this initial part there wont be much of a modification subsequently
	one output vector so this is what initializes and defines my perceptron model
	the next part is that i need to define what is my forward pass over this model or forward
	pass means that if i am giving an input i get an output so what is the relationship
	between this input to my output ok now you remember from our perceptron model over there
	over there had to be connected down everything to my output and once i have this feed forward
	going down the next part is that there will be a summation which happens over there
	here so what this means over here is that whatever comes down as my input that gets
	it as input to this network and then i apply a soft max criteria over there
	called as perceptron whatever i give as input it will have a linear transformation then
	so this is how i define my perceptron model so lets run that part so i have my function
	like to do is actually generate a data set labels are accordingly so here if you remember
	so i was telling that in this classification problem you just have a one hot vector remaining
	everything else is going to be zero but then in the labels which we had stored so they
	had just numbers from one two three four five six seven eight nine ten so its its not exactly
	down another simple for loop so what it would do is that it would define
	elements in your training sample and ten is the number of output ah classes which can
	be present over there and now based on whichever is the class indicated in your train label
	over there so this part if that matches down to a particular column index on a given row
	then you are just going to set that as one and everything else is otherwise going to
	remain as zero based on this initialization given down over there so we can just run that
	part and this generates your one hot label vectors now once that is done
	the next part is that ah you can actually create a pytorch data set from your feature
	matrix and know where this comes down from the fact is that your earlier data structures
	and whatever videos you are using so they were all in numpy format and numpy is a library
	you are dealing with torch as another library it has its own data type definitions to go
	the functions which are needed are something which is called as a torch from numpy so what
	this effectively does is that given any array in numpy you are going to convert it into

now essentially through this whole thing what we are doing is what is called as gradient

descent learning so in this gradient descent learning what happens is that you have your

w and and if you look over this is what is the gradient over there now as you see this

the direction of this gradient which goes down now in that what essentially happens

what happens in the weight space itself so if i plot down to different plots over here

say that i have a very simple neuron we just associate two features to one single output

with some random initial value over there and with this random initial value so we will

have a point on the weight space as well as in this space of epochs versus my cost now

based on my update rule over there on the gradient descent now with that i will get

down a different value of cost coming down over here accordingly i get down to my next

is the major fallacy which comes down and as we go down deeper and deeper we will come

is that maybe you are at some value of w which is not exactly the minima so in case you are

that implementation you will be able to relate down the ways of connecting these input images

via certain features to or class of outputs now finally if you want to read more in details

you are also welcome to use down matlab with the neural network toolbox which is has a

much better gui and given the fact that a lot of people are most experienced on matlab

you might be able to use it much faster but we would be sticking down to our options of

doing it on python the other implementations are obviously based on lua torch which also

so its a syntax and and the base library of torch which is one of the fastest ones as

of date integrated within python to work it out ah so thats all i have for this particular

so welcome to todays lecture and as from we will continue with what we have done on the

last class so today is a practical lab based session in which we would be doing coding

exercise so if you have followed down the last four lectures which we have finished

off so the earlier lecture was on actually getting you introduced to a very linear perceptron

which was basically a coding exercise and there we had implemented one particular code

set as well as on the test set of c p od minus and then that was also stored down as a pickle

file which is your local file used within python in order to store down your recorded

matrices now today what we are going to do is build

up on top of that so in the last class and i had concluded on the point where all of

onwards where you have all the files which are saved down and then appropriately from

those i am going to take it forward and create a new perceptron model and use these features

which were already stored in a pickle file by loading it from the pickle file and subsequently

go down to run a classification so the location is still the same so you will

have to get it down from the github link where we have been keeping all our codes posted

but the reason we preserved it if you would like to have all the earlier computation also

and once you have calculated out the features you would go into it then this header actually

needed as well as you will no more be requiring direct access to the torch vision data set

because all the required information have been stored down in your pickle file itself

so these are optionals but always a good guide to keep them keep going on

now in the last class what we had done was we had trained them and we had stored them

with your features from the training data there is another pickle file which stores

such if i am not giving down a very explicit location this means that all these files reside

some other location then you can just append down the extra directory location from where

load this one so this is where you just define a file pointer as f and then you use that

file pointer in order to load your pickle and you get your ah basically your arrays

,nd to just display whether your matrices have been fetched out so lets keep on running

one by one so this is the first model which has to be executed so once thats done so it

works out you get your first instance which has been executed over there

now we go from the comment on to the next one which is about loading so it shows that

go down to the next one which is to define my network architecture ok so within my network

architecture how it goes down is if you remember from our simple neural network so what we

a ten class classification so it means that there are ten neurons on which the output

will be coming down and these are a one hot neuron kind of a thing so what that technically

is going to have a zero value over there ideally thats what is present on my training data

set whenever you are predicting you will get one of the neurons which will have a very

high value which is close to one all the other neurons are going to have a value which is

there so the first part is to define an initialization part so first we will start by defining a

class so this class definition is basically trying to define your container within python

of saying that this is a particular one which i am using so what i am going to do is that

we are going to import down my n n library so within n n i have a particular data type

this initialization is trying to say down that what is the number of inputs which goes

down into my neural network over here that is the on the input side of it and that

is equal to my number of channels which i call over here as an underscore channels so

this is exactly if you look over here so this n underscore channels it is supposed to be

sort of like within the perceptron model over here which is the starting point of my pointer

on the constructor and which is my end point of the constructor ok so the starting point

of the constructor is what gets defined by this ,nd of super or which is just a superior

constructor over there so over here the first part is that i will

be defining my perceptron which has this and then my next part over there is that the perceptron

the neurons which i have on my output side and how this is connected is that i have n

number of channels in my input set which equals to the length of the feature vector and they

connect down to all the ten neurons on my output side over there

now typically for this initial part there wont be much of a modification subsequently

one output vector so this is what initializes and defines my perceptron model

the next part is that i need to define what is my forward pass over this model or forward

pass means that if i am giving an input i get an output so what is the relationship

between this input to my output ok now you remember from our perceptron model over there

over there had to be connected down everything to my output and once i have this feed forward

going down the next part is that there will be a summation which happens over there

here so what this means over here is that whatever comes down as my input that gets

it as input to this network and then i apply a soft max criteria over there

called as perceptron whatever i give as input it will have a linear transformation then

so this is how i define my perceptron model so lets run that part so i have my function

like to do is actually generate a data set labels are accordingly so here if you remember

so i was telling that in this classification problem you just have a one hot vector remaining

everything else is going to be zero but then in the labels which we had stored so they

had just numbers from one two three four five six seven eight nine ten so its its not exactly

down another simple for loop so what it would do is that it would define

elements in your training sample and ten is the number of output ah classes which can

be present over there and now based on whichever is the class indicated in your train label

over there so this part if that matches down to a particular column index on a given row

then you are just going to set that as one and everything else is otherwise going to

remain as zero based on this initialization given down over there so we can just run that

part and this generates your one hot label vectors now once that is done

the next part is that ah you can actually create a pytorch data set from your feature

matrix and know where this comes down from the fact is that your earlier data structures

and whatever videos you are using so they were all in numpy format and numpy is a library

you are dealing with torch as another library it has its own data type definitions to go

the functions which are needed are something which is called as a torch from numpy so what

this effectively does is that given any array in numpy you are going to convert it into