Fix more broken links (#1040)

Co-authored-by: Saul <saul.caballero.ramirez@gmail.com>

Author: deven367

.github/workflows/build-docs.yaml

@@ -4,6 +4,18 @@ on:
     branches: [main]
   pull_request:
     branches: [main]
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: "The environment to deploy to"
+        required: true
+        type: choice
+        default: "staging"
+        options:
+          - staging
+          - production
 
 jobs:
   build-docs:
@@ -15,11 +27,10 @@ jobs:
 
       - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
         with:
-          python-version: '3.10'
+          python-version: "3.10"
 
       - name: Install dependencies
-        run: |
-          pip install -e '.[all]' lazydocs pyyaml
+        run: pip install -e '.[all]' lazydocs pyyaml
 
       # setup quarto for rendering example/tutorial nbs
       - uses: quarto-dev/quarto-actions/setup@v2
@@ -29,8 +40,18 @@ jobs:
       - name: Build Docs
         run: make all_docs
 
-      - name: Deploy
-        if: github.event_name == 'push'
+      - name: Deploy (Push to main or Pull Request)
+        if: (github.event_name == 'push' && github.ref == 'refs/heads/main') || github.event_name == 'pull_request' || (github.event_name == 'workflow_dispatch' && github.event.inputs.environment == 'staging')
+        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_branch: docs-preview
+          publish_dir: docs/mintlify
+          user_name: github-actions[bot]
+          user_email: 41898282+github-actions[bot]@users.noreply.github.com
+
+      - name: Deploy (Release)
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && github.event.inputs.environment == 'production')
         uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -39,8 +60,21 @@ jobs:
           user_name: github-actions[bot]
           user_email: 41898282+github-actions[bot]@users.noreply.github.com
 
-      - name: Trigger mintlify workflow
-        if: github.event_name == 'push'
+      - name: Trigger mintlify workflow (Push to main or Pull Request)
+        if: (github.event_name == 'push' && github.ref == 'refs/heads/main') || github.event_name == 'pull_request' || (github.event_name == 'workflow_dispatch' && github.event.inputs.environment == 'staging')
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
+        with:
+          github-token: ${{ secrets.DOCS_WORKFLOW_TOKEN }}
+          script: |
+            await github.rest.actions.createWorkflowDispatch({
+              owner: 'nixtla',
+              repo: 'docs',
+              workflow_id: 'mintlify-action-preview.yml',
+              ref: 'main',
+            });
+
+      - name: Trigger mintlify workflow (Release)
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && github.event.inputs.environment == 'production')
         uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
         with:
           github-token: ${{ secrets.DOCS_WORKFLOW_TOKEN }}

CONTRIBUTING.md

@@ -129,6 +129,13 @@ Finally to view the documentation
 make preview_docs
 ```
 
+- The docs are automatically generated from the docstrings in the `python/statsforecast` folder.
+- To contribute, ensure your docstrings follow the Google style format.
+- Once your docstring is correctly written, the documentation framework will scrape it and regenerate the corresponding `.mdx` files and your changes will then appear in the updated docs.
+- Make an appropriate entry in the `docs/mintlify/mint.json` file.
+- Run `make all_docs` to regenerate the documentation.
+- Run `make preview_docs` to view and test the documentation locally.
+
 ## Start Coding
 
 Open a jupyter notebook using `jupyter lab` (or VS Code).

Makefile

@@ -37,7 +37,6 @@ api_docs:
 examples_docs:
 	mkdir -p nbs/_extensions
 	cp -r docs-scripts/mintlify/ nbs/_extensions/mintlify
-	python docs-scripts/update-quarto.py
 	quarto render nbs/docs --output-dir ../docs/mintlify/
 	quarto render nbs/src --output-dir ../docs/mintlify/
 	quarto render nbs/blog --output-dir ../docs/mintlify/

README.md

@@ -21,5 +21,7 @@
 ---
 """
 readme_text = Path("README.md").read_text()
+# replace url with .
+readme_text = re.sub(r"https?://nixtlaverse\.nixtla\.io/", "./", readme_text)
 readme_text = header + readme_text
 (output_path / "index.mdx").write_text(readme_text)

docs/mintlify/dark.png

@@ -1,62 +1,62 @@
 ## Amazon's AutoML vs open source statistical methods
->TL;DR: We paid USD $800 USD and spend 4 hours in the AWS Forecast console so you don't have to. 
+>
+>TL;DR: We paid USD $800 USD and spend 4 hours in the AWS Forecast console so you don't have to.
 
-In this reproducible experiment, we compare [Amazon Forecast](https://aws.amazon.com/forecast/) and [StatsForecast](https://github.com/Nixtla/statsforecast) a python open-source library. For this experiment, given the prominent use of AWS Forecast in demand forecasting, we used the 30,490 series of daily sales at Walmart from the [M5 competition](https://mofc.unic.ac.cy/m5-competition/). We conclude that, for this setting,  Amazon Forecast is 60% less accurate and 669 times more expensive than running an open-source alternative in a simple cloud server. 
-
-We also provide a step-by-step guide to [reproduce the results](https://nixtla.github.io/statsforecast/examples/aws/statsforecast.html).
+In this reproducible experiment, we compare [Amazon Forecast](https://aws.amazon.com/forecast/) and [StatsForecast](https://github.com/Nixtla/statsforecast) a python open-source library. For this experiment, given the prominent use of AWS Forecast in demand forecasting, we used the 30,490 series of daily sales at Walmart from the [M5 competition](https://mofc.unic.ac.cy/m5-competition/). We conclude that, for this setting,  Amazon Forecast is 60% less accurate and 669 times more expensive than running an open-source alternative in a simple cloud server.
 
+We also provide a step-by-step guide to [reproduce the results](https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/AmazonStatsForecast)
 
 ### Amazon Forecast
-Amazon Forecast is an AutoML time-series forecasting service. 
+
+Amazon Forecast is an AutoML time-series forecasting service.
 
 > It uses machine learning (ML) to generate more accurate demand forecasts with just a few clicks, without requiring any prior ML experience. Amazon Forecast includes algorithms that are based on over twenty years of forecasting experience and developed expertise used by Amazon.com bringing the same technology used at Amazon to developers as a fully managed service, removing the need to manage resources. Amazon Forecast uses ML to learn not only the best algorithm for each item, but the best ensemble of algorithms for each item, automatically creating the best model for your data.
 
 Amazon Forecast is one of the leading forecasting services out there. You can read more about its features and pricing tiers [here](https://aws.amazon.com/forecast/).
 
-Amazon Forecast creates predictors with AutoPredictor, which involves applying the optimal combination of algorithms to each time series in your datasets.  The predictor is an Amazon Forecast model that is trained using your target time series, related time series, item metadata, and any additional datasets you include. 
+Amazon Forecast creates predictors with AutoPredictor, which involves applying the optimal combination of algorithms to each time series in your datasets.  The predictor is an Amazon Forecast model that is trained using your target time series, related time series, item metadata, and any additional datasets you include.
 
 Included algorithms range from commonly used statistical algorithms like Autoregressive Integrated Moving Average (ARIMA), to complex neural network algorithms like CNN-QR and DeepAR+.: CNN-QR, DeepAR+, Prophet, NPTS, ARIMA, and ETS.
 
-
 ### StatsForecast
 
 StatsForecast is an open-source python library from Nixtla. The library offers a collection of widely used univariate time series forecasting models, including automatic ARIMA, ETS, CES, and Theta modeling optimized for high performance using numba. It also includes a large battery of benchmarking models.
 
-For this experiment, we used a `c5d.24xlarge` EC2 instance and trained two simple statistical models: `AutoETS`, and `DynamicOptimizedTheta`. Finally, the `AutoETS` and `DynamicOptimizedTheta` models were ensembled using the median. 
-
+For this experiment, we used a `c5d.24xlarge` EC2 instance and trained two simple statistical models: `AutoETS`, and `DynamicOptimizedTheta`. Finally, the `AutoETS` and `DynamicOptimizedTheta` models were ensembled using the median.
 
 ### Main Results
 
-Amazon Forecast: 
+Amazon Forecast:
 
-* achieved 1.617 in error (measured in wRMSSE, the official evaluation metric used in the competition), 
+* achieved 1.617 in error (measured in wRMSSE, the official evaluation metric used in the competition),
 * took 4.1 hours to run,
-* and cost 803.53 USD. 
+* and cost 803.53 USD.
 
 Statsforecast with a simple ensemble of statistical methods trained on a `c5d.24xlarge` EC2 instance:
-* achieved 0.669 in error (wRMSSE), 
+
+* achieved 0.669 in error (wRMSSE),
 * took 14.5 minutes to run,
-* and cost only 1.2 USD. 
+* and cost only 1.2 USD.
 
-For this data set, we show therefore that: 
+For this data set, we show therefore that:
 
-* Amazon Forecast is 60% less accurate and 669 times more expensive than running an open-source alternative in a simple cloud server. 
-* Machine Learning methods are outperformed by classical methods in terms of speed, accuracy and cost. 
+* Amazon Forecast is 60% less accurate and 669 times more expensive than running an open-source alternative in a simple cloud server.
+* Machine Learning methods are outperformed by classical methods in terms of speed, accuracy and cost.
 
 Although using StatsForecast requires some basic knowledge of Python and cloud computing, the results are simply better for this dataset.
 
 ## Data
 
 We provide open access to the data in the following URLs:
 
-- Train set: 
+* Train set:
     `https://m5-benchmarks.s3.amazonaws.com/data/train/target.parquet`
-- Temporal exogenous variables (used by AmazonForecast): 
+* Temporal exogenous variables (used by AmazonForecast):
     `https://m5-benchmarks.s3.amazonaws.com/data/train/temporal.parquet`
-- Static exogenous variables (used by AmazonForecast): 
+* Static exogenous variables (used by AmazonForecast):
     `https://m5-benchmarks.s3.amazonaws.com/data/train/static.parquet`
-    
-The train set contains `30,490` time series. The M5 competition is hierarchical. That is, forecasts are required for different levels of aggregation: national, state, store, etc. 
+
+The train set contains `30,490` time series. The M5 competition is hierarchical. That is, forecasts are required for different levels of aggregation: national, state, store, etc.
 
 ## Experiment
 
@@ -72,7 +72,6 @@ Where the `RMSSE` is defined by,
 
 The `wRMSSE` is the official metric used in the M5 competition.
 
-
 Detailed results per dataset are shown below.
 
 ## Results
@@ -89,15 +88,15 @@ The following table shows the performance across all levels of the hierarchy:
 
 ### Time
 
-Excluding time spent in the console and just accounting for processing and computing time, Amazon Forecast took 4.1 hours to run. In comparison, StatsForecast took just 15 minutes to run. Running time accounts for the end-to-end pipeline including loading data, training and forecasting. 
+Excluding time spent in the console and just accounting for processing and computing time, Amazon Forecast took 4.1 hours to run. In comparison, StatsForecast took just 15 minutes to run. Running time accounts for the end-to-end pipeline including loading data, training and forecasting.
 
-### Cost 
+### Cost
 
-Amazon included a cost calculator that is quite accurate. The estimated cost was 803.53     USD. 
+Amazon included a cost calculator that is quite accurate. The estimated cost was 803.53     USD.
 
 In comparison, we paid 1.2 USD of EC2 associated costs. (This could have been further reduced by using spot instances.)
 
-Below, you can find the detailed results. 
+Below, you can find the detailed results.
 
 **Speed and Cost on M5 Data set**
 
@@ -115,6 +114,7 @@ This conclusion might or not hold in other datasets, however, given the a priori
 Although this experiment does not focus on comparing machine learning and deep learning vs statistical methods, it supports our [previous conclusions](https://github.com/Nixtla/statsforecast/tree/main/experiments/m3) on the current validity of simpler methods for many forecasting tasks.
 
 ## Unsolicited Advice
+
 Choose your models wisely.
 
 It would be extremely expensive and borderline irresponsible to favor AutoML in an organization before establishing solid baselines.
@@ -124,4 +124,5 @@ Simpler is sometimes better. Not everything that glows is gold.
 Go and try other great open-source libraries like GluonTS, Darts and Sktime.
 
 ## Reproducibility
-You can fully reproduce the experiment by following [this step-by-step notebook](https://nixtla.github.io/statsforecast/examples/aws/statsforecast.html).
+
+You can fully reproduce the experiment by following [this step-by-step notebook](https://nixtlaverse.nixtla.io/statsforecast/docs/experiments/AmazonStatsForecast).

docs/mintlify/light.png

@@ -5,10 +5,11 @@ We are excited to release the only implementation for Python of the Complex Expo
 ![](cspweights.png)
 
 The CES model has two main advantages over conventional exponential smoothing models:
+
 * it can model and forecast both stationary and non-stationary processes and
 * it can capture both level and trend cases
 
-Our implementation, optimized using numba, was tested on the M4 dataset (100k time series), getting similar accuracy and computational time results than the original implementation in R. 
+Our implementation, optimized using numba, was tested on the M4 dataset (100k time series), getting similar accuracy and computational time results than the original implementation in R.
 
 Additionally, with StatsForecast you can easly build ensembles of all statstical models. In this experiment, we show how the ensemble between ETS and CES gives the best results.
 
@@ -26,19 +27,17 @@ Additionally, with StatsForecast you can easly build ensembles of all statstical
 
 ## References
 
-* Check the StatsForecast [documentation](https://nixtla.github.io/statsforecast/models.html#autoces) on the CES
+* Check the StatsForecast [documentation](https://nixtlaverse.nixtla.io/statsforecast/models#class-autoces) on the CES
 * [Link](https://forecasting.svetunkov.ru/wp-content/uploads/2022/07/Svetunkov-et-al.-2022-Complex-Exponential-Smoothing.pdf) to the original paper
 * [Link](https://forecasting.svetunkov.ru/en/2022/08/02/the-long-and-winding-road-the-story-of-complex-exponential-smoothing/) to the story of the paper
 
-
-
 ## Reproducibility
 
 To reproduce the main results you have:
 
-1. Execute `make init`. 
+1. Execute `make init`.
 2. Activate the environment using `conda activate ces`.
 3. Run the experiments using `python -m src.ces --dataset M4 --group [group]` where `[model]` can be `[group]` can be `Hourly`, `Daily`, `Weekly`, `Monthly`, `Quarterly`, and `Yearly`.
 4. Compute the ensemble model using `python -m src.ensemble --dataset M4 --group [group]` where `[model]` can be `[group]` can be `Hourly`, `Daily`, `Weekly`, `Monthly`, `Quarterly`, and `Yearly`.
-4. To run R experiments you have to prepare the data using `python -m src.data --dataset M4 --group [group]` for each `[group]`. Once it is done, just run `make run_module module="Rscript src/ces_r.R [group]"`.
-5. Finally you can evaluate the forecasts using `make run_module module="python -m src.evaluation"`.
+5. To run R experiments you have to prepare the data using `python -m src.data --dataset M4 --group [group]` for each `[group]`. Once it is done, just run `make run_module module="Rscript src/ces_r.R [group]"`.
+6. Finally you can evaluate the forecasts using `make run_module module="python -m src.evaluation"`.