diff --git a/docs/en/3-Pipelines/Argo.md b/docs/en/3-Pipelines/Argo.md
index 45ab86835..59fa75824 100644
--- a/docs/en/3-Pipelines/Argo.md
+++ b/docs/en/3-Pipelines/Argo.md
@@ -7,7 +7,7 @@
Full documentation can be found [here](https://argoproj.github.io/argo-workflows/walk-through/).
-Argo Workflows allows you to
+Argo Workflows have these advantages:
- Workflow tasks can be defined as scripts (ex. python) or be containerized (ex. docker).
- Complex workflows can be modeled using Directed Acyclic graphs (DAGs) to capture dependency chains.
@@ -158,7 +158,7 @@ Use the following `Dockerfile` as a starting point for your `R` and `Python` pro
#### 3. Write your workflow in YAML
-YAML is Yet Another Markup Language and you'll need to write down the steps of your training pipeline in an Argo Workflows YAML file. This file should include reference to the Dockerfile you created in [Step 1](#2-write-a-dockerfile-to-run-your-code), as well as any input data and output data you'll be working with.
+YAML is Yet Another Markup Language and you'll need to write down the steps of your training pipeline in an Argo Workflows YAML file. This file should include reference to the Dockerfile you created in [Step 2](#2-write-a-dockerfile-to-run-your-code), as well as any input data and output data you'll be working with.
Here is an example YAML file for a simple machine learning pipeline that trains a logistic regression model on the iris dataset. The only real difference between the `Python` and `R` versions is the command `command: ["python", "train.py"]` vs `command: ["Rscript", "train.R"]` and the models are stored in different formats, `pkl` for `python` and `rds` for `R`.
diff --git a/docs/en/3-Pipelines/PaaS.md b/docs/en/3-Pipelines/PaaS.md
deleted file mode 100644
index 663e84195..000000000
--- a/docs/en/3-Pipelines/PaaS.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Overview
-
-## Integrate with Platforms like Databricks and AzureML
-
-The AAW platform is built around the idea of integrations, and so we can
-integrate with many _Platform as a Service_ (PaaS) offerings, such as
-[Azure ML](https://azure.microsoft.com/en-us/services/machine-learning/) and
-[Databricks](https://azure.microsoft.com/en-ca/services/databricks/).
-
-See some examples on our
-["MLOps" github Repo](https://github.com/StatCan/aaw-kubeflow-mlops).
-
-
-
-# Setup
-
-If you need help integrating with a platform as a service offering, we're happy
-to help!
diff --git a/docs/fr/3-Pipelines/Argo.md b/docs/fr/3-Pipelines/Argo.md
new file mode 100644
index 000000000..f33060ea3
--- /dev/null
+++ b/docs/fr/3-Pipelines/Argo.md
@@ -0,0 +1,383 @@
+
+## Flux de travail Argo
+
+
+
+**[Flux de travail Argo](https://argoproj.github.io/argo-workflows/)** est un moteur de flux de travail open source natif de conteneur pour orchestrer des tâches parallèles sur Kubernetes. Les flux de travails Argo sont implémentés en tant que Kubernetes CRD (Custom Resource Definition). Il est particulièrement adapté aux flux de travail de science des données et aux flux de travail d’apprentissage automatique.
+
+La documentation complète peut être trouvée [ici](https://argoproj.github.io/argo-workflows/walk-through/).
+
+Les flux de travails Argo ont les avantages suivants:
+
+- Les tâches de workflow peuvent être définies sous forme de scripts (ex. Python) ou être conteneurisées (ex. Docker).
+- Des flux de travail complexes peuvent être modélisés à l'aide de graphes acycliques dirigés (DAG) pour capturer les chaînes de dépendance.
+- Les tâches indépendantes peuvent être exécutées en parallèle avec une granularité jusqu'au niveau de mise en œuvre, réduisant ainsi les charges de tâches chronophages.
+- Agnositique de la plateforme Kubernetes, ce qui signifie que votre travail est très portable.
+
+Avec les flux de travails Argo, vous pouvez facilement créer des flux de travails qui intègrent des tâches telles que des constructions et des déploiements automatisés, le prétraitement des données, la formation de modèles et le déploiement de modèles, le tout dans un environnement Cloud Native Kubernetes.
+
+
+!!! info ""
+
+ [](https://argoproj.github.io/argo-workflows/)
+ Flux de travail Argo
+
+
+Vous trouverez ci-dessous un exemple de cas d'utilisation de flux de travail Argo, dans lequel nous formons un modèle d'apprentissage automatique à l'aide des flux de travail Argo sur AAW.
+
+#### 1. Écrivez un script pour entraîner votre modèle
+
+Voici un exemple de script qui entraîne un modèle de régression logistique sur l'ensemble de données iris. N'oubliez pas de consulter le code de chaque langue ci-dessous.
+
+=== "Python"
+
+ ``` python title="train.py" linenums="1"
+ #!/usr/bin/env python
+
+ # Importer les bibliothèques nécessaires
+ import argparse
+ import pandas as pd
+ from sklearn.datasets import load_iris
+ from sklearn.linear_model import LogisticRegression
+ from sklearn.model_selection import train_test_split
+ from sklearn.metrics import accuracy_score
+ import joblib
+
+ # Analyser les arguments d'entrée
+ parser = argparse.ArgumentParser(description="Train logistic regression model on iris dataset.")
+ parser.add_argument("--input", default="iris.csv", help="Path to input dataset file.")
+ parser.add_argument("--output", default="model.pkl", help="Path to output model file.")
+ args = parser.parse_args()
+
+ # Charger l'ensemble de données d'iris
+ data = load_iris()
+ X, y = data.data, data.target
+
+ # Divisez les données en ensembles d'entraînement et de test
+ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+ # Entraîner un modèle de régression logistique
+ clf = LogisticRegression(random_state=42)
+ clf.fit(X_train, y_train)
+
+ # Évaluer le modèle sur l'ensemble de test
+ y_pred = clf.predict(X_test)
+ accuracy = accuracy_score(y_test, y_pred)
+ print("Accuracy:", accuracy)
+
+ # Enregistrer le modèle dans un fichier
+ joblib.dump(clf, args.output)
+ ```
+
+=== "R"
+
+ ``` r title="train.R" linenums="1"
+ #!/usr/bin/env Rscript
+
+ # Importer les bibliothèques nécessaires
+ library(caret)
+
+ # Copier les arguments d'entrée
+ args <- commandArgs(trailingOnly = TRUE)
+ input_file <- ifelse(length(args) > 0, args[1], "iris.csv")
+ output_file <- ifelse(length(args) > 1, args[2], "model.rds")
+
+ # Charger l'ensemble de données d'iris
+ data(iris)
+ X <- iris[, 1:4]
+ y <- iris[, 5]
+
+ # Divisez les données en ensembles d'entraînement et de test
+ set.seed(42)
+ train_index <- createDataPartition(y, p = 0.8, list = FALSE)
+ X_train <- X[train_index, ]
+ y_train <- y[train_index]
+ X_test <- X[-train_index, ]
+ y_test <- y[-train_index]
+
+ # Entraîner un modèle de régression logistique
+ clf <- train(x = X_train, y = y_train, method = "glm")
+
+ # Évaluer le modèle sur l'ensemble de test
+ y_pred <- predict(clf, newdata = X_test)
+ accuracy <- confusionMatrix(y_pred, y_test)$overall["Accuracy"]
+ print(paste0("Accuracy: ", accuracy))
+
+ # Enregistrer le modèle dans un fichier
+ saveRDS(clf, output_file)
+ ```
+#### 2. Écrivez un Dockerfile pour exécuter votre code
+
+Vous aurez besoin d'un Dockerfile qui inclut toutes les dépendances nécessaires pour entraîner votre modèle d'apprentissage automatique. Cela pourrait inclure:
+
+- des paquets comme
+ - `scikit-learn`, `pandas` ou `numpy` si vous utilisez `Python`
+ - `caret`, `janitor` et `tidyverse` si vous utilisez `R`
+- vos propres bibliothèques ou scripts personnalisés
+- le code de votre modèle d'apprentissage automatique sous la forme d'un script [comme dans l'exemple ci-dessus](#1-ecrivez-un-script-pour-entrainer-votre-modele).
+
+Utilisez le `Dockerfile` suivant comme point de départ pour vos projets `R` et `Python`.
+
+=== "Python"
+
+ ``` docker title="Dockerfile" linenums="1"
+ FROM python:3.8-slim-buster
+
+ # Installez toutes les dépendances nécessaires
+ RUN pip install --no-cache-dir scikit-learn pandas numpy
+
+ # Définir le répertoire de travail
+ WORKDIR /app
+
+ # Copier le code dans le conteneur
+ COPY train.py .
+
+ # Définir le point d'entrée
+ ENTRYPOINT ["python", "train.py"]
+ ```
+
+=== "R"
+ ``` docker title="Dockerfile" linenums="1"
+ FROM rocker/r-base:latest
+
+ RUN apt-get update && apt-get install -y --no-install-recommends \
+ libssl-dev \
+ libcurl4-openssl-dev \
+ libxml2-dev \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
+
+ RUN R -e 'install.packages(c("caret", "janitor", "tidyverse"))'
+
+ COPY train.R /app/train.R
+
+ WORKDIR /app
+
+ ENTRYPOINT ["Rscript", "train.R"]
+ ```
+
+#### 3. Écrivez votre flux de travail en YAML
+
+YAML est encore un autre langage de balisage et vous devrez écrire les étapes de votre pipeline de formation dans un fichier YAML Argo Workflows. Ce fichier doit inclure une référence au Dockerfile que vous avez créé à l'[Étape 1](#2-ecrivez-un-dockerfile-pour-executer-votre-code), ainsi que toutes les données d'entrée et de sortie avec lesquelles vous travaillerez.
+
+Voici un exemple de fichier YAML pour un pipeline d'apprentissage automatique simple qui entraîne un modèle de régression logistique sur l'ensemble de données iris. La seule vraie différence entre les versions `Python` et `R` est la commande `command: ["python", "train.py"]` vs `command: ["Rscript", "train.R"]` et le les modèles sont stockés dans différents formats, `pkl` pour `python` et `rds` pour `R`.
+
+Le fichier YAML définit une seule étape appelée `train` qui exécute un script appelé `train.py` ou `train.R` dans l'image Docker `machine-learning:v1`. Le script prend un fichier d'ensemble de données d'entrée, spécifié par un paramètre appelé `dataset`, et génère un fichier de modèle entraîné vers un artefact de sortie appelé `model.pkl` ou `model.rds` selon le langage utilisé.
+
+=== "Python"
+ ``` yaml title="workflow.yaml" linenums="1"
+ apiVersion: argoproj.io/v1alpha1
+ kind: Workflow
+ metadata:
+ generateName: ml-pipeline-
+ spec:
+ entrypoint: train
+ templates:
+ - name: train
+ container:
+ image: machine-learning:v1
+ command: ["python", "train.py"]
+ args: ["--input", "{{inputs.parameters.dataset}}", "--output", "{{outputs.artifacts.model}}"]
+ inputs:
+ parameters:
+ - name: dataset
+ default: "iris.csv"
+ outputs:
+ artifacts:
+ - name: model
+ path: /output/model.pkl
+ ```
+=== "R"
+ ``` yaml title="workflow.yaml" linenums="1"
+ apiVersion: argoproj.io/v1alpha1
+ kind: Workflow
+ metadata:
+ generateName: ml-pipeline-
+ spec:
+ entrypoint: train
+ templates:
+ - name: train
+ container:
+ image: machine-learning:v1
+ command: ["Rscript", "train.R"]
+ args: ["--input", "{{inputs.parameters.dataset}}", "--output", "{{outputs.artifacts.model}}"]
+ inputs:
+ parameters:
+ - name: dataset
+ default: "iris.csv"
+ outputs:
+ artifacts:
+ - name: model
+ path: /output/model.rds
+ ```
+
+#### 4. Soumettez le flux de travail à l'aide de l'entrée de ligne de commande(CLI) du flux de travail Argo
+
+Pour exécuter le flux de travail ci-dessus, vous devrez d'abord envoyer le Dockerfile vers notre registre de conteneurs, puis soumettre le fichier YAML à l'aide de la commande `argo submit`. Une fois le pipeline terminé, vous pouvez récupérer le fichier de modèle entraîné en téléchargeant l'artefact de sortie à partir de la commande `argo logs`.
+
+``` bash title="Terminal"
+$ argo submit workflow.yaml # soumettre une spécification de flux de travail à Kubernetes
+```
+
+Il est également possible de soumettre des workflows argo à partir des workflows à l'aide de SDK et d'appels API (c'est juste un autre service Web !). Voir cette [section](#exemples-utilisant-des-sdk-bases-sur-flux-de-travail-argo).
+
+#### 5. Surveillez le pipeline à l'aide de la CLI du flux de travail Argo
+
+Pendant l'exécution du pipeline, vous pouvez surveiller sa progression à l'aide de la CLI Argo Workflows. Cela vous montrera quelles étapes se sont terminées avec succès et lesquelles sont toujours en cours. Vous trouverez ci-dessous quelques commandes utiles. Pour plus d'informations sur la CLI Argo Workflows, veuillez consulter [la documentation officielle de la CLI Argo Workflows](https://argoproj.github.io/argo-workflows/walk-through/argo-cli/) .
+
+``` bash title="Terminal"
+$ argo list # lister les flux de travail actuels
+$ argo get workflow-xxx # obtenir des informations sur un flux de travail spécifique
+$ argo logs workflow-xxx # imprimer les journaux d'un flux de travail
+$ argo delete workflow-xxx # suprimer un flux de travail
+
+```
+
+#### 6. Récupérer le modèle entraîné
+
+Une fois la pipeline terminé, vous pouvez récupérer les données de sortie à l'aide de la commande argo logs ou en affichant les artefacts de sortie à l'aide de la CLI, c'est-à-dire accéder au répertoire que vous avez spécifié dans votre script et localiser le fichier `model.pkl` ou `model.rds`. L'extrait de code suivant, extrait du [script de formation ci-dessus](#1-ecrivez-un-script-pour-entrainer-votre-modele), indique au langage de programmation respectif où enregistrer le modèle entraîné.
+
+=== "Python"
+
+ ``` python title="Saving Output Data" linenums="1"
+ #!/usr/bin/env python
+
+ parser.add_argument("--output", default="model.pkl", help="Path to output model file.")
+
+ # Enregistrer le modèle dans un fichier
+ joblib.dump(clf, args.output)
+ ```
+
+=== "R"
+
+ ``` r title="Saving Output Data" linenums="1"
+ #!/usr/bin/env Rscript
+
+ output_file <- ifelse(length(args) > 1, args[2], "model.rds")
+
+ # Enregistrer le modèle dans un fichier
+ saveRDS(clf, output_file)
+ ```
+
+### Exemples utilisant des SDK basés sur flux de travail Argo
+
+Argo prend en charge les [bibliothèques client](https://argoproj.github.io/argo-workflows/client-libraries/), générées automatiquement et gérées par la communauté, qui incluent les SDK Java et Python.
+
+Si vous préférez utiliser un cadres de niveau supérieur, alors `Couler` et `Hera` sont des alternatives bien adaptées. Ces cadress rendent la création et la gestion de flux de travail complexes plus accessibles à un public plus large.
+
+#### Hera
+
+Hera vise à simplifier le processus de création et de soumission de flux de travail en éliminant de nombreux détails techniques via une interface de programmation d'application simple. Il utilise également un ensemble cohérent de terminologie et de concepts qui s'alignent sur les flux de travail Argo, permettant aux utilisateurs d'apprendre et d'utiliser plus facilement les deux outils ensemble.
+
+#### Couler
+
+Couler fournit une interface de programmation d'applications simple et unifiée pour définir des flux de travail à l'aide d'un style de programmation impératif. Il construit également automatiquement des graphiques acycliques dirigés (DAG) pour les flux de travail, ce qui peut contribuer à simplifier le processus de création et de gestion de ceux-ci.
+
+=== "Couler"
+ ``` py title="couler.py" linenums="1"
+ #!/usr/bin/env python
+
+ # Préparez votre système
+ !pip config --user set global.index-url https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple
+ !python3 -m pip install git+https://github.com/couler-proj/couler --ignore-installed
+
+ # Définir une variable globale pour plus de commodité
+ NAMESPACE = ""
+
+ # Importer les packages nécessaires
+ import json
+ import random
+
+ import couler.argo as couler
+ from couler.argo_submitter import ArgoSubmitter
+
+
+ # Définir les étapes (fonctions) utilisées dans le workflow
+ def random_code():
+ import random
+ res = "heads" if random.randint(0, 1) == 0 else "tails"
+ print(res)
+
+
+ def flip_coin():
+ return couler.run_script(
+ image="k8scc01covidacr.azurecr.io/ubuntu",
+ source=random_code
+ )
+
+
+ def heads():
+ return couler.run_container(
+ image="k8scc01covidacr.azurecr.io/ubuntu",
+ command=["sh", "-c", 'echo "it was heads"']
+ )
+
+
+ def tails():
+ return couler.run_container(
+ image="k8scc01covidacr.azurecr.io/ubuntu",
+ command=["sh", "-c", 'echo "it was tails"']
+ )
+
+
+ result = flip_coin()
+
+ couler.when(couler.equal(result, "heads"), lambda: heads())
+ couler.when(couler.equal(result, "tails"), lambda: tails())
+
+ submitter = ArgoSubmitter(namespace="NAMESPACE")
+ result = couler.run(submitter=submitter)
+
+ print(json.dumps(result, indent=2))
+ ```
+=== "Hera"
+ ``` py title="hera.py" linenums="1"
+ #!/usr/bin/env python
+
+ # Préparez votre système
+ !pip config --user set global.index-url https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple
+ !pip install hera-workflows
+
+ # Importer les packages nécessaires
+ import hera
+ from hera import Task, Workflow
+
+ # Configurer Hera
+ hera.global_config.GlobalConfig.token = ""
+ hera.global_config.GlobalConfig.host = "https://argo-workflows.aaw-dev.cloud.statcan.ca:443"
+ hera.global_config.GlobalConfig.namespace = ""
+ hera.global_config.GlobalConfig.service_account_name = ""
+
+
+ # Définir les étapes (fonctions) utilisées dans le workflow
+ def random_code():
+ res = "heads" if random.randint(0, 1) == 0 else "tails"
+ print(res)
+
+
+ def heads():
+ print("it was heads")
+
+
+ def tails():
+ print("it was tails")
+
+ # Définir le flux de travail
+ with Workflow("coin-flip") as w:
+ r = Task("r", random_code)
+ h = Task("h", heads)
+ t = Task("t", tails)
+
+ h.on_other_result(r, "heads")
+ t.on_other_result(r, "tails")
+
+ # Exécuter le flux de travail
+ w.create()
+ ```
+
+### Ressources supplémentaires pour les flux de travail Argo
+
+Des exemples de flux de travail Argo peuvent être trouvés dans les référentiels Github suivants :
+
+- [Documentation des workflows Argo](https://argoproj.github.io/argo-workflows/)
+- [Référence Argo CLI](https://argoproj.github.io/argo-workflows/walk-through/argo-cli/)
diff --git a/docs/fr/3-Pipelines/Kubeflow-Pipelines.md b/docs/fr/3-Pipelines/Kubeflow-Pipelines.md
deleted file mode 100644
index 31534fa06..000000000
--- a/docs/fr/3-Pipelines/Kubeflow-Pipelines.md
+++ /dev/null
@@ -1,256 +0,0 @@
-# Vue d'ensemble
-
-Kubeflow Pipelines est une plateforme de création de flux de production
-d'apprentissage automatique pouvant être déployés dans un environnement
-Kubernetes. Il permet de créer des pipelines qui encapsulent les flux de
-production analytiques (transformation de données, modèles de formation,
-construction d'éléments visuels, etc.). Ces pipelines peuvent être mis en
-commun, réutilisés et programmés. Ils sont créés de façon à être exécutés avec
-les calculs fournis par Kubernetes.
-
-Dans le contexte de l'espace de travail en analytique avancée, vous pouvez
-interagir avec les pipelines Kubeflow par l'entremise :
-
-- de [l'interface utilisateur](../1-Experiences/Kubeflow.md) de Kubeflow, où, à
- partir du menu Pipelines, vous pouvez télécharger des pipelines, visualiser
- les pipelines que vous possédez et leurs résultats, etc.
-
-- de la trousse [SDK](https://www.kubeflow.org/docs/pipelines/sdk/sdk-overview/)
- en Python de Kubeflow Pipelines, accessible dans les serveurs de bloc-notes
- Jupyter, où vous pouvez définir vos composants et pipelines, les soumettre
- pour les exécuter immédiatement, ou même les enregistrer pour plus tard.
-
-
-??? exemple "Des exemples supplémentaires dans les bloc-notes"
- Des exemples plus exhaustifs de pipelines produits expressément pour cette
- plateforme sont accessibles dans
- [GitHub](https://github.com/StatCan/aaw-contrib-jupyter-notebooks) (et dans chaque
- serveur de bloc-notes à `/jupyter-notebooks`). Vous pouvez également
- consulter des sources publiques.
-
-Voyez
-[le documentation officiel de Kubeflow](https://www.kubeflow.org/docs/pipelines/overview/pipelines-overview/)
-pour obtenir une explication générale détaillée de Kubeflow.
-
-
-
-# Qu'est-ce qu'un pipeline et comment fonctionne-t-il?
-
-Dans Kubeflow Pipelines, un pipeline comprend un ou plusieurs composants de
-pipeline enchaînés pour former un flux de production. Les composants sont comme
-des fonctions que le pipeline connecte ensemble.
-
-Le _pipeline_ décrit l'ensemble du flux de production de ce que vous souhaitez
-accomplir, tandis que les _composants de pipeline_ décrivent chacune des étapes
-distinctes de ce processus (comme le fait d'extraire des colonnes d'un stock de
-données, de transformer des données ou d'entraîner un modèle). Chaque
-**composant** doit être **modulaire** et idéalement **réutilisable**.
-
-Essentiellement, chaque _composant_ a :
-
-- une application autonome, présentée sous forme d'image de menu fixe
- (https://docs.docker.com/get-started/), pour effectuer le travail proprement
- dit .le code dans l'image de menu fixe peut être une séquence de commandes en
- langage naturel, un script Python ou tout autre code pouvant être exécuté à
- partir d'un terminal Linux
-- une description de la manière dont Kubeflow Pipelines exécute le code
- (l'emplacement de l'image, les arguments de la ligne de commande qu'il
- accepte, les résultats qu'il produit), sous forme de fichier YAML.
-
-Un _pipeline_ définit ensuite la logique de connexion des composants, par
-exemple :
-
-1. Exécuter `ComposantA`
-2. transmettre le résultat du `ComposantA` au `ComposantB` et au `ComposantC`
-3. ...
-
-
-!!! example "Exemple d'un pipeline"
- Voici un exemple :
-
- #!/bin/python3
- dsl.pipeline(name="Estimer Pi",
- description="Estimer Pi au moyen d'un modèle Map-Reduce")
- def compute_pi():
- # Créer un "exemple" d'opération pour chaque valeur de départ
- # transmise au pipeline
- seeds = (1,2,3,4,5,6,7,8,9,10)
- sample_ops = [sample_op(seed) for seed in seeds]
-
- # Obtenir les résultats avant de les transmettre à deux pipelines
- # distincts. Les résultats sont extraits des fichiers
- # `output_file.json` et sont disponibles à partir des instances
- # `sample_op` par l'entremise de l'attribut `.outputs`.
- outputs = [s.outputs['output'] for s in sample_ops]
-
- _generate_plot_op = generate_plot_op(outputs)
- _average_op = average_op(outputs)
-
- Vous pouvez trouver le pipeline complet dans
- [l'exemple `map-reduce-pipeline`](https://github.com/StatCan/aaw-contrib-jupyter-notebooks).
-
-# Définir et exécuter votre premier pipeline
-
-Bien que les _pipelines_ et les _composants_ soient définis par des fichiers
-YAML, la trousse
-[SDK](https://www.kubeflow.org/docs/pipelines/sdk/sdk-overview/) en Python vous
-permet de les définir à partir du code Python. Voici un exemple de définition
-d'un
-[pipeline simple](https://github.com/StatCan/aaw-contrib-jupyter-notebooks/blob/master/kfp-basics/average_with_docker_components.ipynb)
-en utilisant la trousse SDK en Python.
-
-L'objectif de notre pipeline est de calculer, au moyen de cinq nombres, les
-valeurs suivantes :
-
-1. la moyenne des trois premiers nombres;
-2. la moyenne des deux derniers nombres;
-3. la moyenne des résultats de (1) et de (2).
-
-Pour ce faire, nous définissons un _pipeline_ qui utilise notre _composant_
-moyen pour effectuer les calculs.
-
-Le composant moyen est défini par une image de menu fixe au moyen d'un script
-Python qui :
-
-- accepte un ou plusieurs nombres comme arguments de ligne de commande
-- renvoie la moyenne de ces nombres, enregistrée dans le fichier `out.txt` dans
- son conteneur.
-
-Pour indiquer à Kubeflow Pipelines comment utiliser cette image, nous
-définissons notre _composant_ moyen par l'entremise d'un `ContainerOp`, qui
-indique à Kubeflow l'interface API de notre image. L'instance `ContainerOp`
-définit l'emplacement de l'image du menu fixe, la façon de lui transmettre des
-arguments et les résultats à extraire du conteneur. Pour utiliser réellement ces
-`ContainerOp` dans notre pipeline, nous créons des fonctions de fabrique comme
-`average_op` (car nous voudrons probablement plus d'un _composant_ moyen).
-
-```python
-from kfp import dsl
-
-def average_op(\*numbers):
- """ Fabrique de ContainerOp moyen
-
- Accepte un nombre arbitraire de nombres d'entrée, en renvoyant un ContainerOp
- qui transmet ces nombres à l'image du menu fixe sous-jacent pour faire la
- moyenne
-
- Renvoie le résultat recueilli à partir du fichier ./out.txt à l'intérieur du
- conteneur
-
- """
-
- # Validation d'entrée
-
- if len(numbers) < 1:
- raise ValueError("Doit préciser au moins un nombre à partir duquel calculer la moyenne")
-
- return dsl.ContainerOp(
- name="averge", # Élément affiché dans la visionneuse de pipeline
- image="k8scc01covidacr.azurecr.io/kfp-components/average:v1", # L'image
- exécutée par Kubeflow Pipelines pour faire le travail arguments=numbers,
- #transmet chaque nombre comme un argument de ligne de commande (chaîne) distinct
- # Le script à l'intérieur du conteneur enregistre le résultat (sous forme de chaîne de caractères) dans le fichier out.txt, que
- # Kubeflow Pipelines lit pour nous et récupère sous forme de chaîne.
- file_outputs={'data': './out.txt'},
- )
-```
-
-Nous définissons notre pipeline comme une fonction Python qui utilise les
-fabriques de `ComponentOp` ci-dessus, décorées par l'élément décoratif
-`@dsl.pipeline`. Notre pipeline utilise notre composant _moyen_ en lui
-transmettant des nombres. Puis, nous utilisons les résultats _moyens_ en les
-transmettant à des fonctions plus tard par l'accès à `avg\_\*.output`.
-
-```python
-@dsl.pipeline(
- name="nom de mon pipeline"
-)
-def my_pipeline(a, b, c, d, e):
- """
- Calcul de moyenne de pipeline, qui accepte cinq nombres et effectue quelques calculs de moyenne sur ceux-ci
- """
-
- # Calculer les moyennes pour deux groupes
-
- avg_1 = average_op(a, b, c)
- avg_2 = average_op(d, e)
-
- # Utiliser les résultats de \_1 et de \_2 pour calculer une moyenne globale
-
- average_result_overall = average_op(avg_1.output, avg_2.output)
-```
-
-Enfin, nous enregistrons une définition YAML de notre pipeline pour la
-transmettre plus tard à Kubeflow Pipelines. Ce fichier YAML décrit à Kubeflow
-Pipelines exactement comment exécuter notre pipeline. Décompressez-le et voyez
-par vous-même!
-
-```python
-from kfp import compiler
-pipeline_yaml = 'pipeline.yaml.zip'
-compiler.Compiler().compile(
- my_pipeline,
- pipeline_yaml
-) print(f"Définition de pipeline exportée vers {pipeline_yaml}")
-```
-
-
-??? avertissement "Kubeflow Pipelines est une bête paresseuse".
- Il est utile de garder à l'esprit le calcul qui se produit lorsque vous
- exécutez ce code Python par rapport à ce qui se passe lorsque vous soumettez
- le pipeline à Kubeflow Pipelines. Bien que tout semble se produire
- instantanément, essayez d'ajouter `print(avg_1.output)` au pipeline
- ci-dessus et voyez ce qui se passe lorsque vous compilez votre pipeline. La
- trousse SDK en Python que nous utilisons sert à créer des pipelines, et non
- à les exécuter, de sorte que les résultats des composants ne seront jamais
- disponibles lorsque vous exécuterez ce code Python. Ce point est abordé plus
- en détail plus loin, dans la section _Comprendre l'ordre des calculs_.
-
-Pour exécuter notre pipeline, nous définissons une expérience :
-
-```python
-experiment_name = "calcul de moyenne de pipeline"
-
-import kfp
-client = kfp.Client()
-exp = client.create_experiment(name=experiment_name)
-
-pl_params = { 'a': 5, 'b': 5, 'c': 8, 'd': 10, 'e': 18, }
-```
-
-Voici ce qui peut être observé dans
-[l'interface utilisateur](../1-Experiences/Kubeflow.md) de Kubeflow Pipelines :
-
-
-
-Ensuite, nous exécutons une instance de notre pipeline en utilisant les
-arguments souhaités :
-
-```python
-import time
-
-run = client.run_pipeline(
- exp.id, # Exécuter dans l'expérience ci-dessus
- experiment_name + '-' + time.strftime("%Y%m%d-%H%M%S"), # Donner un nom et une
- heure système à notre tâche unique pipeline_yaml, # Transmettre le .yaml.zip que
- nous avons créé ci-dessus. Il définit le pipeline params=pl_params # Transmettre
- les paramètres en fonction desquels nous souhaitons exécuter le pipeline
-)
-```
-
-Voici ce que l'on peut également voir dans l'interface utilisateur :
-
-
-
-Plus tard, lorsque nous souhaiterons réutiliser le pipeline, nous pourrons
-transmettre différents arguments et tout recommencer (et même le réutiliser à
-partir de l'interface utilisateur de Kubeflow). Pour mieux comprendre cet
-exemple, ouvrez-le dans Kubeflow et essayez-le vous-même.
-
-# Composants légers
-
-En construction, malheureusement!
-
-# Comprendre l'ordre des calculs
-
-En construction, malheureusement!
diff --git a/docs/fr/3-Pipelines/Machine-Learning-Model-Cloud-Storage.md b/docs/fr/3-Pipelines/Machine-Learning-Model-Cloud-Storage.md
deleted file mode 100644
index 3a271b7d4..000000000
--- a/docs/fr/3-Pipelines/Machine-Learning-Model-Cloud-Storage.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# Données B protégées par Statcan
-
-
-!!! info "Protégé B"
- L'ETAA est certifié pour l'hébergement de données protégé B !
-
-Afin de télécharger des données protégées B sur l'ETAA, les utilisateurs devront demander l'accès via l'Unité de Succès à la Clientèle (USC). Les utilisateurs d'ETAA devront également fournir un espace de noms, obtenir un sponsor et obtenir l'approbation d'OPMIC. Une fois le processus approuvé, notre équipe infrastructure de données F.A.I.R créera alors un dossier sur Net A qui à son tour donnera accès aux utilisateurs via le répertoire actif. Les données pourront alors être transférées de Net A vers le cloud ETAA.
-
-Le stockage des modèles d'apprentissage automatique dans un environnement de stockage cloud protégé est essentiel pour garantir la sécurité et la confidentialité des données sensibles. L'espace de travail d'analyse avancée (ETAA) fournit un environnement de stockage cloud sécuritaire et robuste qui peut être utilisé pour stocker des modèles d'apprentissage automatique et d'autres actifs de données.
-
-La plate-forme ETAA fournit un environnement de stockage cloud protégé conçu pour répondre aux exigences les plus strictes en matière de sécurité et de confidentialité des données. L'environnement de stockage est protégé par un cryptage et des contrôles d'accès conformes aux normes de l'industrie, ce qui garantit que seul le personnel autorisé peut accéder aux données sensibles. Cela protège contre les accès non autorisés, les violations de données et autres menaces de sécurité.
-
-En plus de ses fonctions de sécurité robustes, l'environnement de stockage en cloud ETAA est également hautement évolutif et flexible. Cela signifie que les data scientists et les ingénieurs en apprentissage automatique peuvent facilement faire évoluer leurs besoins de stockage à mesure que leurs ensembles de données et la taille de leurs modèles augmentent. Cela leur permet de stocker et de gérer de gros volumes de données et de modèles sans avoir à se soucier des limitations de stockage ou des goulots d'étranglement des performances.
-
-Le stockage des modèles d'apprentissage automatique dans un environnement de stockage cloud protégé sur l'espace de travail d'analyse avancée fournit une solution sécurisée, évolutive et flexible pour la gestion et la protection des données sensibles. En tirant parti des capacités de stockage dans le cloud fournies par la plate-forme ETAA, les data scientists et les ingénieurs en apprentissage automatique peuvent se concentrer sur la création et le déploiement de leurs modèles en toute confiance, sachant que leurs données sont protégées et sécurisées.
-
-## Stockage en ligne
-
-
-!!! info "Avantages du stockage en cloud"
- Le stockage en cloud offre plusieurs avantages pour la science des données et l'apprentissage automatique, notamment en termes d'évolutivité, d'accessibilité et de rentabilité.
-
-Premièrement, le stockage dans le cloud permet aux data scientists de stocker et de traiter de grandes quantités de données sans avoir à se soucier des limites du stockage local. Ceci est particulièrement important dans le contexte de l'apprentissage automatique, où de grands ensembles de données sont nécessaires pour la formation et le test des modèles. Le stockage dans le cloud permet aux data scientists d'augmenter leur capacité de stockage selon les besoins, sans avoir à investir dans du matériel coûteux.
-
-Deuxièmement, le stockage en cloud permet aux data scientists d'accéder aux données de n'importe où, en utilisant n'importe quel appareil doté d'une connexion Internet. Cela permet la collaboration entre des équipes géographiquement dispersées et permet aux data scientists de travailler à distance. De plus, le stockage dans le cloud facilite le partage de données avec d'autres parties prenantes, telles que des partenaires commerciaux ou des clients. Enfin, le stockage dans le cloud est généralement plus rentable que le stockage sur site, en particulier pour les petites entreprises ou celles dont les ressources informatiques sont limitées.
-
-Dans l'ensemble, le stockage en cloud est une solution fiable et pratique pour stocker et gérer vos données. Que vous ayez besoin de stocker de grandes quantités de données ou seulement quelques fichiers, le stockage en cloud facilite la gestion de vos besoins de stockage sans les tracas des solutions de stockage traditionnelles.
-
-La plateforme ETAA propose plusieurs types de stockage :
-
-- Disques (également appelés Volumes sur l'écran de création de Kubeflow Notebook Server)
-- Buckets ("Blob" ou stockage S3, fournis via MinIO)
-- Lacs de données (à venir)
-
-Selon votre cas d'utilisation, le disque ou le bucket peut être le plus approprié. Notre [aperçu du stockage](../5-Storage/Overview.md) vous aidera à les comparer.
-
-### Disques
-
-[](Storage.md/)
-
-**[Disks](../5-Storage/Disks.md)** sont ajoutés à votre serveur notebook en ajoutant des volumes de données.
-
-### Seaux
-
-MinIO est un système de stockage d'objets compatible S3-API qui fournit une alternative open source aux services de stockage cloud propriétaires. Bien que nous utilisions actuellement MinIO comme solution de stockage dans le cloud, nous prévoyons de le remplacer par s3-proxy dans un proche avenir. S3-proxy est un serveur proxy inverse léger et open source qui vous permet d'accéder à des services de stockage compatibles avec Amazon S3 avec vos applications existantes. En passant à s3-proxy, nous pourrons améliorer les performances, la sécurité et l'évolutivité de notre stockage dans le cloud, tout en maintenant la compatibilité avec l'API S3.
-
-[](AzureBlobStorage.md/)
-
-**[MinIO](../5-Storage/AzureBlobStorage.md)** est un magasin d'objets évolutif cloud natif. Nous l'utilisons pour les buckets (stockage blob ou S3).
-
-### Lacs de données (à venir)
-
-Un lac de données est un référentiel central qui vous permet de stocker toutes vos données structurées et non structurées à n'importe quelle échelle. C'est un moyen rentable de stocker et de gérer tous les types de données, des données brutes aux données traitées, et c'est un outil essentiel pour les data scientists.
-
-L'un des principaux avantages d'un lac de données est sa flexibilité. Il permet de stocker tous types de données sans avoir besoin de définir un schéma au préalable, ce qui est particulièrement utile lorsqu'il s'agit de données non structurées. Cette flexibilité permet aux data scientists d'explorer, d'expérimenter et d'extraire facilement des informations à partir de leurs données sans être contraints par les limites d'une base de données relationnelle traditionnelle.
-
-Les lacs de données permettent également aux data scientists de centraliser leurs données, ce qui facilite la gestion et l'analyse de gros volumes de données provenant de diverses sources. Avec un lac de données, les data scientists peuvent facilement ingérer et stocker des données provenant de diverses sources, telles que des bases de données, le stockage dans le cloud et des API tierces. De plus, les lacs de données fournissent souvent des fonctionnalités pour la gouvernance des données, la gestion des métadonnées et le contrôle d'accès, ce qui permet de garantir que les données sont de haute qualité et conformes aux réglementations en vigueur.
-
-De plus, les lacs de données basés sur le cloud offrent des solutions de stockage évolutives et économiques qui peuvent être facilement étendues en un clic. À mesure que les besoins de stockage de données d'un scientifique des données augmentent, il peut ajouter une capacité de stockage supplémentaire à son lac de données avec un minimum d'effort, sans se soucier de l'infrastructure sous-jacente ou de la maintenance.
-
-Dans l'ensemble, les lacs de données sont un outil essentiel pour les data scientists, car ils offrent la flexibilité, l'évolutivité et la facilité d'utilisation nécessaires pour stocker et gérer de gros volumes de données, permettant aux data scientists de se concentrer sur l'extraction d'informations et de valeur à partir des données.
diff --git a/docs/fr/3-Pipelines/Machine-Learning-Model-Serving.md b/docs/fr/3-Pipelines/Machine-Learning-Model-Serving.md
deleted file mode 100644
index 237deb56f..000000000
--- a/docs/fr/3-Pipelines/Machine-Learning-Model-Serving.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# Introduction au modèle de service
-
-Dans le contexte des gouvernements, servir des modèles d'apprentissage automatique signifie rendre les modèles formés disponibles pour être utilisés par d'autres applications et systèmes. Cela peut inclure la réalisation de prédictions ou de classifications basées sur les données d'entrée, ou la fourniture d'informations et de recommandations basées sur les résultats de l'analyse des données.
-
-Servir des modèles d'apprentissage automatique dans un contexte gouvernemental soulève des questions importantes liées à la confidentialité des données. Les agences gouvernementales sont souvent responsables de la collecte et de la gestion des données personnelles sensibles, telles que les dossiers médicaux, les données financières et les casiers judiciaires. Lors de la diffusion de modèles d'apprentissage automatique, il est essentiel de s'assurer que ces données sont protégées et que leur accès est strictement contrôlé.
-
-Pour répondre à ces préoccupations, les agences gouvernementales doivent mettre en œuvre des mesures solides de confidentialité et de sécurité des données lorsqu'elles servent des modèles d'apprentissage automatique. Cela pourrait inclure le chiffrement des données au repos et en transit, la mise en œuvre de contrôles d'accès et d'authentification des utilisateurs, et la surveillance régulière des violations de données et des vulnérabilités.
-
-En plus de la confidentialité et de la sécurité des données, il est également important de prendre en compte les implications éthiques de servir des modèles d'apprentissage automatique dans un contexte gouvernemental. Les modèles d'apprentissage automatique peuvent être biaisés ou discriminatoires, entraînant un traitement injuste de certains groupes de personnes. Pour atténuer ces risques, les agences gouvernementales doivent soigneusement évaluer et surveiller leurs modèles d'apprentissage automatique, et prendre des mesures pour lutter contre les préjugés ou la discrimination qui pourraient survenir.
-
-Dans l'ensemble, servir des modèles d'apprentissage automatique dans un contexte gouvernemental nécessite un examen attentif de la confidentialité des données, de la sécurité et des préoccupations éthiques. En mettant en œuvre des mesures solides pour protéger les données personnelles et prévenir les préjugés, les agences gouvernementales peuvent tirer parti de la puissance de l'apprentissage automatique pour prendre de meilleures décisions et améliorer les résultats pour les citoyens tout en maintenant la confiance et la transparence.
-
-## Pourquoi servir avec nous ?
-
-Servir des modèles d'apprentissage automatique avec l'espace de travail d'analyse avancée (l'ETAA) présente plusieurs avantages. Premièrement, l'ETAA est une plate-forme d'analyse de données open source qui donne accès à une variété d'outils d'analyse avancés, notamment Python, R et SAS. Cela facilite le déploiement de modèles d'apprentissage automatique et leur intégration dans les flux de travail existants.
-
-Deuxièmement, l'ETAA prend en charge plusieurs frameworks MLOps, notamment Couler, Seldon et Argo Workflows. Ces frameworks fournissent une gamme de fonctionnalités, notamment la gestion des versions de modèle, le service de modèle et la surveillance de modèle, qui simplifient le processus de déploiement et de gestion des modèles d'apprentissage automatique en production.
-
-Troisièmement, l'ETAA fournit une plate-forme sécurisée et évolutive pour servir les modèles d'apprentissage automatique avec le statut protégé B. Les modèles peuvent être servis à l'aide d'environnements conteneurisés, tels que Docker, qui offrent un niveau élevé d'isolement et de sécurité. L'ETAA fournit également un accès aux ressources de cloud computing, permettant aux utilisateurs d'augmenter leur puissance de calcul selon les besoins pour gérer des volumes élevés de demandes.
-
-Enfin, l'ETAA est une plateforme collaborative qui permet aux utilisateurs de partager du code et des données avec d'autres chercheurs et analystes. Cela favorise une communauté d'utilisateurs qui peuvent apprendre du travail des autres et collaborer sur des projets qui nécessitent des capacités d'analyse avancées.
-
-En résumé, servir des modèles d'apprentissage automatique avec l'espace de travail d'analyse avancée donne accès à des outils d'analyse avancés, à plusieurs cadres MLOps, à une plate-forme protégé B sécurisée et évolutive et à une communauté collaborative d'utilisateurs, ce qui en fait une plate-forme idéale pour les scientifiques et les analystes de données qui veulent pour déployer et gérer des modèles d'apprentissage automatique en production.
-
-## Noyau de Seldon
-
-Seldon Core est une plate-forme open source pour le déploiement, la mise à l'échelle et la surveillance des modèles d'apprentissage automatique sur Kubernetes. Il fournit un moyen simple et efficace de déployer des modèles d'apprentissage automatique en tant que microservices dans un environnement de production.
-
-Servir des modèles d'apprentissage automatique à l'aide de Seldon Core implique les étapes suivantes :
-
-1. Conditionnement du modèle : la première étape consiste à conditionner le modèle d'apprentissage automatique formé dans une image de conteneur avec toutes les dépendances requises. Seldon Core prend en charge divers frameworks d'apprentissage automatique, notamment TensorFlow, PyTorch et Scikit-learn.
-
-2. Déploiement du modèle : une fois l'image du conteneur créée, l'étape suivante consiste à déployer le modèle sur Kubernetes à l'aide de Seldon Core. Cela implique de définir le fichier de configuration de déploiement, qui spécifie les ressources requises pour le déploiement, telles que le nombre de répliques et les ressources de calcul.
-
-3. Service de modèle : une fois le modèle déployé, Seldon Core expose un point de terminaison d'API REST qui peut être utilisé pour effectuer des prédictions. Les clients peuvent envoyer des requêtes au point de terminaison avec des données d'entrée, et le modèle renverra la sortie correspondante. Seldon Core prend également en charge divers modèles de déploiement, tels que le déploiement Canary et les tests A/B, pour permettre une expérimentation et des tests faciles de différents modèles.
-
-4. Surveillance des modèles : Seldon Core fournit diverses fonctionnalités de surveillance pour suivre les performances des modèles déployés. Cela inclut la surveillance en temps réel des métriques du modèle, telles que la latence et le débit, ainsi que la journalisation des données de demande et de réponse à des fins de débogage.
-
-Seldon Core facilite la mise à disposition de modèles d'apprentissage automatique à grande échelle, avec une prise en charge de la haute disponibilité, de l'évolutivité et de la tolérance aux pannes. Il fournit également une intégration avec divers outils natifs de Kubernetes, tels qu'Istio et Prometheus, pour permettre une surveillance et une observabilité avancées.
diff --git a/docs/fr/3-Pipelines/Machine-Learning-Training-Pipelines.md b/docs/fr/3-Pipelines/Machine-Learning-Training-Pipelines.md
deleted file mode 100644
index c15095c6e..000000000
--- a/docs/fr/3-Pipelines/Machine-Learning-Training-Pipelines.md
+++ /dev/null
@@ -1,821 +0,0 @@
-# Former des modèles d'apprentissage automatique sur l'ETAA
-
-
-
-
-
-
-!!! info
- La formation de modèles d'apprentissage automatique implique l'utilisation d'algorithmes pour apprendre des modèles et des relations dans les données. Ce processus implique l'identification de caractéristiques ou de variables pertinentes pour le problème en question et l'utilisation de ces caractéristiques pour faire des prédictions ou des classifications.
-
-## Pourquoi s'entraîner avec nous ?
-
-_L'entraînement des modèles d'apprentissage automatique sur l'espace de travail d'analyse avancée (ETAA) présente plusieurs avantages._
-
-1. **Open Source :** L'ETAA est une *plate-forme de données open source hébergée par Statistique Canada* qui fournit un accès sécurisé (protégé B) à une variété de sources de données, y compris des données de recensement, des enquêtes et des dossiers administratifs. Ces données peuvent être utilisées pour former des modèles d'apprentissage automatique et générer des informations qui peuvent éclairer les décisions politiques et améliorer les processus métier.
-
-2. **Polyvalent :** L'ETAA est *conçu pour gérer des ensembles de données volumineux et complexes*. Il donne accès à une gamme d'outils d'analyse avancés, dans le langage de votre choix, y compris *Python, R et SAS*, qui peuvent être utilisés pour prétraiter les données, former des modèles d'apprentissage automatique et générer des visualisations. *Parce que l'ETAA exploite les technologies cloud, *les utilisateurs peuvent augmenter leur puissance de calcul selon leurs besoins*.
-*
-3. **Sécurisé :** L'ETAA est une *plate-forme sécurisée (protégé B) qui respecte les normes les plus élevées en matière de confidentialité et de sécurité des données*. Les données peuvent être stockées et traitées sur la plateforme sans risque d'accès non autorisé ou de violation de données.
-
-## MLOps et pipelines de données
-
-
-!!! info "Optimiser les workflows de données"
- Les MLOps et les pipelines de données sont des outils importants utilisés dans le domaine de la science des données pour gérer et optimiser les workflows de données.
-
-### MLOps
-
-MLOps fait référence à l'ensemble des pratiques et des outils utilisés pour gérer l'ensemble du cycle de vie d'un modèle d'apprentissage automatique. Cela comprend tout, du développement et de la formation du modèle à son déploiement en production et à sa maintenance dans le temps. MLOps garantit que les modèles d'apprentissage automatique sont fiables, précis et évolutifs, et qu'ils peuvent être mis à jour et améliorés selon les besoins.
-
-### Pipelines de données
-
-Les pipelines de données sont une série d'étapes qui permettent de déplacer des données d'un système ou d'une application à un autre. Cela comprend la collecte, le nettoyage, la transformation et le stockage des données, ainsi que leur récupération en cas de besoin. Les pipelines de données sont importants pour garantir que les données sont exactes, fiables et accessibles à ceux qui en ont besoin.
-
-
-!!! info "Automatisation et fiabilité"
- Les MLOps et les pipelines de données aident les organisations à gérer le processus complexe consistant à travailler avec de grandes quantités de données et à développer des modèles d'apprentissage automatique. En automatisant ces processus et en s'assurant que les données sont exactes et fiables, les organisations peuvent économiser du temps et des ressources tout en prenant de meilleures décisions basées sur des informations basées sur les données.
-
-### Pourquoi des MLOps conteneurisés ?
-
-Les avantages de l'utilisation d'une approche conteneurisée pour la formation de modèles d'apprentissage automatique avec Argo Workflows incluent :
-
-1. **Reproductibilité :** La conteneurisation du modèle de l'apprentissage automatique et de ses dépendances garantit que l'environnement reste cohérent d'une exécution à l'autre, ce qui facilite la reproduction des résultats.
-
-2. **Évolutivité :** Argo Workflows peut orchestrer des tâches parallèles et des flux de travail complexes, ce qui facilite l'évolution du processus de formation selon les besoins.
-
-3. **Portabilité :** Les conteneurs peuvent être exécutés sur n'importe quelle plate-forme prenant en charge la conteneurisation, ce qui facilite le déplacement du processus de formation vers différents environnements ou fournisseurs de cloud.
-
-4. **Collaboration :** En transférant le conteneur vers un registre de conteneurs, les autres utilisateurs peuvent facilement télécharger et utiliser le conteneur à leurs propres fins, ce qui facilite la collaboration sur des projets de l'apprentissage automatique.
-
-Les flux de travail Argo et la conteneurisation offrent une approche puissante et flexible pour la formation de modèles d'apprentissage automatique. En tirant parti de ces outils, les data scientists et les ingénieurs en apprentissage automatique peuvent créer, déployer et gérer des workflows d'apprentissage automatique avec facilité et reproductibilité.
-
-## Comment former des modèles
-
-Il existe plusieurs façons de former des modèles d'apprentissage automatique et ce n'est pas à nous de dire à qui que ce soit comment le faire. Cela étant dit, nous avons fourni ci-dessous quelques guides sur la façon de former des modèles d'apprentissage automatique à l'aide des outils disponibles sur l'ETAA. Le premier tutoriel concerne la formation d'un modèle simple directement dans un notebook JupyterLab. Le deuxième tutoriel suppose que l'utilisateur est plus avancé et souhaite définir un pipeline MLOps pour former des modèles à l'aide d'Argo Workflows.
-
-### Créer un serveur de bloc-notes sur l'ETAA
-
-
-!!! info "Serveurs portables"
- Que vous envisagiez de travailler dans JupyterLab, R Studio ou quelque chose de plus avancé avec Argo Workflows, vous aurez besoin du serveur de bloc-notes approprié. [Suivez les instructions trouvées ici pour commencer.](https://docs.google.com/presentation/d/12yTDlbMCmbg0ccdea2h0vwhs5YTa_GHm_3DieG5A-k8/edit?usp=sharing)
-
-### Utilisation de JupyterLab
-
-
-
-
-!!! info "JupyterLab est populaire"
- La formation de modèles d'apprentissage automatique avec JupyterLab est une approche populaire parmi les data scientists et les ingénieurs en apprentissage automatique.
-
-Vous trouverez ici les étapes nécessaires pour former un modèle d'apprentissage automatique avec JupyterLab sur l'ETAA. Parce que nous sommes un environnement multilingue, nous avons fait de notre mieux pour fournir des exemples de code dans nos langages les plus populaires, `Python`, `R` et `SAS`.
-
-#### 1. Importez les bibliothèques requises
-
-Une fois qu'une session JupyterLab est en cours d'exécution, vous devez importer les bibliothèques requises pour votre modèle d'apprentissage automatique. Cela peut inclure des bibliothèques telles que `NumPy`, `Pandas`, `Scikit-learn`, `Tensorflow` ou `PyTorch`. Si vous utilisez `R`, vous aurez besoin de `tidyverse`, `caret` et `janitor`.
-
-=== "Python"
- ``` py title="libraries.py" linenums="1"
- #!/usr/bin/env python
-
- # tensorflow et keras pour la construction et la formation de modèles d'apprentissage en profondeur
- import tensorflow as tf
- from tensorflow import keras
-
- # numpy pour les calculs numériques
- import numpy as np
-
- # pandas pour la manipulation et l'analyse des données
- import pandas as pd
-
- # matplotlib pour la visualisation des données
- import matplotlib.pyplot as plt
- ```
-=== "R"
- ``` r title="libraries.R" linenums="1"
- #!/usr/bin/env Rscript
-
- # tidyverse pour des outils impressionnants d'analyse de données et de munging
- library(tidyverse)
-
- # concierge pour nettoyer vos données
- library(janitor)
-
- # caret pour un apprentissage automatique facile
- library(caret)
- ```
-=== "SASPy"
- ``` py title="libraries.py" linenums="1"
- #!/usr/bin/env python
-
- # la seule bibliothèque dont vous aurez besoin pour accéder à SAS depuis Python
- import saspy
- ```
-=== "SAS"
- ``` sas title="libraries.sas" linenums="1"
-
- ```
-
-
-!!! note "À propos du code"
- Les exemples de code que vous voyez dans ce document et tout au long de la documentation sont à titre indicatif pour vous aider à démarrer vos projets. Selon la tâche ou le projet spécifique, d'autres bibliothèques et étapes peuvent être nécessaires.
-
-#### 2. Charger et prétraiter les données
-
-Ensuite, vous devez charger et prétraiter les données que vous utiliserez pour entraîner votre modèle d'apprentissage automatique. Cela peut inclure le nettoyage des données, l'extraction de caractéristiques et la normalisation. Les étapes de prétraitement exactes que vous devrez effectuer dépendront de l'ensemble de données spécifique avec lequel vous travaillez, des exigences de votre modèle d'apprentissage automatique et du travail à effectuer.
-
-=== "Python"
- ``` py title="load_data.py" linenums="1"
- #!/usr/bin/env python
-
- # Importer les paquets nécessaires
- import pandas as pd
- from sklearn.preprocessing import StandardScaler
-
- # Charger des données à partir d'un fichier CSV
- data = pd.read_csv('data.csv')
-
- # Nettoyage des données ! Beaucoup plus peut être fait, c'est un principe de base
- data = data.dropna() # Drop rows with missing values
- data = data.drop_duplicates() # Drop duplicate rows
-
- # Extraction de caractéristiques
- X = data[['feature1', 'feature2', 'feature3']] # Sélectionnez les fonctionnalités pertinentes
-
- # Normalisation
- scaler = StandardScaler() # Crée un objet scaler
- X_norm = scaler.fit_transform(X) # Normaliser les valeurs des caractéristiques
- ```
-=== "R"
- ``` r title="load_data.R" linenums="1"
- #!/usr/bin/env Rscript
-
- # Importer les paquets nécessaires
- library(tidyverse)
- library(janitor)
-
- # Charger des données à partir d'un fichier CSV
- data <- read_csv("data.csv")
-
- # Nettoyer les données à l'aide d'un concierge
- data_cleaned <- data %>%
- # Supprimer les espaces blancs de début/fin dans les noms de colonne
- clean_names() %>%
- # Supprimer les lignes avec des valeurs manquantes
- remove_empty() %>%
- # Convertir la colonne de date au format Date
- mutate(date = as.Date(date, format = "%m/%d/%Y")) %>%
- # Supprimer les lignes en double
- distinct() %>%
- # Réorganiser les colonnes
- select(date, column2, column1, column3)
- ```
-=== "SASPy"
- ``` py title="load_data.py" linenums="1"
- #!/usr/bin/env python
-
- # Importer les paquets nécessaires
- import saspy
-
- # Démarrez une session SAS et vérifiez les informations de configuration
- sas = saspy.SASsession(cfgname='default')
-
- # Charger des données à partir d'un fichier CSV
- data = sas.read_csv("./data.csv")
- ```
-=== "SAS"
- ``` sas title="load_data.sas" linenums="1"
- /* Lecture d'un fichier délimité par des virgules avec une extension .csv */
- /* */
- /* Puisque la valeur DBMS= est CSV, vous n'avez pas besoin d'utiliser le DELIMITER= */
- /* déclaration.Par défaut, il est supposé que les noms de variables sont sur la première */
- /* ligne, l'instruction GETNAMES= n'est donc pas requise. */
- /* */
- /* Créer un fichier de test délimité par des virgules à lire en utilisant PROC IMPORT ci-dessous. */
-
- /* Charger les données d'un fichier CSV */
- proc import
- datafile='data.csv'
- out=data
- dbms=csv
- replace;
- run;
-
- /* Afficher les données */
- proc print ;
- courir;
- ```
-
-#### 3. Divisez les données en ensembles d'entraînement et de test
-
- Une fois les données prétraitées, vous devez les diviser en ensembles d'apprentissage et de test. L'ensemble de formation sera utilisé pour former le modèle d'apprentissage automatique, tandis que l'ensemble de test sera utilisé pour évaluer ses performances.
-
-=== "Python"
- ``` py title="train_test.py" linenums="1"
- #!/usr/bin/env python
-
- # Importer les paquets nécessaires
- import pandas as pd
- from sklearn.model_selection import train_test_split
-
- # Diviser les données en ensembles d'entraînement et de test
- X_train, X_test, y_train, y_test = train_test_split(X_norm,
- data['target'], test_size=0.2, random_state=42)
- ```
-=== "R"
- ``` r title="train_test.R" linenums="1"
- #!/usr/bin/env Rscript
-
- # Importer les paquets nécessaires
- library(caret)
-
- # Charger le jeu de données
- data <- read.csv("my-dataset.csv")
-
- # Définir la graine pour la reproductibilité
- set.seed(123)
-
- # Diviser l'ensemble de données en train et tester à l'aide de la fonction createDataPartition de caret
- train_index <- createDataPartition(data$target_variable, p = 0.7, list = FALSE)
- train_data <- data[train_index, ]
- test_data <- data[-train_index, ]
- ```
-=== "SASPy"
- ``` py title="train_test.py" linenums="1"
- #!/usr/bin/env python
-
- ```
-=== "SAS"
- ``` sas title="train_test.sas" linenums="1"
-
- ```
-
-
-!!! note
- Nous divisons les données en ensembles d'apprentissage et de test à l'aide de la fonction "train_test_split" de "scikit-learn", qui divise de manière aléatoire les données en deux ensembles en fonction de la taille de test spécifiée et de la graine aléatoire.
-
-
-#### 4. Définir et entraîner le modèle d'apprentissage automatique
-
-Avec la division des données, vous pouvez désormais définir et entraîner votre modèle d'apprentissage automatique à l'aide de l'ensemble d'entraînement. Cela pourrait impliquer la sélection de l'algorithme approprié, le réglage des hyperparamètres et la validation croisée.
-
-=== "Python"
- ``` py title="train.py" linenums="1"
- #!/usr/bin/env python
-
- # Importer les paquets nécessaires
- from sklearn.ensemble import RandomForestClassifier
- from sklearn.model_selection import train_test_split
-
- # Charger les ensembles de données
- data = pd.read_csv("my-dataset.csv")
-
- # Diviser l'ensemble de données en train et tester
- X_train, X_test, y_train, y_test = train_test_split(data.iloc[:, :-1], data.iloc[:, -1], test_size=0.3, random_state=123)
-
- # Former le modèle
- model = RandomForestClassifier(n_estimators=100, random_state=123)
- model.fit(X_train, y_train)
-
- # Imprimer le score de précision sur les données de test
- print("Accuracy on test set: {:.3f}".format(model.score(X_test, y_test)))
- ```
-=== "R"
- ``` r title="train.R" linenums="1"
- #!/usr/bin/env Rscript
-
- # Importer les paquets nécessaires
- library(caret)
-
- # Charger l'ensembles de données
- data <- read.csv("my-dataset.csv")
-
- # Définir la graine pour la reproductibilité
- set.seed(123)
-
- # Diviser l'ensemble de données en train et tester à l'aide de la fonction createDataPartition de caret
- train_index <- createDataPartition(data$target_variable, p = 0.7, list = FALSE)
- train_data <- data[train_index, ]
- test_data <- data[-train_index, ]
-
- # Définir le contrôle d'entraînement
- train_control <- trainControl(method = "cv", number = 5)
-
- # Entraînez le modèle à l'aide de la fonction d'entraînement de caret, (method = "rf" est pour la forêt aléatoire)
- model <- train(target_variable ~ ., data = train_data, method = "rf", trControl = train_control)
-
- # Imprimez l'objet modèle pour afficher les résultats
- print(model)
- ```
-=== "SASPy"
- ``` py title="train.py" linenums="1"
- #!/usr/bin/env python
-
- # Importer les paquets nécessaires
- import saspy
- import pandas as pd
-
- # Établir une connexion à une session SAS
- sas = saspy.SASsession()
-
- # Charger l'ensembles de données
- data = pd.read_csv("my-dataset.csv")
-
- # Télécharger l'ensemble de données sur SAS
- sas_df = sas.df2sd(data, "mydata")
-
- # Diviser l'ensemble de données en train et tester
- train, test = sas.surveyselect(data=sas_df,
- method="SRS",
- seed=123,
- samprate=0.7,
- outall=True,
- strata="target_variable",
- partind=True)
-
- # Former le modèle en utilisant la procédure HPFOREST
- model = sas.hpforest(data=train,
- target="target_variable",
- input="input_variable_1-input_variable_n",
- partition="rolevar",
- rolevars={"test": "0", "train": "1"},
- nominals=["input_variable_1-input_variable_n"],
- forestopts={"ntree": 100, "seed": 123})
-
- # Noter le modèle sur les données de test
- predictions = model.predict(newdata=test, out=pred_out)
-
- # Calculer le score de précision sur les données de test
- accuracy = sas.freq(data=predictions, tables="target_variable*p_target_variable", nocum=True, nocol=True)
-
- # Imprimer le score de précision
- print("Accuracy on test set: {:.3f}".format(accuracy.Frequency.iloc[0, 1] / accuracy.Frequency.iloc[:, 1].sum()))
-
- # Se déconnecter de la session SAS
- sas.disconnect()
- ```
-=== "SAS"
- ``` sas title="train.sas" linenums="1"
- /* Charger le jeu de données */
- proc import datafile="my-dataset.csv" out=mydata dbms=csv replace;
- run;
-
- /* Divise le jeu de données en train et test */
- proc surveyselect data=mydata method=srs seed=123 out=selected outall
- samprate=0.7;
- strata target_variable;
- run;
-
- /* Former le modèle */
- proc hpforest data=selected;
- class _all_;
- target target_variable / level=nominal;
- partition rolevar=target_variable(test="0" train="1");
- input _all_;
- forest ntree=100 seed=123;
- run;
-
- /* Noter le modèle sur les données de test */
- proc hpforest predict testdata=selected out=testout;
- run;
-
- /* Affiche le score de précision sur les données de test */
- proc freq data=testout;
- tables target_variable*p_target_variable / nocum nocol;
- run;
- ```
-
-#### 5. Évaluer le modèle
-
-Après avoir entraîné le modèle, vous devez évaluer ses performances sur l'ensemble de test. Cela vous donnera une idée de la performance du modèle sur de nouvelles données inédites.
-
-=== "Python"
- ``` py title="evaluate.py" linenums="1"
-
- ```
-=== "R"
- ``` r title="evaluate.R" linenums="1"
-
- ```
-=== "SASPy"
- ``` py title="evaluate.py" linenums="1"
-
- ```
-=== "SAS"
- ``` sas title="evaluate.sas" linenums="1"
-
- ```
-
-#### 6. Déployer le modèle
-
-Enfin, vous pouvez déployer le modèle d'apprentissage automatique formé dans un environnement de production.
-
-=== "Python"
- ``` py title="deploy.py" linenums="1"
-
- ```
-=== "R"
- ``` r title="deploy.R" linenums="1"
-
- ```
-=== "SASPy"
- ``` py title="deploy.py" linenums="1"
-
- ```
-=== "SAS"
- ``` sas title="deploy.sas" linenums="1"
-
- ```
-
-### Utilisation des workflows Argo
-
-
-
-
-!!! info "Bonnes pratiques MLOps"
- Argo Workflows est un excellent outil pour tous ceux qui cherchent à mettre en œuvre des pratiques MLOps et à rationaliser le processus de formation et de déploiement de modèles d'apprentissage automatique ou d'autres tâches de science des données telles que ETL.
-
-**[Argo Workflows](https://argoproj.github.io/argo-workflows/)** est un engin de workflow open source natif de conteneur pour orchestrer des tâches parallèles sur Kubernetes. Argo Workflows est implémenté en tant que Kubernetes CRD (Custom Resource Definition). Il est particulièrement bien adapté pour une utilisation dans les flux de travail d'apprentissage automatique et de science des données.
-
-Argo Workflows vous permet de
-
-- Définissez des flux de travail où chaque étape du flux de travail est un conteneur.
-- Modélisez les flux de travail en plusieurs étapes sous la forme d'une séquence de tâches ou capturez les dépendances entre les tâches à l'aide d'un graphe acyclique dirigé (DAG).
-- Exécutez facilement des tâches de calcul intensives pour l'apprentissage automatique ou le traitement de données en une fraction du temps à l'aide des flux de travail Argo sur Kubernetes.
-- Exécutez des pipelines CI/CD en mode natif sur Kubernetes sans configurer de produits de développement logiciel complexes.
-
-ce qui facilite la gestion de l'ensemble du pipeline d'apprentissage automatique de bout en bout. Avec Argo Workflows, vous pouvez facilement créer des workflows qui intègrent des tâches telles que le prétraitement des données, la formation de modèles et le déploiement de modèles, le tout dans un environnement Kubernetes.
-
-
-!!! info ""
-
- [](https://argoproj.github.io/argo-workflows/)
- Flux de travail Argo
-
-
-Vous trouverez ci-dessous les étapes pour former un modèle d'apprentissage automatique à l'aide d'Argo Workflows sur l'ETAA.
-
-#### 1. Écrivez un script pour entraîner votre modèle
-
-Voici un exemple de script qui entraîne un modèle de régression logistique sur l'ensemble de données iris. N'oubliez pas de consulter le code de chaque langue ci-dessous.
-
-=== "Python"
-
- ``` python title="train.py" linenums="1"
- #!/usr/bin/env python
-
- # Importer les bibliothèques nécessaires
- import argparse
- import pandas as pd
- from sklearn.datasets import load_iris
- from sklearn.linear_model import LogisticRegression
- from sklearn.model_selection import train_test_split
- from sklearn.metrics import accuracy_score
- import joblib
-
- # Analyser les arguments d'entrée
- parser = argparse.ArgumentParser(description="Train logistic regression model on iris dataset.")
- parser.add_argument("--input", default="iris.csv", help="Path to input dataset file.")
- parser.add_argument("--output", default="model.pkl", help="Path to output model file.")
- args = parser.parse_args()
-
- # Charger le jeu de données de l'iris
- data = load_iris()
- X, y = data.data, data.target
-
- # Diviser les données en ensembles d'entraînement et de test
- X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-
- # Former le modèle de régression logistique
- clf = LogisticRegression(random_state=42)
- clf.fit(X_train, y_train)
-
- # Évaluer le modèle sur l'ensemble de test
- y_pred = clf.predict(X_test)
- accuracy = accuracy_score(y_test, y_pred)
- print("Accuracy:", accuracy)
-
- # Enregistrer le modèle dans un fichier
- joblib.dump(clf, args.output)
- ```
-
-=== "R"
-
- ``` r title="train.R" linenums="1"
- #!/usr/bin/env Rscript
-
- # Importer les bibliothèques nécessaires
- library(caret)
-
- # Analyser les arguments d'entrée
- args <- commandArgs(trailingOnly = TRUE)
- input_file <- ifelse(length(args) > 0, args[1], "iris.csv")
- output_file <- ifelse(length(args) > 1, args[2], "model.rds")
-
- # Charger le jeu de données de l'iris
- data(iris)
- X <- iris[, 1:4]
- y <- iris[, 5]
-
- # Diviser les données en ensembles d'entraînement et de test
- set.seed(42)
- train_index <- createDataPartition(y, p = 0.8, list = FALSE)
- X_train <- X[train_index, ]
- y_train <- y[train_index]
- X_test <- X[-train_index, ]
- y_test <- y[-train_index]
-
- # Former le modèle de régression logistique
- clf <- train(x = X_train, y = y_train, method = "glm")
-
- # Évaluer le modèle sur l'ensemble de test
- y_pred <- predict(clf, newdata = X_test)
- accuracy <- confusionMatrix(y_pred, y_test)$overall["Accuracy"]
- print(paste0("Accuracy: ", accuracy))
-
- # Enregistrer le modèle dans un fichier
- saveRDS(clf, output_file)
- ```
-
-#### 2. Écrivez un Dockerfile pour exécuter votre code
-
-Vous aurez besoin d'un Dockerfile qui inclut toutes les dépendances nécessaires pour former votre modèle d'apprentissage automatique. Cela pourrait inclure
-
-- des forfaits comme
- - `scikit-learn`, `pandas` ou `numpy` si vous utilisez `Python`
- - `caret`, `janitor` et `tidyverse` si vous utilisez `R`
-- vos propres bibliothèques ou scripts personnalisés
-- le code de votre modèle de l'apprentissage automatique sous la forme d'un script [comme dans l'exemple ci-dessus](#1-write-a-script-to-train-your-model).
-
-Utilisez le `Dockerfile` suivant comme point de départ pour vos projets `R` et `Python`.
-
-=== "Python"
-
- ``` docker title="Dockerfile" linenums="1"
- FROM python:3.8-slim-buster
-
- # Installez toutes les dépendances nécessaires
- RUN pip install --no-cache-dir scikit-learn pandas numpy
-
- # Définir le répertoire de travail
- WORKDIR /app
-
- # Copier le code dans le conteneur
- COPY train.py .
-
- # Définir le point d'entrée
- ENTRYPOINT ["python", "train.py"]
- ```
-
-=== "R"
- ``` docker title="Dockerfile" linenums="1"
- FROM rocker/r-base:latest
-
- RUN apt-get update && apt-get install -y --no-install-recommends \
- libssl-dev \
- libcurl4-openssl-dev \
- libxml2-dev \
- && apt-get clean \
- && rm -rf /var/lib/apt/lists/*
-
- RUN R -e 'install.packages(c("caret", "janitor", "tidyverse"))'
-
- COPY train.R /app/train.R
-
- WORKDIR /app
-
- ENTRYPOINT ["Rscript", "train.R"]
- ```
-
-#### 3. Écrivez votre workflow en YAML
-
-YAML est encore un autre langage de balisage et vous devrez écrire les étapes de votre pipeline de formation dans un fichier YAML Argo Workflows. Ce fichier doit inclure une référence au Dockerfile que vous avez créé à l'[Étape 1](#2-write-a-dockerfile-to-run-your-code), ainsi que toutes les données d'entrée et de sortie avec lesquelles vous travaillerez.
-
-Voici un exemple de fichier YAML pour un pipeline d'apprentissage automatique simple qui forme un modèle de régression logistique sur l'ensemble de données iris. La seule vraie différence entre les versions `Python` et `R` est la commande `command : ["python", "train.py"]` vs `command : ["Rscript", "train.R"]` et la les modèles sont stockés dans différents formats, `pkl` pour `python` et `rds` pour `R`.
-
-Le fichier YAML définit une seule étape appelée "train" qui exécute un script appelé "train.py" ou "train.R" dans l'image Docker "machine-learning:v1". Le script prend un fichier d'ensemble de données d'entrée, spécifié par un paramètre appelé `dataset`, et génère un fichier de modèle entraîné vers un artefact de sortie appelé `model.pkl` ou `model.rds` selon le langage utilisé.
-
-=== "Python"
- ``` yaml title="workflow.yaml" linenums="1"
- apiVersion: argoproj.io/v1alpha1
- kind: Workflow
- metadata:
- generateName: ml-pipeline-
- spec:
- entrypoint: train
- templates:
- - name: train
- container:
- image: machine-learning:v1
- command: ["python", "train.py"]
- args: ["--input", "{{inputs.parameters.dataset}}", "--output", "{{outputs.artifacts.model}}"]
- inputs:
- parameters:
- - name: dataset
- default: "iris.csv"
- outputs:
- artifacts:
- - name: model
- path: /output/model.pkl
- ```
-=== "R"
- ``` yaml title="workflow.yaml" linenums="1"
- apiVersion: argoproj.io/v1alpha1
- kind: Workflow
- metadata:
- generateName: ml-pipeline-
- spec:
- entrypoint: train
- templates:
- - name: train
- container:
- image: machine-learning:v1
- command: ["Rscript", "train.R"]
- args: ["--input", "{{inputs.parameters.dataset}}", "--output", "{{outputs.artifacts.model}}"]
- inputs:
- parameters:
- - name: dataset
- default: "iris.csv"
- outputs:
- artifacts:
- - name: model
- path: /output/model.rds
- ```
-
-
-#### 4. Soumettez le workflow à l'aide de la CLI Argo Workflows
-
-Pour exécuter le flux de travail ci-dessus, vous devez d'abord envoyer le fichier Dockerfile à notre registre de conteneurs, puis envoyer le fichier YAML à l'aide de la commande "argo submit". Une fois le pipeline terminé, vous pouvez récupérer le fichier de modèle formé en téléchargeant l'artefact de sortie à partir de la commande `argo logs`.
-
-``` bash title="Terminal"
-$ argo submit workflow.yaml # soumettre une spécification de workflow à Kubernetes
-```
-
-#### 5. Surveiller le pipeline à l'aide de la CLI Argo Workflows
-
-Au fur et à mesure que le pipeline s'exécute, vous pouvez surveiller sa progression à l'aide de la CLI Argo Workflows. Cela vous montrera quelles étapes ont réussi et lesquelles sont toujours en cours. Vous trouverez ci-dessous quelques commandes utiles. Pour plus d'informations sur la CLI Argo Workflows, veuillez consulter [la documentation officielle de la CLI Argo Workflows](https://argoproj.github.io/argo-workflows/walk-through/argo-cli/) .
-
-``` bash title="Terminal"
-$ argo list # liste les workflows actuels
-$ argo get workflow-xxx # obtenir des informations sur un workflow spécifique
-$ argo logs workflow-xxx # imprimer les logs d'un workflow
-$ argo delete workflow-xxx # supprimer le workflow
-
-```
-
-#### 6. Récupérer le modèle formé
-
-Une fois le pipeline terminé, vous pouvez récupérer les données de sortie à l'aide de la commande argo logs ou en affichant les artefacts de sortie à l'aide de la CLI, c'est-à-dire accéder au répertoire que vous avez spécifié dans votre script et localiser le fichier `model.pkl` ou `model. rds`. L'extrait de code suivant, tiré du [script de formation ci-dessus](#1-define-the-machine-learning-model-and-its-dependencies), indique au langage de programmation respectif où enregistrer le modèle formé.
-
-=== "Python"
-
- ``` python title="Enregistrement des données de sortie" linenums="1"
- #!/usr/bin/env python
-
- parser.add_argument("--output", default="model.pkl", help="Path to output model file.")
-
- # Enregistrer le modèle dans un fichier
- joblib.dump(clf, args.sortie)
- ```
-
-=== "R"
-
- ``` r title="Enregistrement des données de sortie" linenums="1"
- #!/usr/bin/env Rscript
-
- output_file <- ifelse(length(args) > 1, args[2], "model.rds")
-
- # Enregistrer le modèle dans un fichier
- saveRDS(clf, output_file)
- ```
-
-### Exemples d'utilisation de SDK basés sur Argo Workflows
-
-Si vous préférez utiliser un cadre de niveau supérieur, nous avons `Couler` et `Hera`. Ces cadres rendent la création et la gestion de flux de travail complexes plus accessibles à un public plus large.
-
-#### Hera
-
-Hera vise à simplifier le processus de création et de soumission des flux de travail en éliminant de nombreux détails techniques via une interface de programmation d'application simple. Il utilise également un ensemble cohérent de terminologie et de concepts qui s'alignent sur Argo Workflows, ce qui permet aux utilisateurs d'apprendre et d'utiliser plus facilement les deux outils ensemble.
-
-#### Couler
-
-Couler fournit une interface de programmation d'application simple et unifiée pour définir les flux de travail à l'aide d'un style de programmation impératif. Il construit également automatiquement des graphes acycliques dirigés (DAG) pour les flux de travail, ce qui peut aider à simplifier le processus de création et de gestion de ceux-ci.
-
-=== "Couler"
- ``` py title="couler.py" linenums="1"
- #!/usr/bin/env python
-
- # Préparez votre système
- !pip config --user set global.index-url https://jfrog.ETAA.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple
- !python3 -m pip install git+https://github.com/couler-proj/couler --ignore-installed
-
- # Définir la variable globale pour plus de commodité
-
- NAMESPACE = ""
-
- # Importer les paquets nécessaires
- import json
- import random
-
- import couler.argo as couler
- from couler.argo_submitter import ArgoSubmitter
-
-
- # Définir les étapes (fonctions) utilisées dans le workflow
- def random_code():
- import random
- res = "heads" if random.randint(0, 1) == 0 else "tails"
- print(res)
-
-
- def flip_coin():
- return couler.run_script(
- image="k8scc01covidacr.azurecr.io/ubuntu",
- source=random_code
- )
-
-
- def heads():
- return couler.run_container(
- image="k8scc01covidacr.azurecr.io/ubuntu",
- command=["sh", "-c", 'echo "it was heads"']
- )
-
-
- def tails():
- return couler.run_container(
- image="k8scc01covidacr.azurecr.io/ubuntu",
- command=["sh", "-c", 'echo "it was tails"']
- )
-
-
- result = flip_coin()
-
- couler.when(couler.equal(result, "heads"), lambda: heads())
- couler.when(couler.equal(result, "tails"), lambda: tails())
-
- submitter = ArgoSubmitter(namespace="NAMESPACE")
- result = couler.run(submitter=submitter)
-
- print(json.dumps(result, indent=2))
- ```
-=== "Hera"
- ``` py title="hera.py" linenums="1"
- #!/usr/bin/env python
-
- # Préparez votre système
- !pip config --user set global.index-url https://jfrog.ETAA.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple
- !pip install hera-workflows
-
- # Importer les paquets nécessaires
- import hera
- from hera import Task, Workflow
-
- # Configurer Hera
- hera.global_config.GlobalConfig.token = ""
- hera.global_config.GlobalConfig.host = "https://argo-workflows.ETAA-dev.cloud.statcan.ca:443"
- hera.global_config.GlobalConfig.namespace = ""
- hera.global_config.GlobalConfig.service_account_name = ""
-
-
- # Définir les étapes (fonctions) utilisées dans le workflow
- def random_code():
- res = "heads" if random.randint(0, 1) == 0 else "tails"
- print(res)
-
-
- def heads():
- print("it was heads")
-
-
- def tails():
- print("it was tails")
-
-
- # Définir le flux de travail
- with Workflow("coin-flip") as w:
- r = Task("r", random_code)
- h = Task("h", heads)
- t = Task("t", tails)
-
- h.on_other_result(r, "heads")
- t.on_other_result(r, "tails")
-
- # Exécuter le flux de travail
- w.create()
- ```
-=== "YAML"
- ``` py title="workflow.yaml" linenums="1"
-
- ```
-=== "Seldon ?"
- ``` py
-
- ```
-
-### Ressources supplémentaires pour les workflows Argo
-
-Des exemples de workflows Argo Workflows peuvent être trouvés dans les répos Github suivants :
-
-- [Documentation Argo Workflows](https://argoproj.github.io/argo-workflows/)
-- [Référence Argo CLI] (https://argoproj.github.io/argo-workflows/walk-through/argo-cli/)
diff --git a/docs/fr/3-Pipelines/Machine-Learning.md b/docs/fr/3-Pipelines/Machine-Learning.md
deleted file mode 100644
index 8f57449a5..000000000
--- a/docs/fr/3-Pipelines/Machine-Learning.md
+++ /dev/null
@@ -1,369 +0,0 @@
-# Modèles d'apprentissage automatique
-
-Les modèles d'apprentissage automatique sont des algorithmes de calcul conçus pour apprendre automatiquement des modèles et des relations à partir de données. Ces modèles sont entraînés sur un ensemble de données, qui est généralement une collection d'exemples ou d'instances, chacun d'entre eux se composant d'un ensemble de fonctionnalités ou de variables, ainsi que d'une variable cible ou d'une sortie.
-
-L'objectif d'un modèle d'apprentissage automatique est d'identifier des modèles et des relations au sein des données qui peuvent être utilisés pour faire des prédictions ou des décisions concernant de nouvelles données invisibles. Cela implique de développer une représentation mathématique de la relation entre les caractéristiques d'entrée et la variable de sortie, sur la base des modèles observés dans les données d'apprentissage. Une fois le modèle entraîné, il peut être utilisé pour faire des prédictions ou prendre des décisions concernant de nouvelles données inédites.
-
-Il existe plusieurs types de modèles d'apprentissage automatique, chacun étant conçu pour traiter différents types de problèmes ou de données. Certains des types les plus courants de modèles d'apprentissage automatique incluent :
-
-1. **Modèles de régression :** Les modèles de régression sont utilisés pour prédire des valeurs numériques continues, telles que les cours des actions ou les prix des logements.
-
-2. **Modèles de classification :** Les modèles de classification sont utilisés pour prédire des valeurs catégorielles discrètes, par exemple si un client achètera ou non un produit.
-
-3. **Modèles de clustering :** Les modèles de clustering sont utilisés pour identifier des groupes ou des clusters au sein d'un ensemble de données en fonction des similitudes entre les instances.
-
-4. **Modèles de recommandation :** Les modèles de recommandation sont utilisés pour recommander des produits ou des services aux utilisateurs en fonction de leur comportement ou de leurs préférences passés.
-
-5. **Réseaux de neurones :** Les réseaux de neurones sont un type de modèle d'apprentissage automatique conçu pour imiter la structure et la fonction du cerveau humain. Ils sont couramment utilisés dans les applications de reconnaissance d'images, de reconnaissance vocale et de traitement du langage naturel.
-
-
-!!! info "Les modèles d'apprentissage automatique peuvent être biaisés"
- Les modèles d'apprentissage automatique sont un outil puissant pour analyser et faire des prédictions sur les données, et ils ont un large éventail d'applications dans des domaines tels que la finance, la santé, le marketing, etc. Cependant, il est important de noter que les modèles d'apprentissage automatique ne sont pas parfaits et peuvent parfois faire des erreurs ou produire des résultats biaisés. Par conséquent, il est important d'évaluer et de tester soigneusement les modèles d'apprentissage automatique avant de les utiliser dans des applications réelles.
-
-## Exemples
-
-### Régression linéaire
-
-
-
-
-!!! info "Régression linéaire"
- $$
- \hat{Y}_i = \hat{\beta}_0 + \hat{\beta}_1 X_i + \hat{\epsilon}_i
- $$
-
- _Où $\hat{Y}_i$ désigne le $i$ième estimateur de la vraie valeur $Y$ en fonction de la $i$ième période d'apprentissage. Chaque $\hat{\beta}$ est un paramètre à apprendre. $\hat{\epsilon}_i$ est la quantité de bruit autorisée dans le modèle et peut varier en fonction du nombre d'époques d'entraînement indiqué par $i$. Chaque $X_i$ représente le $i$ième lot de données d'apprentissage._
-
-Dans les modèles statistiques classiques comme la régression linéaire, l'objectif est de trouver une ligne qui correspond le mieux aux données, nous permettant de faire des prédictions sur de nouveaux points de données.
-
-À mesure que la complexité du problème augmente, des algorithmes plus sophistiqués sont nécessaires, tels que des arbres de décision, des machines à vecteurs de support et des forêts aléatoires. Cependant, ces méthodes ont des limites et peuvent ne pas être en mesure de capturer des modèles complexes dans de grands ensembles de données.
-
-#### Exemple de code
-
-=== "Python"
- ``` py title="linear_regression.py" linenums="1"
- #!/usr/bin/env python
-
- # Charger les bibliothèques requises
- import pandas as pd
- from sklearn.model_selection import train_test_split
- from sklearn.linear_model import LinearRegression
- from sklearn.metrics import mean_squared_error
-
- # Charger le jeu de données
- data = pd.read_csv('path/to/dataset.csv')
-
- # Diviser les données en ensembles d'entraînement et de test
- X_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)
-
- # Former le modèle de régression linéaire
- linear_model = LinearRegression()
- linear_model.fit(X_train, y_train)
-
- # Faire des prédictions sur l'ensemble de test
- y_pred = linear_model.predict(X_test)
-
- # Évaluer les performances du modèle
- mse = mean_squared_error(y_test, y_pred)
- rmse = mse ** 0.5
- print('Root Mean Squared Error:', rmse)
- ```
-
-=== "R"
- ``` r title="linear_regression.r" linenums="1"
- #!/usr/bin/env Rscript
-
- # Définir une graine aléatoire pour la reproductibilité
- set.seed(123)
-
- # Charger le jeu de données
- data <- read.csv('path/to/dataset.csv')
-
- # Diviser les données en ensembles d'entraînement et de test
- train_index <- sample(1:nrow(data), size=0.8*nrow(data))
- train_data <- data[train_index,]
- test_data <- data[-train_index,]
-
- # Former le modèle de régression linéaire
- lm_model <- lm(target_variable ~ ., data=train_data)
-
- # Faire des prédictions sur l'ensemble de test
- y_pred <- predict(lm_model, newdata=test_data[,-which(names(test_data)=='target_variable')])
-
- # Évaluer les performances du modèle
- mse <- mean((y_pred - test_data$target_variable)^2)
- rmse <- sqrt(mse)
- print(paste('Root Mean Squared Error:', rmse))
- ```
-
-### Machine à vecteurs de support (SVM)
-
-
-
-
-!!! note "SVM"
- $$
- \underset{\mathbf{w},b,\boldsymbol{\xi}}{\operatorname{minimize}} \hspace{0.2cm} \frac{1}{2} ||\mathbf{w}||^2 + C \sum_{i=1}^{N} \xi_i
- $$
-
- $$
- \text{où} \hspace{0.2cm} y_i(\mathbf{w}^T\mathbf{x}_i + b) \geq 1-\xi_i \quad \text{and} \quad \hspace{0.2cm} \xi_i \geq 0 \hspace{0.2cm} \forall i \in {1,2,...,N}
- $$
-
- _Dans cette formule, nous utilisons la formulation SVM standard où $\mathbf{w}$ est le vecteur de poids, $b$ est le terme de biais et $\boldsymbol{\xi}$ est le vecteur variable d'écart. L'objectif est de minimiser la norme L2 du vecteur de poids $\mathbf{w}$, sous la contrainte que tous les exemples d'apprentissage sont classés correctement avec une marge d'au moins 1, plus une tolérance pour certaines violations de marge contrôlées par le paramètre de régularisation $C$. La variable cible $y_i$ prend les valeurs 1 ou -1, représentant les deux classes du problème de classification binaire, et $\mathbf{x}_i$ est le vecteur de caractéristiques pour le $i$ième exemple d'entraînement._
-
-Une machine à vecteurs de support (SVM) est un algorithme d'apprentissage automatique supervisé qui peut être utilisé pour la classification, la régression et la détection des valeurs aberrantes. C'est un algorithme populaire dans le domaine de l'apprentissage automatique, en particulier pour résoudre les problèmes de classification.
-
-L'idée de base derrière SVM est de trouver un hyperplan qui sépare au mieux les données d'entrée en différentes classes. Dans un problème de classification à deux classes, l'hyperplan est une ligne qui sépare les points de données d'une classe des points de données de l'autre classe. SVM essaie de trouver l'hyperplan qui maximise la marge entre les deux classes, où la marge est la distance entre l'hyperplan et les points de données les plus proches de chaque classe.
-
-#### Exemple de code
-
-=== "Python"
- ``` py title="svm.py" linenums="1"
- #!/usr/bin/env python
-
- # Charger les bibliothèques requises
- import pandas as pd
- from sklearn.model_selection import train_test_split
- from sklearn.svm import SVC
- from sklearn.metrics import accuracy_score
-
- # Charger le jeu de données
- data = pd.read_csv('path/to/dataset.csv')
-
- # Diviser les données en ensembles d'entraînement et de test
- X_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)
-
- # Former le modèle SVM
- svm_model = SVC(kernel='linear', C=1.0, random_state=42)
- svm_model.fit(X_train, y_train)
-
- # Faire des prédictions sur l'ensemble de test
- y_pred = svm_model.predict(X_test)
-
- # Évaluer les performances du modèle
- accuracy = accuracy_score(y_test, y_pred)
- print('Accuracy:', accuracy)
- ```
-
-=== "R"
-
- ``` r title="svm.r" linenums="1"
- #!/usr/bin/env Rscript
-
- # Charger les bibliothèques requises
- library(e1071)
-
- # Charger le jeu de données
- data <- read.csv('path/to/dataset.csv')
-
- # Diviser les données en ensembles d'entraînement et de test
- set.seed(123)
- train_index <- sample(1:nrow(data), size=0.8*nrow(data))
- train_data <- data[train_index,]
- test_data <- data[-train_index,]
-
- # Former le modèle SVM
- svm_model <- svm(target_variable ~ ., data=train_data, kernel='linear', cost=1)
-
- # Faire des prédictions sur l'ensemble de test
- y_pred <- predict(svm_model, newdata=test_data[,-which(names(test_data)=='target_variable')])
-
- # Évaluer les performances du modèle
- accuracy <- mean(y_pred == test_data$target_variable)
- print(paste('Accuracy:', accuracy))
- ```
-
-### Forêt aléatoire
-
-
-
-
-!!! note "Forêt aléatoire"
- $$
- \hat{y} = \frac{1}{T} \sum_{t=1}^{T} f_t(\mathbf{x}),
- $$
-
- _où $\hat{y}$ est la sortie prédite, $f_t(\mathbf{x})$ est la prédiction du $t$ième arbre de la forêt pour l'entrée $\mathbf{x}$, et $T $ est le nombre d'arbres dans la forêt._
-
-Les forêts aléatoires sont une méthode d'apprentissage d'ensemble qui peut être utilisée pour les problèmes de classification et de régression. Ils sont souvent utilisés pour leur capacité à gérer des ensembles de données dimensionnelles à haute variation et des relations non linéaires entre les entités et les cibles.
-
-Chaque arbre est entraîné sur un sous-ensemble amorcé des données d'entraînement d'origine, et à chaque division, un sous-ensemble aléatoire de caractéristiques est pris en compte pour déterminer la division. La prédiction finale est obtenue en faisant la moyenne des prédictions de tous les arbres de la forêt.
-
-#### Exemple de code
-
-=== "Python"
-
- ``` py title="random_forest.py" linenums="1"
- #!/usr/bin/env python
-
- # Charger les bibliothèques requises
- import pandas as pd
- from sklearn.model_selection import train_test_split
- from sklearn.ensemble import RandomForestRegressor
- from sklearn.metrics import mean_squared_error
-
- # Charger le jeu de données
- data = pd.read_csv('path/to/dataset.csv')
-
- # Diviser les données en ensembles d'entraînement et de test
- X_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)
-
- # Former le modèle de forêt aléatoire
- rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
- rf_model.fit(X_train, y_train)
-
- # Faire des prédictions sur l'ensemble de test
- y_pred = rf_model.predict(X_test)
-
- # Évaluer les performances du modèle
- mse = mean_squared_error(y_test, y_pred)
- rmse = mse ** 0.5
- print('Root Mean Squared Error:', rmse)
- ```
-
-=== "R"
-
- ``` r title="random_forest.r" linenums="1"
- #!/usr/bin/env Rscript
-
- # Charger les bibliothèques requises
- library(randomForest)
-
- # Charger le jeu de données
- data <- read.csv('path/to/dataset.csv')
-
- # Diviser les données en ensembles d'entraînement et de test
- set.seed(123)
- train_index <- sample(1:nrow(data), size=0.8*nrow(data))
- train_data <- data[train_index,]
- test_data <- data[-train_index,]
-
- # Former le modèle de forêt aléatoire
- rf_model <- randomForest(target_variable ~ ., data=train_data, ntree=100, importance=TRUE)
-
- # Faire des prédictions sur l'ensemble de test
- y_pred <- predict(rf_model, newdata=test_data[,-which(names(test_data)=='target_variable')])
-
- # Évaluer les performances du modèle
- mse <- mean((y_pred - test_data$target_variable)^2)
- rmse <- sqrt(mse)
- print(paste('Root Mean Squared Error:', rmse))
- ```
-
-### L'apprentissage en profondeur
-
-
-
-
-!!! note "Apprentissage en profondeur"
- $$
- \hat{y} = f(\mathbf{W}_L f(\mathbf{W}_{L-1} f(\dots f(\mathbf{W}_1\mathbf{x}+\mathbf{b} _1)\dots)+\mathbf{b}_{L-1})+\mathbf{b}_L)
- $$
-
- _où $\mathbf{x}$ est le vecteur d'entrée, $\mathbf{W}_i$ et $\mathbf{b}_i$ sont respectivement la matrice de pondération et le vecteur de biais pour la $i$ième couche, et $ f$ est la fonction d'activation._
-
- _Cette formule représente un réseau de neurones à anticipation avec des couches $L$, où chaque couche applique une transformation linéaire à la sortie de la couche précédente, suivie d'une fonction d'activation non linéaire. La sortie de la couche finale, $\hat{y}$, représente la sortie prédite du réseau de neurones pour l'entrée donnée $\mathbf{x}$._
-
-L'apprentissage en profondeur est un sous-ensemble de l'apprentissage automatique qui implique la formation de réseaux de neurones avec de nombreuses couches de nœuds interconnectés. Cette approche peut gérer des ensembles de données volumineux et complexes et est utilisée dans un large éventail d'applications, notamment la reconnaissance d'images, le traitement du langage naturel et la reconnaissance vocale. Le processus de formation consiste à alimenter le réseau de neurones avec un grand ensemble de données et à ajuster les poids des connexions entre les nœuds pour minimiser l'erreur entre les sorties prédites et les sorties réelles. Grâce à des itérations répétées, le réseau de neurones peut apprendre à reconnaître des modèles dans les données et à faire des prédictions précises sur de nouvelles données.
-
-#### Exemple de code
-
-=== "Python"
- ``` py title="deep_learning.py" linenums="1"
- #!/usr/bin/env python
-
- # Charger les bibliothèques requises
- import pandas as pd
- import numpy as np
- import tensorflow as tf
- from tensorflow import keras
- from sklearn.model_selection import train_test_split
- from sklearn.preprocessing import StandardScaler
- from sklearn.metrics import accuracy_score
-
- # Charger le jeu de données
- data = pd.read_csv('path/to/dataset.csv')
-
- # Diviser les données en ensembles d'entraînement et de test
- X_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)
-
- # Standardiser les caractéristiques d'entrée
- scaler = StandardScaler()
- X_train_scaled = scaler.fit_transform(X_train)
- X_test_scaled = scaler.transform(X_test)
-
- # Définir le modèle de deep learning
- model = keras.Sequential([
- keras.layers.Dense(64, activation='relu', input_shape=[X_train_scaled.shape[1]]),
- keras.layers.Dropout(0.2),
- keras.layers.Dense(1, activation='sigmoid')
- ])
-
- # Compiler le modèle
- model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
-
- # Former le modèle
- history = model.fit(X_train_scaled, y_train, epochs=50, batch_size=32, validation_split=0.1)
-
- # Évaluer les performances du modèle
- y_pred = model.predict_classes(X_test_scaled)
- accuracy = accuracy_score(y_test, y_pred)
- print('Accuracy:', accuracy)
- ```
-
-=== "R"
-
- ``` r title="deep_learning.r" linenums="1"
- #!/usr/bin/env Rscript
-
- # Charger les bibliothèques requises
- library(keras)
- library(tensorflow)
-
- # Charger le jeu de données
- data <- iris
- x <- as.matrix(data[, 1:4])
- y <- to_categorical(as.numeric(data[, 5]) - 1)
-
- # Diviser les données en ensembles d'entraînement et de test
- set.seed(123)
- train_index <- sample(1:nrow(data), size=0.8*nrow(data))
- x_train <- x[train_index,]
- y_train <- y[train_index,]
- x_test <- x[-train_index,]
- y_test <- y[-train_index,]
-
- # Définir l'architecture du réseau neuronal
- model <- keras_model_sequential() %>%
- layer_dense(units = 8, input_shape = c(4)) %>%
- layer_activation('relu') %>%
- layer_dense(units = 3) %>%
- layer_activation('softmax')
-
- # Compiler le modèle
- model %>% compile(
- loss = 'categorical_crossentropy',
- optimizer = 'adam',
- metrics = c('accuracy')
- )
-
- # Former le modèle
- history <- model %>% fit(
- x_train, y_train,
- epochs = 50,
- batch_size = 10,
- validation_split = 0.2,
- verbose = 0
- )
-
- # Évaluer les performances du modèle
- metrics <- model %>% evaluate(x_test, y_test)
- print(paste('Test Loss:', metrics[1]))
- print(paste('Test Accuracy:', metrics[2]))
-
- # Tracez la précision de la formation et de la validation dans le temps
- plot(history$metrics$accuracy, type='l', col='blue', ylim=c(0,1), ylab='Accuracy', xlab='Epoch')
- lines(history$metrics$val_accuracy, type='l', col='red')
- legend('bottomright', legend=c('Training', 'Validation'), col=c('blue', 'red'), lty=1)
- ```
\ No newline at end of file
diff --git a/docs/fr/3-Pipelines/Overview.md b/docs/fr/3-Pipelines/Overview.md
deleted file mode 100644
index 4015d3035..000000000
--- a/docs/fr/3-Pipelines/Overview.md
+++ /dev/null
@@ -1,17 +0,0 @@
-MLOps, ou lopérations d'apprentissage automatique, fait référence à l'ensemble de pratiques et d'outils qui permettent aux organisations de développer, déployer et maintenir des modèles d'apprentissage automatique à grande échelle. MLOps vise à rationaliser le processus de bout en bout de création et de déploiement de modèles d'apprentissage automatique en intégrant les différentes étapes du cycle de vie de l'apprentissage automatique dans un flux de travail cohérent et automatisé.
-
-MLOps implique une gamme d'activités différentes, y compris la préparation et le prétraitement des données, la formation et l'optimisation des modèles, le déploiement et le service des modèles, la surveillance et la maintenance et l'amélioration continue. Certains des composants clés des MLOps incluent :
-
-1. **Gestion des données :** MLOps implique la gestion et le traitement de grandes quantités de données pour garantir la qualité et la précision des modèles d'apprentissage automatique. Cela implique des activités telles que le nettoyage, l'intégration et la transformation des données.
-
-2. **Entraînement et optimisation des modèles :** MLOps implique de développer et de tester des modèles d'apprentissage automatique, ainsi que de les optimiser en termes de performances et de précision. Cela peut impliquer d'expérimenter différents algorithmes, hyperparamètres et techniques de prétraitement des données.
-
-3. **Déploiement de modèles :** MLOps implique le déploiement de modèles d'apprentissage automatique dans des environnements de production, les rendant disponibles pour une utilisation dans des applications du monde réel. Cela peut impliquer la mise en conteneur de modèles pour un déploiement et une mise à l'échelle faciles, ainsi que la configuration d'API et d'autres interfaces pour la diffusion de modèles.
-
-4. **Surveillance et maintenance :** MLOps implique la surveillance des modèles d'apprentissage automatique en production pour s'assurer qu'ils fonctionnent comme prévu. Cela peut impliquer la configuration d'alertes et de notifications pour les défaillances du modèle, ainsi que la mise en œuvre de processus pour la maintenance et les mises à jour du modèle.
-
-5. **Amélioration continue :** MLOps implique l'amélioration continue des modèles d'apprentissage automatique au fil du temps, en fonction des commentaires des utilisateurs et de l'analyse continue des données de performance. Cela peut impliquer de recycler les modèles avec de nouvelles données ou d'intégrer les commentaires des utilisateurs pour affiner les modèles.
-
-Afin de mettre en œuvre efficacement les MLOps, les organisations doivent généralement adopter une gamme d'outils et de technologies différents, notamment des plates-formes de gestion de données, des cadres d'apprentissage automatique, des outils de conteneurisation et des outils de surveillance et de journalisation. Ils doivent également établir des flux de travail et des processus clairs pour gérer les différentes étapes du cycle de vie de l'apprentissage automatique, ainsi que mettre en œuvre des mesures de gouvernance et de conformité pour garantir la confidentialité et la sécurité des données.
-
-En résumé, MLOps est un composant essentiel du cycle de vie de l'apprentissage automatique, permettant aux organisations de développer, déployer et maintenir des modèles d'apprentissage automatique à grande échelle. En adoptant des pratiques et des outils MLOps, les organisations peuvent rationaliser leurs flux de travail d'apprentissage automatique, améliorer la précision et les performances des modèles et offrir plus de valeur aux utilisateurs et aux parties prenantes.
diff --git a/docs/fr/3-Pipelines/PaaS-Integration.md b/docs/fr/3-Pipelines/PaaS-Integration.md
deleted file mode 100644
index bf03427f1..000000000
--- a/docs/fr/3-Pipelines/PaaS-Integration.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# Aperçu
-
-_L'un des principaux avantages de la plate-forme ETAA est sa capacité à s'intégrer aux plates-formes d'apprentissage automatique populaires telles que Databricks et AzureML._
-
-Espace de travail d'analyse avancée (ETAA) est une plate-forme d'analyse de données open source conçue pour être hautement intégrable. Cela signifie qu'il peut être facilement intégré à d'autres plates-formes et outils pour étendre ses capacités et rationaliser les flux de travail.
-
-Un exemple de diagramme illustrant une stratégie de connexion PaaS possible :
-
-
-
-
-
-
-
-**Configuration :** Si vous avez besoin d'aide pour intégrer une plate-forme en tant qu'offre de service, nous sommes heureux
-aider!
-
-## Intégration avec les offres de plate-forme externe en tant que service (PaaS)
-
-_L'intégration est la clé du succès._
-
-[]()
-
-Notre plate-forme open source offre une option inégalée à nos utilisateurs. En permettant aux utilisateurs d'utiliser des outils open source, nous leur donnons la possibilité d'utiliser leurs frameworks de science des données et d'apprentissage automatique préférés. Mais la véritable puissance de notre plateforme vient de sa capacité à s'intégrer à de nombreuses offres de plateforme en tant que service (PaaS), comme Databricks ou AzureML. Cela signifie que nos utilisateurs peuvent tirer parti de la puissance du cloud pour exécuter des pipelines complexes de traitement de données et d'apprentissage automatique à grande échelle. Avec la possibilité de s'intégrer aux offres PaaS, notre plate-forme permet à nos utilisateurs de faire passer leur travail au niveau supérieur, en leur donnant le pouvoir d'adapter facilement leurs charges de travail et de tirer parti des dernières innovations dans le domaine de la science des données et de la machine. apprentissage. En offrant ce niveau d'optionnalité, nous nous assurons que nos utilisateurs peuvent toujours choisir le bon outil pour le travail et garder une longueur d'avance dans un domaine en évolution constante.
-
-Nous pouvons nous intégrer à de nombreuses offres de plate-forme en tant que service (PaaS), comme Databricks ou AzureML.
-
-## Briques de données
-
-- [Databricks de Microsoft](https://azure.microsoft.com/en-ca/services/databricks/)
-
-Databricks est une plate-forme basée sur le cloud qui fournit une plate-forme d'analyse unifiée pour le traitement du Big Data et l'apprentissage automatique. Avec son puissant moteur de calcul distribué et ses outils de flux de travail rationalisés, Databricks est un choix populaire pour créer et déployer des modèles d'apprentissage automatique. En s'intégrant à Databricks, la plate-forme ETAA peut tirer parti de ses capacités informatiques distribuées pour former et déployer des modèles d'apprentissage automatique à grande échelle.
-
-## AzureML
-
-- [Azure ML de Microsoft](https://azure.microsoft.com/en-us/services/machine-learning/)
-
-AzureML est une autre plate-forme d'apprentissage automatique populaire qui fournit une large gamme d'outils pour créer, former et déployer des modèles d'apprentissage automatique. En s'intégrant à AzureML, la plateforme ETAA peut tirer parti de ses puissants outils de création et de formation de modèles, ainsi que de sa capacité à déployer des modèles dans le cloud.
-
-### Exemples
-
-_Des exemples d'intégration de la plate-forme ETAA avec ces plates-formes et d'autres peuvent être trouvés sur le référentiel MLOps Github._
-
-- [Dépôt Github MLOps](https://github.com/StatCan/ETAA-kubeflow-mlops)
-
-Ce référentiel contient une gamme d'exemples et de didacticiels pour l'utilisation de la plate-forme ETAA dans divers flux de travail d'apprentissage automatique, y compris la préparation des données, la formation de modèles et le déploiement de modèles.
-
-## Conclusion
-
-En s'intégrant à des plates-formes d'apprentissage automatique populaires telles que Databricks et AzureML, la plate-forme ETAA fournit une solution puissante et flexible pour créer, déployer et gérer des workflows d'apprentissage automatique à grande échelle.
-
-En tirant parti des intégrations et des outils fournis par ces plates-formes, les scientifiques des données et les ingénieurs en apprentissage automatique peuvent accélérer leurs flux de travail et obtenir de meilleurs résultats avec moins d'effort.
diff --git a/docs/fr/3-Pipelines/PaaS.md b/docs/fr/3-Pipelines/PaaS.md
deleted file mode 100644
index f3b33a781..000000000
--- a/docs/fr/3-Pipelines/PaaS.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Intégrer avec des plateformes comme Databricks et AzureML
-
-La plateforme AAW est construite autour de l'idée d'intégrations, et nous
-pouvons donc s'intégrer avec de nombreuses offres de "plateforme en tant que
-service" (PaaS), telles que
-[Azure ML](https://azure.microsoft.com/en-us/services/machine-learning/) et
-[Databricks](https://azure.microsoft.com/en-ca/services/databricks/).
-
-Voir quelques exemples dans notre
-[Dépôt Github "MLOps"](https://github.com/StatCan/aaw-kubeflow-mlops).
-
-
diff --git a/docs/fr/3-Pipelines/Serving.md b/docs/fr/3-Pipelines/Serving.md
deleted file mode 100644
index 02f5b7d94..000000000
--- a/docs/fr/3-Pipelines/Serving.md
+++ /dev/null
@@ -1,18 +0,0 @@
-# Service de modèle avec Seldon Core et KFServing
-
-
-!!! warning "⚒ Cette page est en construction ⚒"
- La personne qui écrit cette entrée n'en sait pas assez sur cette fonctionnalité pour écrire à son sujet, mais vous pouvez demander sur notre canal en Slack.
-
-## Sans-serveur avec KNative
-
-Kubernetes et [KNative] (https://knative.dev/) permettent à vos services de
-monter ou descendre en puissance à la demande. Cela vous permet de créer des API
-pour servir des modèles d'apprentissage automatique, sans avoir besoin de gérer
-l'équilibrage de charge ou la montée en puissance. La plateforme peut gérer
-toute votre mise à l'échelle pour vous, afin que vous puissiez vous concentrer
-sur la logique du programme.
-
-
-!!! warning "⚒ Cette page est en construction ⚒"
- La personne qui rédige cette entrée ne connaît pas suffisamment cette fonctionnalité pour écrire à son sujet, mais vous pouvez demander sur notre canal en Slack.
diff --git a/docs/fr/3-Pipelines/sklearn_iris_jsondata.ipynb b/docs/fr/3-Pipelines/sklearn_iris_jsondata.ipynb
deleted file mode 100644
index c9256f0e0..000000000
--- a/docs/fr/3-Pipelines/sklearn_iris_jsondata.ipynb
+++ /dev/null
@@ -1,524 +0,0 @@
-{
- "cells": [
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Servir un classificateur d'iris avec Seldon\n",
- "\n",
- "## Objectif du bloc-notes\n",
- "\n",
- "L'objectif de ce bloc-notes est d'encapsuler un modèle Python \"scikit-learn\" à utiliser comme microservice de prédiction avec Seldon Core."
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Configurer Python\n",
- "\n",
- "Écrivez requirements.txt et configurez notre environnement virtuel Python."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T15:57:57.958799Z",
- "iopub.status.busy": "2023-04-27T15:57:57.957866Z",
- "iopub.status.idle": "2023-04-27T15:57:57.964285Z",
- "shell.execute_reply": "2023-04-27T15:57:57.963484Z",
- "shell.execute_reply.started": "2023-04-27T15:57:57.958767Z"
- },
- "scrolled": true,
- "tags": []
- },
- "outputs": [],
- "source": [
- "%%writefile requirements.txt\n",
- "scikit-learn\n",
- "dill\n",
- "pandas\n",
- "sklearn\n",
- "seldon-core\n",
- "requests\n",
- "matplotlib"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:18.412667Z",
- "iopub.status.busy": "2023-04-27T13:58:18.411840Z",
- "iopub.status.idle": "2023-04-27T13:58:19.144219Z",
- "shell.execute_reply": "2023-04-27T13:58:19.143136Z",
- "shell.execute_reply.started": "2023-04-27T13:58:18.412630Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "!if [ ! -d \"./venv\" ]; then python -m venv venv; fi"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:19.302968Z",
- "iopub.status.busy": "2023-04-27T13:58:19.302445Z",
- "iopub.status.idle": "2023-04-27T13:58:20.355237Z",
- "shell.execute_reply": "2023-04-27T13:58:20.353560Z",
- "shell.execute_reply.started": "2023-04-27T13:58:19.302929Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "!source ./venv/bin/activate"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:20.713063Z",
- "iopub.status.busy": "2023-04-27T13:58:20.712216Z",
- "iopub.status.idle": "2023-04-27T13:58:21.461588Z",
- "shell.execute_reply": "2023-04-27T13:58:21.460429Z",
- "shell.execute_reply.started": "2023-04-27T13:58:20.713016Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "!if [ ! -d \"/home/jovyan/.config/pip\" ]; then mkdir /home/jovyan/.config/pip; fi"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Seldon ne fonctionne que dans l'environnement de développement ETAA; modifiez `pip.conf` pour récupérer les packages sur internet."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:21.463776Z",
- "iopub.status.busy": "2023-04-27T13:58:21.463360Z",
- "iopub.status.idle": "2023-04-27T13:58:21.469135Z",
- "shell.execute_reply": "2023-04-27T13:58:21.468420Z",
- "shell.execute_reply.started": "2023-04-27T13:58:21.463740Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "%%writefile /home/jovyan/.config/pip/pip.conf\n",
- "[global]\n",
- "index-url = https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T15:58:01.566928Z",
- "iopub.status.busy": "2023-04-27T15:58:01.566106Z",
- "iopub.status.idle": "2023-04-27T15:58:05.178871Z",
- "shell.execute_reply": "2023-04-27T15:58:05.177536Z",
- "shell.execute_reply.started": "2023-04-27T15:58:01.566896Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "%%capture\n",
- "%pip install -r requirements.txt"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Nous pouvons ajouter le noyau au lanceur JupyterLab pour une réutilisation facile."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:48.714311Z",
- "iopub.status.busy": "2023-04-27T13:58:48.713884Z",
- "iopub.status.idle": "2023-04-27T13:58:50.178610Z",
- "shell.execute_reply": "2023-04-27T13:58:50.177586Z",
- "shell.execute_reply.started": "2023-04-27T13:58:48.714273Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "!python -m ipykernel install --user --name=sklearn_iris_jsondata"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Déployer le modèle\n",
- "\n",
- "Écrivez un fichier YAML SeldonDeployment pour le modèle conteneurisé."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T14:48:15.600923Z",
- "iopub.status.busy": "2023-04-27T14:48:15.600036Z",
- "iopub.status.idle": "2023-04-27T14:48:15.606528Z",
- "shell.execute_reply": "2023-04-27T14:48:15.605436Z",
- "shell.execute_reply.started": "2023-04-27T14:48:15.600890Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "%%writefile sklearn_iris_jsondata_deployment.yaml\n",
- "apiVersion: machinelearning.seldon.io/v1alpha2\n",
- "kind: SeldonDeployment\n",
- "metadata:\n",
- " name: seldon-deployment-example\n",
- " namespace: bryanpaget\n",
- "spec:\n",
- " name: sklearn-iris-deployment\n",
- " annotations:\n",
- " sidecar.istio.io/inject: \"false\"\n",
- " predictors:\n",
- " - componentSpecs:\n",
- " - spec:\n",
- " containers:\n",
- " - image: seldonio/sklearn-iris:0.3\n",
- " imagePullPolicy: IfNotPresent\n",
- " name: sklearn-iris-classifier\n",
- " graph:\n",
- " children: []\n",
- " endpoint:\n",
- " type: REST\n",
- " name: sklearn-iris-classifier\n",
- " type: MODEL\n",
- " name: sklearn-iris-predictor\n",
- " replicas: 1"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Déployez SeldonDeployment."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:50.189468Z",
- "iopub.status.busy": "2023-04-27T13:58:50.188796Z",
- "iopub.status.idle": "2023-04-27T13:58:53.893779Z",
- "shell.execute_reply": "2023-04-27T13:58:53.892661Z",
- "shell.execute_reply.started": "2023-04-27T13:58:50.189441Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "!kubectl create -f sklearn_iris_jsondata_deployment.yaml"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:53.896155Z",
- "iopub.status.busy": "2023-04-27T13:58:53.895313Z",
- "iopub.status.idle": "2023-04-27T13:58:55.209852Z",
- "shell.execute_reply": "2023-04-27T13:58:55.208787Z",
- "shell.execute_reply.started": "2023-04-27T13:58:53.896117Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "!kubectl rollout status deploy \\\n",
- " $(kubectl get deploy -l seldon-deployment-id=seldon-deployment-example \\\n",
- " -o jsonpath='{.items[0].metadata.name}')"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Le service est-il disponible ?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T13:58:55.211582Z",
- "iopub.status.busy": "2023-04-27T13:58:55.211279Z",
- "iopub.status.idle": "2023-04-27T13:58:55.435452Z",
- "shell.execute_reply": "2023-04-27T13:58:55.434211Z",
- "shell.execute_reply.started": "2023-04-27T13:58:55.211552Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "for i in range(60):\n",
- " state = !kubectl get sdep seldon-deployment-example -o jsonpath='{.status.state}'\n",
- " state = state[0]\n",
- " print(state)\n",
- " if state == \"Available\":\n",
- " break\n",
- " time.sleep(1)\n",
- "assert state == \"Available\""
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Modèle de test\n",
- "\n",
- "Avec l'environnement virtuel configuré et activé, importez les bibliothèques Python nécessaires."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T15:58:43.902715Z",
- "iopub.status.busy": "2023-04-27T15:58:43.901670Z",
- "iopub.status.idle": "2023-04-27T15:58:43.906588Z",
- "shell.execute_reply": "2023-04-27T15:58:43.905572Z",
- "shell.execute_reply.started": "2023-04-27T15:58:43.902678Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "import json\n",
- "import pandas as pd"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Le classificateur d'iris prend un ensemble de quatre mesures, dans ce cas `[5.964, 1.006, 2.081, 1.031]`, et il renvoie un ensemble de probabilités, une pour chacun des trois types de fleurs d'iris. [Vous pouvez en savoir plus sur les données d'iris ici.](https://archive.ics.uci.edu/ml/datasets/iris) Envoyons quelques données au modèle."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T16:05:03.253143Z",
- "iopub.status.busy": "2023-04-27T16:05:03.252208Z",
- "iopub.status.idle": "2023-04-27T16:05:03.304174Z",
- "shell.execute_reply": "2023-04-27T16:05:03.303066Z",
- "shell.execute_reply.started": "2023-04-27T16:05:03.253106Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "res = !curl -v seldon-deployment-example-sklearn-iris-predictor.bryanpaget.svc.cluster.local:8000/api/v0.1/predictions \\\n",
- " -H 'Content-Type: application/json' \\\n",
- " -d '{\"data\": {\"ndarray\": [[5.964, 1.006, 2.081, 1.031]]}}'"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Résultats\n",
- "\n",
- "Ce sont les résultats en JSON brut."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T16:05:03.594132Z",
- "iopub.status.busy": "2023-04-27T16:05:03.593539Z",
- "iopub.status.idle": "2023-04-27T16:05:03.600395Z",
- "shell.execute_reply": "2023-04-27T16:05:03.599596Z",
- "shell.execute_reply.started": "2023-04-27T16:05:03.594090Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "parsed = json.loads(res[-1])\n",
- "print(json.dumps(parsed, indent=4, sort_keys=True))"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Cette fonction de traçage révèle un graphique à barres avec l'inférence du classificateur."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T16:05:04.188096Z",
- "iopub.status.busy": "2023-04-27T16:05:04.187614Z",
- "iopub.status.idle": "2023-04-27T16:05:04.541870Z",
- "shell.execute_reply": "2023-04-27T16:05:04.540936Z",
- "shell.execute_reply.started": "2023-04-27T16:05:04.188045Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "def display_iris_classifier_results(res):\n",
- " \"\"\" Prend les résultats de classification du classificateur d'iris et les trace dans un graphique à barres pour une visualisation facile des probabilités de classe.\n",
- "\n",
- " Arguments :\n",
- " res (string) : résultats du modèle d'iris servi par Seldon.\n",
- " \"\"\"\n",
- " results = res[-1]\n",
- " results = json.loads(results)\n",
- " names = results[\"data\"][\"names\"]\n",
- " predictions = results[\"data\"][\"ndarray\"][0]\n",
- " model = results[\"meta\"][\"requestPath\"]\n",
- " model = model.popitem()\n",
- " model, version = model[0], model[1]\n",
- "\n",
- " df = pd.DataFrame({\"Class\": names, \"Probability\": predictions})\n",
- "\n",
- " df.plot(\n",
- " kind=\"bar\",\n",
- " title=model.replace(\"-\", \" \").title(),\n",
- " xlabel=\"Classification\",\n",
- " ylabel=\"Probability\",\n",
- " legend=False\n",
- " )\n",
- "\n",
- "display_iris_classifier_results(res)"
- ]
- },
- {
- "attachments": {},
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Nettoyer\n",
- "\n",
- "Nettoyez en supprimant le déploiement."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "execution": {
- "iopub.execute_input": "2023-04-27T16:05:04.750111Z",
- "iopub.status.busy": "2023-04-27T16:05:04.749559Z",
- "iopub.status.idle": "2023-04-27T16:05:07.723921Z",
- "shell.execute_reply": "2023-04-27T16:05:07.722248Z",
- "shell.execute_reply.started": "2023-04-27T16:05:04.750073Z"
- },
- "tags": []
- },
- "outputs": [],
- "source": [
- "!kubectl delete -f sklearn_iris_jsondata_deployment.yaml"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": ".venv",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.6"
- },
- "varInspector": {
- "cols": {
- "lenName": 16,
- "lenType": 16,
- "lenVar": 40
- },
- "kernels_config": {
- "python": {
- "delete_cmd_postfix": "",
- "delete_cmd_prefix": "del ",
- "library": "var_list.py",
- "varRefreshCmd": "print(var_dic_list())"
- },
- "r": {
- "delete_cmd_postfix": ") ",
- "delete_cmd_prefix": "rm(",
- "library": "var_list.r",
- "varRefreshCmd": "cat(var_dic_list()) "
- }
- },
- "types_to_exclude": [
- "module",
- "function",
- "builtin_function_or_method",
- "instance",
- "_Feature"
- ],
- "window_display": false
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/docs/fr/images/argo-workflows.jpg b/docs/fr/images/argo-workflows.jpg
new file mode 100644
index 000000000..3042e54a1
Binary files /dev/null and b/docs/fr/images/argo-workflows.jpg differ
diff --git a/docs/fr/images/argo.png b/docs/fr/images/argo.png
new file mode 100644
index 000000000..6d1819bd2
Binary files /dev/null and b/docs/fr/images/argo.png differ
diff --git a/mkdocs-fr.yml b/mkdocs-fr.yml
index 9184cb2aa..7348b254c 100644
--- a/mkdocs-fr.yml
+++ b/mkdocs-fr.yml
@@ -75,9 +75,7 @@ nav:
- Power BI: 2-Publication/PowerBI.md
- Sur mesure: 2-Publication/Sur-mesure.md
- Pipelines:
- - Kubeflow Pipelines: 3-Pipelines/Machine-Learning-Training-Pipelines.md
- - PaaS Integration: 3-Pipelines/Machine-Learning-Training-Pipelines.md
- - Model Serving: 3-Pipelines/Machine-Learning-Model-Serving.md
+ - Argo: 3-Pipelines/Argo.md
- Collaboration:
- Aperçu: 4-Collaboration/Aperçu.md
- Demander un espace de nom: 4-Collaboration/Demander-EspaceDeNom.md