High in last session, we discussed about boosting the Legatum, so and we also discussed about boosting.
So let me summarize the boosting value.
It works on a similar method as discussed above.
It fits a sequence of cloners on different weighted training data.
So basically, we will be creating small rules and then combining all of those small rules together.
Now it starts by predicting additional data set and gives an equal weightage to all the observations.
When a particular observation is misclassified, it gives a higher wage or more attention to that particular
value, to those particular rules of data.
And then it will try to reiterate and continue and learn to correct those rules of data which were incorrectly
predicted.
Now, this will keep on continuing to fill up limit is raised in the number of models or the accuracy.
So if we reach the maximum number of models or if we reach and limit of accuracy at that point, the
other boosting stops now, mostly the EU's decision tree stumps with either boosting, but we can also
use machine learning algorithms as based on its weight on training data set so we can use our robust
algorithm for both classification and regression.
So this is about either boosting and either boosting is one of the very basic algorithms which we have
for the boosting algorithms.
It's like a very basic go to the for the boosting algorithms.
So now we will go ahead with the mathematics behind.
The boosting algorithms and try to understand that.
Now, the math behind the boosting algorithm is majorly consisting of three important steps, the fourth
step, the.
An initial model, if not, which is defined to predict the target variable, but if not is are very
forced to be the model for the very first vehicle owner and the model will be associated with the residual.
That is an error.
It is also known as such as you do it.
So it will be by minus, if not because Y is what we were trying to predict.
And if not, is the prediction which we have got from this particular first model, the 08 model.
That is the very beginning.
Now a new model, each one will be generated.
Now this model is for to the residual from the previous step.
So now the target value will actually be by a minus.
If not.
So now, if not on each one are combined to give F one, that is if one model is created by combining
the two one model and the if not more, each one model, actual model, three models, these are all
the vehicle models after the very first model like this, if not so F not is our very first model.
So if we have a look at the diagram, then this model will be the if not model and all the other next
models will be each one H2, H3 at Ford.
That is intermediate models and the combination of these models.
So the first model plus the second model that is if not plus each one will be if one.
Now, if not, plus one plus two will be if two more similarly, if not, plus one plus two plus three
will be the F three model.
So this is how the naming convention would go.
So let us go the.
So here you can see.
We have if not and it's not, which combine to give everyone the boosted version of, if not the means
squared error from F1 will be lower than that from the.
If not, why?
Because if not, has one decision, stumm and each one has another decision stumm.
So if one will be having some value, if one would have given some residual value, that is why minus
if not now, each one will also have predicted some value.
It should not be also given some improvement in the prediction.
So that improvement, let us see if there's some other value.
So when we combine this with this, the resulting residual, the resultant error value will be lower
in comparison to the previous value.
If it does not lower, then we will not consider that particular stamp.
So we will not consider that particular model only if it actually increased the error.
So because that is a completely opposite, the target of the modelling process, which we are following.
So now to improve the performance of the F1 model, which we just created here by including one model,
one decisions dump into the original decision system.
So now we will again model the model, this particular model and indigenous team to this particular
model, which has already has a residual value of F1.
So now we will create a new model if this new model, if you will, the combination of the original
F1 plus H2.
So what would this be?
It would be if not plus each one plus H2.
So now again, we will expect the error to reduce further.
So like this, after we add another one, another one of the S3 and the Richwood.
So like this, we are expecting the residual to decrease slowly and gradually.
We do not want to do that as you do will do decrease very drastically.
We want to reduce slowly and gradually.
We want each dump to learn only some part of the department.
We don't want this dump to be a large dump or we don't want it to be a large decision.
Three, we want it to be as only a small vehicle owner so that it could improve slowly.
Now, this can be done from immigration.
So after immigration, the final model, if m will be a combination of F of M minus one plus itchin
and this would be continued in the schedule has been minimized as much as possible.
Now, here, the additive lonas do not disturb the functions created in the previous setup, so F2 will
not impact H2 or if one and if one will not impact each one, or if not, these are independent in this
particular nature.
The only thing is we are just combining.
We are just adding something on Bulford.
So instead.
They impart information of their own to bring down the visitors.
Now, let us consider that the Prediction Act, I believe I should be, is if of.
So this will be equal to a function of X, so prediction at any particular iteration is a 50, which
is a final combined model that is at any that the combination of if not and each one is núñez.
If the while the small vehicle owners are each called, if the small if the I, these will be added
from zero to.
Whatever hydration we ate, so we are seeing that we will have small, if not smaller if one, small
if two and so on, to give us a larger if you value something like that.
So these will be small we cloners, which we will be adding.
And this is the final of strong learning which we will be getting.
So the loss value, the value of the error.
So how do we calculate errors?
The errors are simply isolated by volume minus the predicted value.
So the predicted value will be F of the capital of the fixed, so the loss value will be this particular
value G G is also going to loss function.
So loss function or cost function.
So cost will be summation of the entire loss.
So loss, this is the loss function, loss function is at any point of time, what is the error?
So Ed will be by minus 50 like this, if of the fakes, doctors error and the predicted value at any
point of time.
So when we subtract error value from the target value, it is called.
Edit And when, Wendy.
Do a summation of these errors.
It is called the.
Cost.
So this is the cost function now we are trying to find out the change in cost with respect to the model
at every step, how much the cost is changing.
So how we need to improve the model at each and every occasion, that is what we are trying to find
out.
So it will be Belge differentiated with respect to FFP of Fix, because here the only thing which is
changing is if the function if.
Rate X and Y are already constant, so the only thing changes F will be so we will differentiate with
respect of a fee.
So the deluge by itself of the effects comes out the summation of lost function of via F the X.
Differentiated with respect to Beloff of the office now.
The change which should be brought.
Do a particular model, is this particular value?
So the next model which would be created, that is this this F of the any particular iteration is F
of your right now the F of five plus one.
This the next model, the next complete model will actually be a some of this current model, plus the
change which we want to bring to that model.
So F of B plus X, the 50 plus one is equal to minus new value by the lefty, which is this particular
deal, the change which we want to bring to our model with respect to the entire function and do a constant
on that is the learning rate, how fast we want to grow our model.
So this will be the next vehicle which needs to be added.
So the next final model will actually be the previous model, the previous final model, the with all
the layers, plus the new model, the new vehicle stuff which has been added to it.
So this is F of B plus one.
That is the final model.
I will I know that the Operation B plus one and this is the final model, dehydration B.
Or to which we add another stump for fee plus one.
So you can see that this is the final model as of now.
Now, when we will add another small model to it, when the others was done to it, the if the capital
F of the plus two will actually be equal to a full fee plus one plus small fee plus two.
So every time, every time we add a small sum to this particular model, the stronger model will keep
on increasing.
So let us apply a regression to it, so when we will be applying regression to this particular model.
So the loss function is log function for regression is sum of squared off added.
So the laws function will be via a minus of the affects who will square, not the of error.
Now, when we were differentiated with respect to f off the we will get negative V minus F of B.
This will be equivalent to now of the plus one.
If all 50 plus one is nothing but the change which we will be having in the previous one.
So this multiplied with the learning rate gives the next improved model, the next stump, which we
will be adding.
So the next dome will be giving us.
This particular learning rate in via minus F will feel fixed, so this is the improvement which we will
be bringing to our model.
Now, let us have a look further.
Now, what we will be doing is now let us say we are working with classification.
This was the case of regression.
So the loss function for regression is the difference between the value, the actual value, minus the
predicted value holds to give the loss for the regression problem.
Now, the for classification problem, the loss function is nothing, but the model will be one upon
one plus E to the power minus F of the.
So the loss function for this will be equal to minus Vei in the logoff, BP plus one minus Y.A. in the
logo, one minus BP.
You remember the likelihood equation which we had the likelihood equation stated that B to the power
VI plus one minus B by.
To devour one minus Y.
So when we take a log of this entire thing, we go bayoumy via a new logo, the.
Plus one minus Y into log one minus B.
So when we solve this integration, we get Lawwell one plus E to the power of the X minus via into F
of B.
Now, when we differentiate this with respect of F of the X, what do we get?
We get.
Minus Y, minus one Oborne one plus E to the power minus four feet, which is again in the form of minus
of VIII, minus B of the.
Now, that's because this is the B of B date, if we replace this one little new.
So what do we get we get Vijaya minus BofI for this next game.
So what is the next step for the model?
What is the next viglione which we will be getting?
The next decision?
Stumm will be a fee plus one is equal to the loan.
And great interview minus BP.
Now, if we come bad, does this not look similar?
This is just a similar thing, right?
No, my benefit is a regression on classification.
The improvement which we need to bring is just the same.
So what are the different issues with Gbps now, let us consider different issues with GBM, so these
are different values is these are different.
This is the model which we have generated.
So this is how we are improving.
So what we will be doing is we will be having a vehicle or not.
We will create a vehicle, not small if zettl.
So.
This will be a small if of zero, we will add another one to small for one to it, which will combine
to form form capital F of one.
Right, then we will have let me draw this for you.
So here you can see that initially we have the vehicle, which is if we can find another model, another
vehicle stump, if one to it, and the model at that particular station, which is a combination of
these two models, which is Capital One.
Now, when we arrived at the capital, if one to another storm, which is if we get the capital to Morton,
which is the combination of all seem linked now to the combination of all three models that this capital
is the model.
Then we add another vehicle, another small F3.
We get the capital EFSI model and it goes on the same.
So until you can see that we have this, if not more, do we add another small if if one model to it
and we get the if one when we add capital if one and small if we get capital and.
So this is the value of 50 plus one.
So the next model will actually be the current model plus small change of the.
Function, which we have small change in the lost function.
Which will cause the next more days, a week later.
So this is what DBM is now, what is Jim Gimmies gradient boosting machine, which is what we have discussed
now.
So what is the issue with this?
The first issue is that the laws function does not consider more than complexity.
Here we have not considered if our model, the vehicle under which we have considered is actually weak
or not, what really happened in case this vehicle or not is actually having a higher depth and it does
not really a vehicle or not.
It tends to overreact as it does not know where to stop now, because we don't know where this F plus
one should stop being created, so we don't really know where this should stop.
And next is it is not generalized in nature, so it will not know when it actually starts to overwhelm.
So for this, we have another solution, which is egg boosting, which is extremely great in boosting
machines.
Now, hosting was introduced in 2014, Exposed has been loudly lauded as the holy grail of machine learning
algorithms and competitions.
So in case you have visited the website Jagi, you will have seen that there are a lot of competitions
which are being held for the machine, learning a beginner to intermediate level people who actually
participate in different competitions and showcase their skills.
So the goal of the algorithm is a boost for them.
So if you see all the winner models would have been trained on extra boost in case of any of this or
any of such competitions.
So from predicting I click through rates to classify high energy physics events, Extra Boost has proven
its mettle in terms of performance and speed.
So extra boost has a very great performance and the high speed for predicting and for training as well.
Now, the execution speed generally moves this fast, really fast when compared to other implementations
of gradient boosting.
But newly introduced light GBM is faster than exergy boosting.
So there is another variant of boosting, which is like the GBM, which is faster than H2 boosting.
Now the model performance boost in the mind dominated structure or tabular data set on classification
and regression predictive models.
So the evidence is that it is the go to algorithm for competition winners on the competitive data science
platform.
So in case you are not looking for a new model and you just you don't want any clarifications from the
model, you don't want to understand how a model is working and you are happy with having a black box,
Maubee.
And the only thing that you want is a good performance.
Then you can straightaway go do extra boosting requoted.
And you can straightaway skip the linear models and random photos and decision, and basically we're
going to move forward for the implementation.
No.
Now, what algorithm does she to use, so the rules library implements the gradient boosting decision
algorithm, so it is applying the gradient boosting algorithm on the small decision tree stumps.
The algorithm goes by a lot of different names, such as in boosting multiple additive regression trees
stuck at stochastic gradient boosting or gradient boosting questions.
Boosting is an ensemble technique which we have already learned about when new models are added to correct
the errors made by the existing one.
Modules are added sequentially until no further improvement can be made, a popular example is the Boost
algorithm, which we just discussed, and this reads the data points that are hard to predict.
So basically, what are the algorithm, which we have learned was that we will have certain data points
and the data points, which will not be classified correctly by the previous model.
The new model will give more weight based on this these particular data points and try to predict them
better in case it is.
It has some more residues which are not predicted that a key.
Then again, it will give higher ratings to them and then the next model will try to improve basic.
So grading, boosting is an approach with new models out there that predicted as you do it or instead
of prior model, I then added together to make the final prediction.
It is all very interesting because it uses a gradient descent algorithm to minimize the loss when adding
the new model, which we have just discussed, this gradient, which we are calculating.
This differentiation, which we are calculating all the cost function is actually the gradient which
we are applying for the creation of the next model.
This is the next model which we are creating.
So this is the gradient which has been applied for creation of this next Vignola, but just the base
of degrading, boosting the.
This approach supports both aggression and classification, predictive modeling.
So hence we will be using it for both of them now ASG boosting, what is the difference between JVM
and extra boost algorithm?
So bored to extra boost and Devean follow the principle of gradient boosting that.
However, the difference in modeling is specifically to boost use to a more regularized model formalization
to control overfitting, which gives it a better performance.
This is what we discussed here that GBM thanks to all Wellford ads, it does not know where to stop
and it does not consider the model complexity and it is more generalized in nature.
So to consider the more complexity.
We have introduced more regularisation in case of extreme boost, so in case of extra boost, we have
used more regularized, more formalization to control overfitting.
So instead of the draining loss alone, we have added another regularisation film to the objective function
for this particular model.
So the regularisation don't control the complexity of the model, which helps us avoid overfitting.
This sounds a bit abstract, so let's consider the following problem.
In the following picture, you had asked if it was really a step function given the input data point
on the upper left corner of the image.
Now, the solution among the three, do you think is the best fit?
So you need to find out which one is a better fit.
Now, these are the images.
So what is a better.
So if you see these are the data points.
Now, for these data points, if we create these kind of splits, then what will happen is it will keep
on.
Wooing by the decision that it will need a lot of decision trees, these are the number of stamps which
will be needed and you can see that it is it will take to overfit here the.
Value for regularisation is value.
Here, the function is very complex in nature, that is, it is trying to override the values, it is
trying to learn everything, it is trying to learn all the items, which is why when you look at this
particular dataset, at this particular split, it has made a split at the wrong position.
It should have made a split at this particular position, which has been corrected in this particular
diagram.
Here you can see this line is also incorrect and this line is also incorrect right here.
Both the lines are completely in sync with the data, although there will be very slight error present.
But at least it has learned the generalized model, which was actually the expectation here.
So here the there is a balance between the log function or time function.
So let's go further.
So this is the objective function.
This objective function contains the traditional Lospalos function, the old lost function, which we
had from the DBM, right.
This is what we remember from the DEVEAN.
This is the last function from the Devia, so this is still present in the boost.
They have added another regularisation function on top of it, in case of boosting, so extreme boosting
is a Baoshan or upgraded version of Gbemi where we have considered the complexities of the models so
that we can actually regularising regularize these models and we have added a regularization term.
Now, let us see how this actually works.
Now, in exposed package, I did step Vardas to find the three Ifti that will minimize the objective
function.
So we have this loss, but if the minus one plus FP is created and we have this loss function.
This particular regularisation function, and this is the entire object of effort, so this is the lost
function and this is the regularisation function, the regularisation is essential.
Now, we have been learning regularisation from the very first one.
You should remember, regularisation has been implemented in case of models as in the form of rage and
laso regression.
These are two regularization parameter which we have been using.
Then we have applied certain parameters or the stopping points do decision trees which actually allow
in regularization of the decision is random.
Forest again, is not really secularized, we could see, but it is using bigging mechanism on the small
models.
So it is again being regularized on the basis of averaging out the values and it is reducing the variance
of it.
Now the boosting has the mean concept of improving the base.
So instead of having the high bias which was already present, it is trying to decrease the bias in
this case of extra boost.
So.
We have been using regularization ever since.
So here they colorization is essential to prevent overfitting to the training set.
So when we apply regularisation, this overfitting will not happen.
So without any regularisation, the three will split until it can predict the training set perfectly,
so it will keep on creating new F.P. models, new small, iffy models and combining it with the previous
complete strong Kloner in the time it gets the exact value.
That is what we have learned in the beginning.
Right.
So but we need to know where we should stop so that we do not overfit.
So this will usually mean that the three has lost overgeneralization and will not do well on the new
best data.
So the more they may be able to predict this training data, it will predict this training data.
But in case I give it any other point, any other data point.
Then it will not be able to predict that properly.
So in to boost the regularisation function shows the model complexity.
So now we will consider more complexity in case of extreme boosting.
So this is the function which we have, this is the globalization of function, which we have for the
more complexity.
So there are these different components which are present in this more complexity.
So we need to know what this more complexity actually means.
So here the is the number of leaves in the.
So are regularizing the number of bodies in the street, so we don't want to have a lot of leaves,
so this will actually reduce the size of the tree.
So when we have regularisation on the number of leaves of the tree, it will actually stop the tree
from growing very large.
Next, we have this W, which is the score of the Liefooghe, so every player will have a certain number
of UVs.
So for even if we have a vid associated, this Veith is actually what allows the next model to predict
the values better.
So we have been discussing about the frenzied state that Adam boosting tries to give more weight age
to a particular node or to a particular data point so that that particular data point is classified,
but a key next thing.
So this is what the Vade will be doing.
This weight will be giving the score to the leaf.
Now, this Guerma is the Levett penalty barometer.
So Gamma will try to finalize the weight of the.
Leith, so we don't want a particular vicuña to learn a lot.
We want to increase the precision or increase the performance slowly and gradually.
So what we will be doing is we will be penalizing the leaflet so that it does not learn a lot at one
particular point of time.
We are trying to stop it from launching a lot.
And the lamda is the precise penalty and we did, which again was along with the evalu so that the three
sides does not grow very large.
So at the end, lamda actually regulating the size of the tree while W and them are actually helping
in reducing the score or the age of different leaves.
So how does the function optimize the above objective function?
So we have this objective function, so this particular objective function when this is differentiated,
so it will actually give us these this particular dome, Belge, will be the first differentiation of
this value, and it will be the seventh the second differential of these values.
For a differential of the lost function and second differential of the loss function.
So here you is the value here.
The Q value which we have generated is the value which maps the input features to the leaf nodes in
the tree in our lost function.
This objective function is much easier to work with because it is now giving a school that we can use
to determine how we structure this.
So this entire values which we have, these entire values, that is the lambda gumline w will help in
creating a tree structure which is regularized in nature.
So the value of the and the value of lambda will try to reduce the size of the tree and the value of
W and Gummo will try to reduce the leaf weight so that it does not overfit and it does not overflown,
so that the size of the stump is smaller here.
The entire mathematics is not really necessary for you to understand the mean things which you need
to think of is that the values of the novel and the size of the tree and Gumline W will actually involve
the weight of the leaf node.
And the objective function is the loss function, plus the more complexity which has been added in the
GBM.
So in case you have created a model and it is the overfitting, then the next model which you will be
going do would be extra to boost.
Because she to be less over for them and it will be reducing the mortgage complexity, hence it will
all be over.
So this is how you can decide actually which money you need to pick up next.
So when we are discussing all these to my face, you don't really need to remember everything from the
mathematics, but you need to know that how these things are generated.
So when you know how these things are generated and how the model is being created, it will actually
give you an indication of how the model is actually being generated, how everything is working up,
so that in case something does not go well, then you know that which hypovolemic that you need to you
like the machine guns on you.
It is the main object.
They will, Wolf.
Introducing the mathematics of any model to you is that it will allow you to understand how the world
works.
And I will be going a little overboard with the mathematics.
I will be going a little more in-depth with the mathematics.
But you need to understand the concepts behind that is the main objective here.
It is fine if you don't understand the entire mathematics of it.
The main task here is to understand how this entire thing works and to understand what the importance
of different hypovolemic does, which we have in the different algorithms, because that is exactly
what you will have.
So I have three and a different video for the how the steps for barometer tuning and for different metrics.
So you can refer to all those guidelines videos so that you can actually get to know what other mean
things which you need to focus on.
So for the entire process, I've created one guideline video which you can watch and understand the
entire process.
So next, what we will be discussing.
Is the moral complexity for the.
So here you can see that in case of will think we have the original function, this regularisation method,
when we have this lambda and the guy might be the Lambda V, so there are different kind of defining
a more complexity.
So that is one this method of defining the more complexity.
This is another method of defining the model complexity.
So all of the more complexities work in the same way, a little different from each other.
But the main task here is that the regularization has to happen.
Now, the regular is one five miles, three packages read less carefully or simply ignored.
This was because the traditional treatment of the early learning on the emphasis is on improving the
impurity by the complexity.
Control was left to heuristics by defining it formally.
We can get a better idea of what we are learning and it works well in practice.
So that is why.
We have provided different definitions and explained how these moral complexity works so that you can
actually compare the more those that you are generating and compare then modern complexities and see
which one is actually better.
If you understand the mathematics, you will know how things actually work.
So we could have gone from a very simple is will we have a loan from a very simple model to a complex
model?
But we could have directly due to the complex models that is used in random forest and we would have
done with it because these are the only wonders which you will be using very frequently.
But the main objective here was to make you understand each and every step and each and every model
because each model has some mathematics behind it.
And the mathematics from the simpler model allows you to understand the complex model more better.
So that is why we have discussed all of these models and we will be learning about different models
for them so that you will be able to understand how things work.
So here is one link for Gbagbo says Exposed wasis allied GBM, so you can go through this particular
code and see how these are coming back and how these actually work.
Now, let us discuss about the unique features of boosting so reboost is a popular implementation of
the union boosting.
So these are the important features.
The first one being regularisation.
So she has an option to penalize complex models through both L1 and Regularisation.
So the regularization helps in preventing overfitting.
So again, when you will be applying to regularization, then you can get the importance handling sparse
data and missing values or data processing steps like one or two, including maybe Despres.
So because what does one word, including one word and coding, will be giving Zettl values and one
values to the data.
So when you have a lot of zero one values, there will be a lot of land values, there will be a lot
of zettl values.
These zero values actually create the sparse data when we have a lot of values.
So of Wells incorporates us for city of finding algorithm to handle different types of sparsity patterns
in the data.
So it take years, takes care of the data in guys that are such kind of one encoded data that this dummies
which have been created from the categorical columns.
So it looks good on the go to the columns as well.
Then we have waited for four days sketch that is most exciting through this algorithm can find the split
points when the data points out of equal weight.
So if different data points are of equal weight, then it can still find out the splitting points.
However, they are not equipped to handle the data.
So in case there is some kind of latency weighted classes that this imbalance glasses, then it might
not do that well.
So H.G. Wells has distributed we did a sketch algorithm to effectively handle the data.
Next.
So exiguous can actually handle the date of the imbalanced classes very well, so next is unique features.
So again, we have block structure for parliament building.
Now in different models, there are only one jobs which could be done.
That is, we can run only one thread for those jobs, but in case of extra boost, we can actually run
several jobs together.
So for faster computing, you can make use of multiple cores on the sea view.
This is possible because of a block structure and a system design data is sorted and stored in the memory
units called blocks, unlike other algorithms.
This enables the data but will be used by subsequent iterations instead of computing it again.
So this feature also solves useful for steps like split finding and columns upsampling so you can use
multiple jobs to get better and faster of the work.
Then we have Gashi Venice, so boost non continuous memory access is required to get the baby inside
the stick index.
Hence extra boost has been designed to make optimal use of hardware.
This is done by allocating internal buffer in each thread where the gradient statistics can be stored.
So it is aware of the cache and makes use of the hardware very efficiently.
Then it has the full computing, which is same as by learning, so it will just use the codes and use
the available disk more efficiently.
So basically it because it has multiple jobs and efficiency to run in the hardware more efficiently.
So that is why it will run faster in comparison to any other modeling launched a little faster in comparison
to other models or other variants of boosting itself.
So this is about actually boosting next, we will learn about some important hypothalamic those, so
these are the type of and we do to have one is that is done.
That is the Shinkichi do.
So each new breed that is added has its weight shrunk by this parameter, preventing overvoting, but
at the cost of increasing number of rounds needed for convergence.
So as you increase the value.
So when we increase the value, what happens is that it will make sure that the previous models shrink.
That is, the weight which is provided by the previous model is reduced.
So it will prevent overfitting if you have higher added value, but it will also slow down the learning
process.
So make sure you're not reducing or increasing the item very high because then it will be very difficult
for you to find a good algorithm.
It will take a lot of time to bring.
Then we have the Gummo value, which is a three size penalty, then we have maximum statis, maximum
depth of each three Stumm minimum eaglet is the minimum wage that the Notkin have.
If the minimum is not met, then a particular split will not occur.
So that is the minimum amount, minimum number of values which should be present in the child.
Then Subsample gives the opportunity to perform.
So if we want to have all these samples of data being used for each three, then we can use subsample.
Then for example, by three, it allows to perform feature bigging.
So basically, if you want to select a subset of the variables or subset of the features, then we can
use, for example, by three.
So subsample and sample, but we are introducing the dumbness which we had in the random for this to
include boosting bolthole.
Then we have lamda value, which is the L to leave no penalty sort of penalizes the weight of the leave
not.
So this is about actually boosting so this is the entire theory which is associated with the extreme
boosting, the main task for you is to understand these different barometers and get familiar with the
two things which are present.
One is the loss function and another is the more complexity.
You don't need to get into the mathematics.
I'm reading this again because in no interview session, you will be asked about these of these domes
or of the very core mathematics.
But what you would be asked about is how one model is better than the other.
How is better than gradient boosting?
So then you can simply see that it is because of the model complexity and you can explain that the model
complexity is improving the leaf the size of the tree and the weight of the leaves.
So that is something which is important for you to understand.
The mean thrust of the concept is what you need to learn instead of making up the environment the takes,
because that is not the object of.
One should know how something works and not muck up all the mathematics behind it, so that is exactly
what we are focusing on.
That is exactly what is required in the organizations and on the field.
So that is something that we are focusing on the entire course.
So in the next session, we will go towards the implementation of boosting and see how we can implement
it.