refit | The automatic type-safe REST library for .NET Core, Xamarin and .NET. Heavily inspired by Square's R | Form library

You can simply reuse the .fit() call available to the estimator on the new data.

This would be preferred, especially in a time series, as the signal changes and you do not want older, non-representative data to be understood as potentially normal (or anomalous).

If old data is important, you can simply join the older training data and newer input signal data together, and then call .fit() again.

Also sidenote, according to sklearn documentation, it is better to use joblib than pickle

An MRE with resources below:

Import GensimWord2VecVectorizer in your Flask Web app python file.

Alright so I think I got this dialed in. I wont go over the how, other than to say that once you study the code enough the black magic doesn't go away but patterns do emerge. I just extended those patterns and it looks like it works.

End result

Admittedly this is so low res that it look like its not changing from C=1 to C=2 but it is. Load it up and you'll see. The gif should show the flow more cleary now.

First the methodology behind the proof. I found a funky surface equation and added a third input variable C (in-effect creating a 4D surface), then studied the surface shape with fixed C values using the original 3D fitter/renderer as a point of trusted reference.

When C is 1, you get a half pipe from hell. A slightly lopsided downsloping halfpipe.

Whence C is 2, you get much the same but the lopsidedness is even more exaggerated.

When C is 3, you get a very different shape. Like the exaggerated half pipe from above was cut in half, reversed, and glued back together.

When you run the below code, you get a 3D render with a slider that allows you to flow through the C values from 1 to 3. The values at 1, 2, and 3 look like solid matches to the references. I also added a randomizer to the data to see how it would perform at approximating a surface from imperfect noisy data and I like what I see there too.

Props to the below questions for their code and ideas.

Python 3D polynomial surface fit, order dependent

python visualize 4d data with surface plot and slider for 4th variable

Within a given call to refit, you're not changing c, so c has the same value in the second print() that it does in the first print(). All the recursive calls happen in between those two print calls.

On the first call, c is []:

The point of refit is that the model will be refitted using the best parameter set found before and the entire dataset. To find the best parameters, cross-validation is used which means that the dataset is always split into a training and a validation set, i.e. not the entire dataset is used for training here.

When you define multiple metrics, you have to tell scikit-learn how it should determine what best means for you. For convenience, you can just specify any of your scorers to be used as the decider so to say. In that case, the parameter set that maximizes this metric will be used for refitting.

If you want something more sophisticated, like taking the parameter set that returned the highest mean of all scorers, you have to pass a function to refit that given all the created metrics returns the index of the corresponding best parameter set. This parameter set will then be used to refit the model.

Those metrics will be passed as a dictionary of strings as keys and NumPy arrays as values. Those NumPy arrays have as many entries as parameter sets that have been evaluated. You find a lot of things in there. What is probably the most relevant is mean_test_*scorer-name*. Those arrays contain for each tested parameter set the mean scorer-name-scorer computed across the cv splits.

In code, to get the index of the parameter set, that returns the highest mean across all scorers, you can do the following

The order of the steps in a Pipeline matters, and only the last step can be a non-transformer like your svc.

Found it, with help from a colleague! Turns out the HttpResponseMessage needs some/any RequestMessage.

Change

RidgeClassifierCV allows you to perform cross validation and find the best alpha with respect to your dataset.

GridSearchCV allows you not only to finetune an estimator but the preprocessing steps of a Pipeline as well.

From the documentation, The advantage of an EstimatorCV such as RidgeClassifierCV is that they can take advantage of warm-starting by reusing precomputed results in the previous steps of the cross-validation process. This generally leads to speed improvements.

As a conclusion if you are only trying to finetune a ridge classifier, RidgeClassifierCV should be the best choice as it might be faster. However if you are having extra preprocessing steps, it should be better to use GridSearchCV.

You can use: