regenerate tutorials

Author: ablaom

__site/advanced/ensembles-3/index.html

@@ -13,7 +13,7 @@ networks.
 
 Learning networks are an advanced MLJ feature which are covered in detail, with
 examples, in the [Learning
-networks](https://JuliaAI.github.io/MLJ.jl/dev/learning_networks/) section
+networks](https://alan-turing-institute.github.io/MLJ.jl/dev/learning_networks/) section
 of the manual. In the "Ensemble" and "Ensemble (2)" tutorials it is shown how to create
 and apply homogeneous ensembles using MLJ's built-in `EnsembleModel` wrapper. To provide
 a simple illustration of learning networks we show how a user could build their own
@@ -24,7 +24,7 @@ selection of features in each split of a decision tree).
 For a more advanced illustration, see the "Stacking" tutorial.
 
 Some familiarity with the early parts of [Learning networks by
-example](https://JuliaAI.github.io/MLJ.jl/dev/learning_networks/#Learning-networks-by-example)
+example](https://alan-turing-institute.github.io/MLJ.jl/dev/learning_networks/#Learning-networks-by-example)
 will be helpful, but is not essential.
 
 @@dropdown

__site/advanced/stacking/index.html

@@ -17,13 +17,13 @@ intensive. Nevertheless, stacking has been used successfully by teams in data sc
 science competitions.
 
 For routine stacking tasks the MLJ user should use the `Stack` model documented
-[here](https://JuliaAI.github.io/MLJ.jl/dev/composing_models/#Model-Stacking). Internally,
+[here](https://alan-turing-institute.github.io/MLJ.jl/dev/composing_models/#Model-Stacking). Internally,
 `Stack` is implemented using MLJ's learning networks feature, and the purpose of this
 tutorial give an advanced illustration of MLJ learning networks by presenting a
 simplified version of this implementation. Familiarity with model stacking is not
 essential, but we assume the reader is already familiar with learning network basics, as
 illustrated in the [Learning
-networks](https://JuliaAI.github.io/MLJ.jl/dev/learning_networks/) section
+networks](https://alan-turing-institute.github.io/MLJ.jl/dev/learning_networks/) section
 of the MLJ manual. The "Ensembles (learning networks)" tutorial also gives a simple
 illustration.
 

__site/assets/literate/advanced/ensembles-3/tutorial.md

@@ -81,7 +81,7 @@ first(capacity, 5)
 
 This dataframe contains several subgroups (country and technology type) and it would be interesting to get data aggregates by subgroup.
 To obtain a `view` of the DataFrame by subgroup, we can use the `groupby` function.
-(See the [DataFrame tutorial](https://JuliaAI.github.io/DataScienceTutorials.jl/data/dataframe/#groupby) for an introduction to the use of `groupby`)
+(See the [DataFrame tutorial](https://alan-turing-institute.github.io/DataScienceTutorials.jl/data/dataframe/#groupby) for an introduction to the use of `groupby`)
 
 ````julia:ex9
 cap_gr = groupby(capacity, [:country, :primary_fuel]);

__site/assets/literate/advanced/stacking/tutorial.md

@@ -151,7 +151,7 @@ Can we do even better? Yeah, we can!! We can make use of Model Tuning.
 @@
 @@dropdown-content
 
-In case you are new to model tuning using MLJ, refer [lab5](https://JuliaAI.github.io/DataScienceTutorials.jl/isl/lab-5/) and [model-tuning](https://JuliaAI.github.io/DataScienceTutorials.jl/getting-started/model-tuning/)
+In case you are new to model tuning using MLJ, refer [lab5](https://alan-turing-institute.github.io/DataScienceTutorials.jl/isl/lab-5/) and [model-tuning](https://alan-turing-institute.github.io/DataScienceTutorials.jl/getting-started/model-tuning/)
 
 Range of values for parameters should be specified to do hyperparameter tuning
 

__site/assets/literate/data/processing/tutorial.md

@@ -103,7 +103,7 @@ nnregressor = MLJFlux.NeuralNetworkRegressor(builder=myregressor, epochs=10)
 ````
 
 Other parameters that NeuralNetworkRegressor takes can be found here:
-https://github.com/JuliaAI/MLJFlux.jl#model-hyperparameters
+https://github.com/alan-turing-institute/MLJFlux.jl#model-hyperparameters
 
 `nnregressor` now acts like any other MLJ model. Let's try wrapping it in a
 MLJ machine and calling `fit!, predict`.

__site/assets/literate/end-to-end/airfoil/tutorial.md

@@ -79,7 +79,7 @@ data; to facilitate the interpretation, we can use `autotype` from `ScientificTy
 By default, `autotype` will check all columns and suggest a Finite type assuming there
 are relatively few distinct values in the column.  More sophisticated rules can be
 passed, see
-[ScientificTypes.jl](https://JuliaAI.github.io/ScientificTypes.jl/dev/):
+[ScientificTypes.jl](https://alan-turing-institute.github.io/ScientificTypes.jl/dev/):
 
 ````julia:ex5
 coerce!(data, autotype(data));

__site/assets/literate/end-to-end/boston-flux/tutorial.md

@@ -138,7 +138,7 @@ schema(data)
 ````
 
 It is important that the scientific type of the variables corresponds to one of the types allowed for use with the models you are planning to use.
-(For more guidance on this, see the [Scientific Type](https://JuliaAI.github.io/DataScienceTutorials.jl/data/scitype/) tutorial.
+(For more guidance on this, see the [Scientific Type](https://alan-turing-institute.github.io/DataScienceTutorials.jl/data/scitype/) tutorial.
 The scientific type of both `Wind_gen` and `Solar_gen` is currently `Count`. Let's coerce them to `Continuous`.
 
 ````julia:ex13

__site/assets/literate/end-to-end/horse/tutorial.md

@@ -9,7 +9,7 @@ end;
 ````
 
 An application of the [MLJ
-toolbox](https://JuliaAI.github.io/MLJ.jl/dev/) to the
+toolbox](https://alan-turing-institute.github.io/MLJ.jl/dev/) to the
 Telco Customer Churn dataset, aimed at practicing data scientists
 new to MLJ (Machine Learning in Julia). This tutorial does not
 cover exploratory data analysis.
@@ -18,9 +18,9 @@ MLJ is a general machine learning toolbox (i.e., not just
 deep-learning).
 
 For other MLJ learning resources see the [Learning
-MLJ](https://JuliaAI.github.io/MLJ.jl/dev/learning_mlj/)
+MLJ](https://alan-turing-institute.github.io/MLJ.jl/dev/learning_mlj/)
 section of the
-[manual](https://JuliaAI.github.io/MLJ.jl/dev/).
+[manual](https://alan-turing-institute.github.io/MLJ.jl/dev/).
 
 **Topics covered**: Grabbing and preparing a dataset, basic
 fit/predict workflow, constructing a pipeline to include data
@@ -94,7 +94,7 @@ introducing the main actors in any MLJ workflow. Details that you
 don't fully grasp should become clearer in the Telco study.
 
 This section is a condensed adaption of the [Getting Started
-example](https://JuliaAI.github.io/MLJ.jl/dev/getting_started/#Fit-and-predict)
+example](https://alan-turing-institute.github.io/MLJ.jl/dev/getting_started/#Fit-and-predict)
 in the MLJ documentation.
 
 First, using the built-in iris dataset, we load and inspect the features
@@ -145,7 +145,7 @@ fitted_params(mach)
 ````
 
 A machine stores some other information enabling [warm
-restart](https://JuliaAI.github.io/MLJ.jl/dev/machines/#Warm-restarts)
+restart](https://alan-turing-institute.github.io/MLJ.jl/dev/machines/#Warm-restarts)
 for some models, but we won't go into that here. You are allowed to
 access and mutate the `model` parameter:
 
@@ -360,7 +360,7 @@ ytest, Xtest = unpack(df_test, ==(:Churn), !=(:customerID));
 *Introduces:* `@load`, `input_scitype`, `target_scitype`
 
 For tools helping us to identify suitable models, see the [Model
-Search](https://JuliaAI.github.io/MLJ.jl/dev/model_search/#model_search)
+Search](https://alan-turing-institute.github.io/MLJ.jl/dev/model_search/#model_search)
 section of the manual. We will build a gradient tree-boosting model,
 a popular first choice for structured data like we have here. Model
 code is contained in a third-party package called
@@ -428,7 +428,7 @@ pipe = ContinuousEncoder() |> booster
 
 Note that the component models appear as hyper-parameters of
 `pipe`. Pipelines are an implementation of a more general [model
-composition](https://JuliaAI.github.io/MLJ.jl/dev/composing_models/#Composing-Models)
+composition](https://alan-turing-institute.github.io/MLJ.jl/dev/composing_models/#Composing-Models)
 interface provided by MLJ that advanced users may want to learn about.
 
 From the above display, we see that component model hyper-parameters
@@ -622,7 +622,7 @@ observation space, for a total of 18 folds) and set
 `acceleration=CPUThreads()` to parallelize the computation.
 
 We choose a `StratifiedCV` resampling strategy; the complete list of options is
-[here](https://JuliaAI.github.io/MLJ.jl/dev/evaluating_model_performance/#Built-in-resampling-strategies).
+[here](https://alan-turing-institute.github.io/MLJ.jl/dev/evaluating_model_performance/#Built-in-resampling-strategies).
 
 ````julia:ex49
 e_pipe = evaluate(pipe, X, y,
@@ -692,7 +692,7 @@ eg, the neural network models provided by
 [MLJFlux.jl](https://github.com/FluxML/MLJFlux.jl).
 
 First, we select appropriate controls from [this
-list](https://JuliaAI.github.io/MLJ.jl/dev/controlling_iterative_models/#Controls-provided):
+list](https://alan-turing-institute.github.io/MLJ.jl/dev/controlling_iterative_models/#Controls-provided):
 
 ````julia:ex51
 controls = [
@@ -751,7 +751,7 @@ here is the `learning_curve` function, which can be useful when
 wanting to visualize the effect of changes to a *single*
 hyper-parameter (which could be an iteration parameter). See, for
 example, [this section of the
-manual](https://JuliaAI.github.io/MLJ.jl/dev/learning_curves/)
+manual](https://alan-turing-institute.github.io/MLJ.jl/dev/learning_curves/)
 or [this
 tutorial](https://github.com/ablaom/MLJTutorial.jl/blob/dev/notebooks/04_tuning/notebook.ipynb).
 
@@ -791,7 +791,7 @@ Nominal ranges are defined by specifying `values` instead of `lower`
 and `upper`.
 
 Next, we choose an optimization strategy from [this
-list](https://JuliaAI.github.io/MLJ.jl/dev/tuning_models/#Tuning-Models):
+list](https://alan-turing-institute.github.io/MLJ.jl/dev/tuning_models/#Tuning-Models):
 
 ````julia:ex56
 tuning = RandomSearch(rng=rng)
@@ -880,7 +880,7 @@ savefig(joinpath(@OUTPUT, "EX-telco-tuning.svg")); # hide
 Here's how to serialize our final, trained self-iterating,
 self-tuning pipeline machine using Julia's native serializer (see
 [the
-manual](https://JuliaAI.github.io/MLJ.jl/dev/machines/#Saving-machines)
+manual](https://alan-turing-institute.github.io/MLJ.jl/dev/machines/#Saving-machines)
 for more options):
 
 ````julia:ex63

__site/assets/literate/end-to-end/powergen/tutorial.md

@@ -5,7 +5,7 @@ Pkg.activate("_literate/getting-started/fit-predict/Project.toml")
 Pkg.instantiate()
 ````
 
-[MLJ.jl]: https://github.com/JuliaAI/MLJ.jl
+[MLJ.jl]: https://github.com/alan-turing-institute/MLJ.jl
 [RDatasets.jl]: https://github.com/JuliaStats/RDatasets.jl
 [DecisionTree.jl]: https://github.com/bensadeghi/DecisionTree.jl
 

__site/assets/literate/end-to-end/telco/tutorial.md

@@ -5,9 +5,9 @@ Pkg.activate("_literate/getting-started/model-choice/Project.toml")
 Pkg.instantiate()
 ````
 
-[MLJ.jl]: https://github.com/JuliaAI/MLJ.jl
+[MLJ.jl]: https://github.com/alan-turing-institute/MLJ.jl
 [RDatasets.jl]: https://github.com/JuliaStats/RDatasets.jl
-[MLJModels.jl]: https://github.com/JuliaAI/MLJModels.jl
+[MLJModels.jl]: https://github.com/alan-turing-institute/MLJModels.jl
 [DecisionTree.jl]: https://github.com/bensadeghi/DecisionTree.jl
 [NearestNeighbors.jl]: https://github.com/KristofferC/NearestNeighbors.jl
 [GLM.jl]: https://github.com/JuliaStats/GLM.jl

__site/assets/literate/getting-started/fit-predict/tutorial.md

@@ -8,7 +8,7 @@ macro OUTPUT()
 end
 ````
 
-[MLJ.jl]: https://github.com/JuliaAI/MLJ.jl
+[MLJ.jl]: https://github.com/alan-turing-institute/MLJ.jl
 [RDatasets.jl]: https://github.com/JuliaStats/RDatasets.jl
 [NearestNeighbors.jl]: https://github.com/KristofferC/NearestNeighbors.jl
 

__site/assets/literate/getting-started/model-choice/tutorial.md

@@ -30,6 +30,10 @@ Note the use of `rng=` to seed the shuffling of indices so that the results are
 @@
 @@dropdown-content
 
+This tutorial introduces polynomial regression in a very hands-on way. A more
+programmatic alternative is to use MLJ's `InteractionTransformer`. Run
+`doc("InteractionTransformer")` for details.
+
 ````julia:ex3
 LR = @load LinearRegressor pkg=MLJLinearModels
 ````

__site/assets/literate/getting-started/model-tuning/tutorial.md

@@ -119,7 +119,7 @@ To coerce `int` features to `Float`, we nest the `autotype` function in the `coe
 function.  The `autotype` function returns a dictionary containing scientific types,
 which is then passed to the `coerce` function.  For more details on the use of
 `autotype`, see the [Scientific
-Types](https://JuliaAI.github.io/DataScienceTutorials.jl/data/scitype/index.html#autotype)
+Types](https://alan-turing-institute.github.io/DataScienceTutorials.jl/data/scitype/index.html#autotype)
 
 ````julia:ex9
 Xc = coerce(X, autotype(X, rules = (:discrete_to_continuous,)))