diff --git a/dev/sitemap.xml b/dev/sitemap.xml index adf30b241..da4778fab 100644 --- a/dev/sitemap.xml +++ b/dev/sitemap.xml @@ -2,357 +2,357 @@ https://statcan.github.io/aaw/en/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/developer-tools/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Argocd%20Applications/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Argoflow%20Azure/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Contrib%20Containers/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Contrib%20Jupyter%20Notebooks/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Contrib%20R%20Notebooks/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Goofys%20Injector/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Gpu%20Toleration%20Injector/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Inferenceservices%20Controller/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Kubeflow%20Containers/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Kubeflow%20Controller/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Kubeflow%20Manifests/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Kubeflow%20Mlops/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Kubeflow%20Opa%20Sync/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Kubeflow%20Pipelines%20Secret%20Scanner/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Kubeflow%20Profiles%20Controller/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Minio%20Credential%20Injector/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Namespace%20Injector/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Prob%20Notebook%20Controller/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Profile%20State%20Controller/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Security%20Scanning%20Containers/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Aaw%20Toleration%20Injector/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Boathouse/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Charts/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Geoserver/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Goofys/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Jupyter%20Apis/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Jupyterlab%20Language%20Pack%20Fr_fr/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Kubecost/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Kubeflow/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Kubeflow/CHANGELOG/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Kubeflow%20Containers%20Desktop/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Kubeflow%20Pipelines/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Kubeflow%20Pipelines/CHANGELOG/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Minio%20Deploy/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Minio%20Operator/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Mlflow%20Operator/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Pachyderm/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/R%20Dashboards/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Shiny/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Advanced%20Analytics%20Workspaces%20Infrastructure%20Example/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Azure%20Statcan%20Aaw%20Environment/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Azure%20Statcan%20Aaw%20Network/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Azure%20Statcan%20Aaw%20Region%20Environment/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Azure%20Statcan%20Cloud%20Native%20Environment%20Infrastructure/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Azurerm%20Kubernetes%20Cluster/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Azurerm%20Kubernetes%20Cluster%20Nodepool/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Kubernetes%20Aks%20Daaas/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Kubernetes%20Aks%20Platform%20Daaas/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Kubernetes%20Cert%20Manager%20Certificate/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Kubernetes%20Cert%20Manager%20Issuer/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Kubernetes%20Istio%20Operator%20Cr/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Statcan%20Aaw%20Infrastructure%20Example/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Terraform%20Statcan%20Aaw%20Platform/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Vault%20Plugin%20Secrets%20Minio/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/features/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/features/cloud-main-connectivity/cloud-main-connectivity/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/features/data-virtualization/trino/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/features/object-storage/blobcsi/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/features/object-storage/s3proxy/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/features/rbac/non-employee-rbac/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/features/source-control/gitea/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/getting-started/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/getting-started/jupyterlab/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/getting-started/login/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/getting-started/setup/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/getting-started/tms/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/getting-started/vm/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/resources/ - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/resources/networking/ - 2023-12-11 + 2023-12-13 daily \ No newline at end of file diff --git a/dev/sitemap.xml.gz b/dev/sitemap.xml.gz index cfa875047..26b180ad0 100644 Binary files a/dev/sitemap.xml.gz and b/dev/sitemap.xml.gz differ diff --git a/en/1-Experiments/Jupyter.html b/en/1-Experiments/Jupyter.html index 71460d8a9..7fe39ee7c 100644 --- a/en/1-Experiments/Jupyter.html +++ b/en/1-Experiments/Jupyter.html @@ -763,6 +763,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/1-Experiments/Kubeflow.html b/en/1-Experiments/Kubeflow.html index 3c215149e..6ad0ea41d 100644 --- a/en/1-Experiments/Kubeflow.html +++ b/en/1-Experiments/Kubeflow.html @@ -730,6 +730,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/1-Experiments/MLflow.html b/en/1-Experiments/MLflow.html index 48cdeb821..d7296d997 100644 --- a/en/1-Experiments/MLflow.html +++ b/en/1-Experiments/MLflow.html @@ -673,6 +673,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/1-Experiments/Notebooks/DTale_EN.html b/en/1-Experiments/Notebooks/DTale_EN.html index f05e6117b..785c61add 100644 --- a/en/1-Experiments/Notebooks/DTale_EN.html +++ b/en/1-Experiments/Notebooks/DTale_EN.html @@ -741,6 +741,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • @@ -2220,11 +2241,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U dtale
    %%capture -! pip install -r requirements.txt ! pip install -U dtale
    diff --git a/en/1-Experiments/Notebooks/DTale_EN.ipynb b/en/1-Experiments/Notebooks/DTale_EN.ipynb index 1143608b8..697310270 100644 --- a/en/1-Experiments/Notebooks/DTale_EN.ipynb +++ b/en/1-Experiments/Notebooks/DTale_EN.ipynb @@ -33,7 +33,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U dtale" ] }, diff --git a/en/1-Experiments/Notebooks/DrawData_EN.html b/en/1-Experiments/Notebooks/DrawData_EN.html index beee46cd8..68b01d93e 100644 --- a/en/1-Experiments/Notebooks/DrawData_EN.html +++ b/en/1-Experiments/Notebooks/DrawData_EN.html @@ -759,6 +759,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • @@ -2263,16 +2284,10 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U drawdata
-# On Linux you'll need to:
-# sudo apt-get install xsel xclip -y
    %%capture -! pip install -r requirements.txt -! pip install -U drawdata -# On Linux you'll need to: -# sudo apt-get install xsel xclip -y
    +! pip install -U drawdata diff --git a/en/1-Experiments/Notebooks/DrawData_EN.ipynb b/en/1-Experiments/Notebooks/DrawData_EN.ipynb index 3cd3bf6d0..9997bc518 100644 --- a/en/1-Experiments/Notebooks/DrawData_EN.ipynb +++ b/en/1-Experiments/Notebooks/DrawData_EN.ipynb @@ -31,10 +31,7 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", - "! pip install -U drawdata\n", - "# On Linux you'll need to:\n", - "# sudo apt-get install xsel xclip -y" + "! pip install -U drawdata" ] }, { diff --git a/en/1-Experiments/Notebooks/MitoSheet_EN.html b/en/1-Experiments/Notebooks/MitoSheet_EN.html index 1bb40f9c6..f69db9994 100644 --- a/en/1-Experiments/Notebooks/MitoSheet_EN.html +++ b/en/1-Experiments/Notebooks/MitoSheet_EN.html @@ -750,6 +750,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • @@ -2235,13 +2256,11 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U mitosheet
 ! python -m jupyter nbextension install --py --user mitosheet
 ! python -m jupyter nbextension enable --py --user mitosheet
    %%capture -! pip install -r requirements.txt ! pip install -U mitosheet ! python -m jupyter nbextension install --py --user mitosheet ! python -m jupyter nbextension enable --py --user mitosheet
    diff --git a/en/1-Experiments/Notebooks/MitoSheet_EN.ipynb b/en/1-Experiments/Notebooks/MitoSheet_EN.ipynb index 3350bfdfe..4a0e18322 100644 --- a/en/1-Experiments/Notebooks/MitoSheet_EN.ipynb +++ b/en/1-Experiments/Notebooks/MitoSheet_EN.ipynb @@ -28,7 +28,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U mitosheet\n", "! python -m jupyter nbextension install --py --user mitosheet\n", "! python -m jupyter nbextension enable --py --user mitosheet" diff --git a/en/1-Experiments/Notebooks/PyGWalker_EN.html b/en/1-Experiments/Notebooks/PyGWalker_EN.html index d829fb101..84a1e65aa 100644 --- a/en/1-Experiments/Notebooks/PyGWalker_EN.html +++ b/en/1-Experiments/Notebooks/PyGWalker_EN.html @@ -16,7 +16,7 @@ - + @@ -759,6 +759,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • @@ -2258,11 +2279,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U pygwalker ydata-profiling ipywidgets
    %%capture -! pip install -r requirements.txt ! pip install -U pygwalker ydata-profiling ipywidgets
    diff --git a/en/1-Experiments/Notebooks/PyGWalker_EN.ipynb b/en/1-Experiments/Notebooks/PyGWalker_EN.ipynb index 0c91c42bb..cf410d326 100644 --- a/en/1-Experiments/Notebooks/PyGWalker_EN.ipynb +++ b/en/1-Experiments/Notebooks/PyGWalker_EN.ipynb @@ -38,7 +38,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U pygwalker ydata-profiling ipywidgets" ] }, diff --git a/en/1-Experiments/Notebooks/ReRun_EN.html b/en/1-Experiments/Notebooks/ReRun_EN.html new file mode 100644 index 000000000..dd9c0e993 --- /dev/null +++ b/en/1-Experiments/Notebooks/ReRun_EN.html @@ -0,0 +1,2917 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + ReRun: Fast and Powerful Multimodal Data Visualization - Advanced Analytics Workspace + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +     +
    + +
    + + + + + + +
    + + + + + + + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + + + + + + + + +
    + +
    + + + + + + + + + + + + + + + + + +
    +
    + + + + + +
    + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/en/1-Experiments/Notebooks/ReRun_EN.ipynb b/en/1-Experiments/Notebooks/ReRun_EN.ipynb new file mode 100644 index 000000000..adce3f99c --- /dev/null +++ b/en/1-Experiments/Notebooks/ReRun_EN.ipynb @@ -0,0 +1,316 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1bd46748-42b9-46ea-9fea-fee20634a793", + "metadata": {}, + "source": [ + "# ReRun: Fast and Powerful Multimodal Data Visualization\n", + "\n", + "Welcome to ReRun, your go-to SDK for visualizing multimodal data that dynamically evolves over time. Engineers and researchers in fields like computer vision and robotics leverage ReRun to verify, debug, and demonstrate their projects with unparalleled efficiency.\n", + "\n", + "![Multimodal Timeseries Data](./img/rerun-multi-1.png)\n", + "\n", + "## Key Highlights\n", + "\n", + "- **Open-Core Model:** ReRun operates on an open-core model, ensuring that everything in this repository remains open source and free. In the future, ReRun will introduce a commercial product that builds upon the robust foundation of the core free project.\n", + "\n", + "- **Tailored for Individuals and Teams:** The open source project caters to the needs of individual developers, while the upcoming commercial product will specifically address the requirements of teams involved in building and running computer vision and robotics products.\n", + "\n", + "- **Versatile and Cross-Platform:** ReRun is an SDK and engine designed for visualizing and interacting with multimodal data streams. It's simple to integrate and get started with, usable from Python, Rust, and C++, and built in Rust for cross-platform compatibility and speed.\n", + "\n", + "- **Open Source:** ReRun is committed to open source principles, dual-licensed under MIT and Apache 2.\n", + "\n", + "## Installation\n", + "\n", + "To unleash the power of ReRun, install it in your JupyterLab environment with a simple command:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d9f41c51-e09f-4a37-b5e6-3ff4766001ea", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%capture\n", + "! pip install -U rerun-sdk" + ] + }, + { + "cell_type": "markdown", + "id": "b421be69-2741-4d5c-a3fa-f60f8d9187aa", + "metadata": { + "tags": [] + }, + "source": [ + "## Getting Started\n", + "\n", + "For an optimal ReRun experience, it's recommended to use a Linux, Mac, or Windows desktop session instead of JupyterLab. Access the full ReRun viewer by running `rr.spawn()` in the following script from your terminal emulator:\n", + "\n", + "``` python\n", + "import rerun as rr\n", + "\n", + "rr.spawn()\n", + "```\n", + "\n", + "However, if JupyterLab is your preferred environment, ReRun seamlessly operates within it. Refer to the [official documentation](https://www.rerun.io/docs/howto/notebook) for details on running ReRun within JupyterLab. The simplest JupyterLab example is to open ReRun using the `memory_recording()` and `show()` methods:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9918233", + "metadata": {}, + "outputs": [], + "source": [ + "import rerun as rr\n", + "\n", + "rec = rr.memory_recording()\n", + "rec.show(width=1024, height=768)" + ] + }, + { + "cell_type": "markdown", + "id": "b84e8b9d", + "metadata": {}, + "source": [ + "## 3D Visualization: The Cube\n", + "\n", + "Experience the simplicity of 3D visualization with ReRun by generating and plotting points in space:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7127bbc", + "metadata": {}, + "outputs": [], + "source": [ + "import rerun as rr\n", + "import numpy as np\n", + "\n", + "rec = rr.memory_recording()\n", + "\n", + "SIZE = 10\n", + "\n", + "pos_grid = np.meshgrid(*[np.linspace(-10, 10, SIZE)]*3)\n", + "positions = np.vstack([d.reshape(-1) for d in pos_grid]).T\n", + "\n", + "col_grid = np.meshgrid(*[np.linspace(0, 255, SIZE)]*3)\n", + "colors = np.vstack([c.reshape(-1) for c in col_grid]).astype(np.uint8).T\n", + "\n", + "rr.log(\n", + " \"my_points\",\n", + " rr.Points3D(positions, colors=colors, radii=0.5)\n", + ")\n", + "\n", + "rec.show(width=1024, height=768)" + ] + }, + { + "cell_type": "markdown", + "id": "759d2169", + "metadata": {}, + "source": [ + "\n", + "## 3D Visualization: The DNA\n", + "\n", + "Explore a fascinating example of synthetic 3D data visualization in the shape of a double helix:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9bd9a87", + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "import argparse\n", + "from math import tau\n", + "\n", + "import numpy as np\n", + "\n", + "import rerun as rr # pip install rerun-sdk\n", + "from rerun.utilities import bounce_lerp, build_color_spiral\n", + "\n", + "rec = rr.memory_recording()\n", + "\n", + "rr.set_time_seconds(\"stable_time\", 0)\n", + "\n", + "NUM_POINTS = 100\n", + "\n", + "# points and colors are both np.array((NUM_POINTS, 3))\n", + "points1, colors1 = build_color_spiral(NUM_POINTS)\n", + "points2, colors2 = build_color_spiral(NUM_POINTS, angular_offset=tau * 0.5)\n", + "rr.log(\"helix/structure/left\", rr.Points3D(points1, colors=colors1, radii=0.08))\n", + "rr.log(\"helix/structure/right\", rr.Points3D(points2, colors=colors2, radii=0.08))\n", + "\n", + "rr.log(\"helix/structure/scaffolding\", rr.LineStrips3D(np.stack((points1, points2), axis=1), colors=[128, 128, 128]))\n", + "\n", + "time_offsets = np.random.rand(NUM_POINTS)\n", + "for i in range(400):\n", + " time = i * 0.01\n", + " rr.set_time_seconds(\"stable_time\", time)\n", + "\n", + " times = np.repeat(time, NUM_POINTS) + time_offsets\n", + " beads = [bounce_lerp(points1[n], points2[n], times[n]) for n in range(NUM_POINTS)]\n", + " colors = [[int(bounce_lerp(80, 230, times[n] * 2))] for n in range(NUM_POINTS)]\n", + " rr.log(\n", + " \"helix/structure/scaffolding/beads\", rr.Points3D(beads, radii=0.06, colors=np.repeat(colors, 3, axis=-1))\n", + " )\n", + "\n", + " rr.log(\n", + " \"helix/structure\",\n", + " rr.Transform3D(rotation=rr.RotationAxisAngle(axis=[0, 0, 1], radians=time / 4.0 * tau)),\n", + " )\n", + "\n", + "rec.show(width=1024, height=768)" + ] + }, + { + "cell_type": "markdown", + "id": "cb0cbca9", + "metadata": {}, + "source": [ + "## Time-Series Data: Plots that Impress\n", + "\n", + "ReRun truly shines when visualizing multimodal time-series data. The following example demonstrates ReRun's prowess in displaying various plots corresponding to different readings on the same time-series data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de21e1f2", + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "import argparse\n", + "import random\n", + "from math import cos, sin, tau\n", + "\n", + "import numpy as np\n", + "import rerun as rr # pip install rerun-sdk\n", + "\n", + "rec = rr.memory_recording()\n", + "\n", + "def clamp(n, smallest, largest): # type: ignore[no-untyped-def]\n", + " return max(smallest, min(n, largest))\n", + "\n", + "\n", + "def log_bar_chart() -> None:\n", + " rr.set_time_sequence(\"frame_nr\", 0)\n", + " # Log a gauss bell as a bar chart\n", + " mean = 0\n", + " std = 1\n", + " variance = np.square(std)\n", + " x = np.arange(-5, 5, 0.1)\n", + " y = np.exp(-np.square(x - mean) / 2 * variance) / (np.sqrt(2 * np.pi * variance))\n", + " rr.log(\"bar_chart\", rr.BarChart(y))\n", + "\n", + "\n", + "def log_parabola() -> None:\n", + " # Log a parabola as a time series\n", + " for t in range(0, 1000, 10):\n", + " rr.set_time_sequence(\"frame_nr\", t)\n", + "\n", + " f_of_t = (t * 0.01 - 5) ** 3 + 1\n", + " radius = clamp(abs(f_of_t) * 0.1, 0.5, 10.0)\n", + " color = [255, 255, 0]\n", + " if f_of_t < -10.0:\n", + " color = [255, 0, 0]\n", + " elif f_of_t > 10.0:\n", + " color = [0, 255, 0]\n", + "\n", + " rr.log(\n", + " \"curves/parabola\",\n", + " rr.TimeSeriesScalar(\n", + " f_of_t,\n", + " label=\"f(t) = (0.01t - 3)³ + 1\",\n", + " radius=radius,\n", + " color=color,\n", + " ),\n", + " )\n", + "\n", + "\n", + "def log_trig() -> None:\n", + " # Log a time series\n", + " for t in range(0, int(tau * 2 * 100.0)):\n", + " rr.set_time_sequence(\"frame_nr\", t)\n", + "\n", + " sin_of_t = sin(float(t) / 100.0)\n", + " rr.log(\"trig/sin\", rr.TimeSeriesScalar(sin_of_t, label=\"sin(0.01t)\", color=[255, 0, 0]))\n", + "\n", + " cos_of_t = cos(float(t) / 100.0)\n", + " rr.log(\"trig/cos\", rr.TimeSeriesScalar(cos_of_t, label=\"cos(0.01t)\", color=[0, 255, 0]))\n", + "\n", + "\n", + "def log_classification() -> None:\n", + " # Log a time series\n", + " for t in range(0, 1000, 2):\n", + " rr.set_time_sequence(\"frame_nr\", t)\n", + "\n", + " f_of_t = (2 * 0.01 * t) + 2\n", + " color = [255, 255, 0]\n", + " rr.log(\"classification/line\", rr.TimeSeriesScalar(f_of_t, color=color, radius=3.0))\n", + "\n", + " g_of_t = f_of_t + random.uniform(-5.0, 5.0)\n", + " if g_of_t < f_of_t - 1.5:\n", + " color = [255, 0, 0]\n", + " elif g_of_t > f_of_t + 1.5:\n", + " color = [0, 255, 0]\n", + " else:\n", + " color = [255, 255, 255]\n", + " radius = abs(g_of_t - f_of_t)\n", + " rr.log(\"classification/samples\", rr.TimeSeriesScalar(g_of_t, color=color, scattered=True, radius=radius))\n", + "\n", + "\n", + "log_bar_chart()\n", + "log_parabola()\n", + "log_trig()\n", + "log_classification()\n", + "\n", + "rec.show(width=1024, height=768)\n" + ] + }, + { + "cell_type": "markdown", + "id": "d9bd7e11", + "metadata": {}, + "source": [ + "## Dive Deeper\n", + "\n", + "For an in-depth understanding of ReRun and its capabilities, refer to the [official ReRun Python Quickstart](https://www.rerun.io/docs/quickstart/python/).\n", + "\n", + "Now, armed with ReRun, embark on a journey of unparalleled data visualization and exploration. Happy coding!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/en/1-Experiments/Notebooks/SweetViz_EN.html b/en/1-Experiments/Notebooks/SweetViz_EN.html index e0ade0410..7ad6a46e1 100644 --- a/en/1-Experiments/Notebooks/SweetViz_EN.html +++ b/en/1-Experiments/Notebooks/SweetViz_EN.html @@ -13,7 +13,7 @@ - + @@ -681,6 +681,27 @@ + + +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + @@ -2270,11 +2291,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U sweetviz ydata-profiling
    %%capture -! pip install -r requirements.txt ! pip install -U sweetviz ydata-profiling
    diff --git a/en/1-Experiments/Notebooks/SweetViz_EN.ipynb b/en/1-Experiments/Notebooks/SweetViz_EN.ipynb index 75260ac8a..52dfa8f2c 100644 --- a/en/1-Experiments/Notebooks/SweetViz_EN.ipynb +++ b/en/1-Experiments/Notebooks/SweetViz_EN.ipynb @@ -44,7 +44,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U sweetviz ydata-profiling" ] }, diff --git a/en/1-Experiments/Notebooks/VisualPython_EN.html b/en/1-Experiments/Notebooks/VisualPython_EN.html index 3b5a297bd..631881108 100644 --- a/en/1-Experiments/Notebooks/VisualPython_EN.html +++ b/en/1-Experiments/Notebooks/VisualPython_EN.html @@ -683,6 +683,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • @@ -2330,11 +2351,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U jupyterlab-visualpython plotly wordcloud
    %%capture -! pip install -r requirements.txt ! pip install -U jupyterlab-visualpython plotly wordcloud
    diff --git a/en/1-Experiments/Notebooks/VisualPython_EN.ipynb b/en/1-Experiments/Notebooks/VisualPython_EN.ipynb index 009a966a1..5a9161e36 100644 --- a/en/1-Experiments/Notebooks/VisualPython_EN.ipynb +++ b/en/1-Experiments/Notebooks/VisualPython_EN.ipynb @@ -34,7 +34,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U jupyterlab-visualpython plotly wordcloud" ] }, diff --git a/en/1-Experiments/Notebooks/YData-Profiling_EN.html b/en/1-Experiments/Notebooks/YData-Profiling_EN.html index 8811dc3d0..60a63a512 100644 --- a/en/1-Experiments/Notebooks/YData-Profiling_EN.html +++ b/en/1-Experiments/Notebooks/YData-Profiling_EN.html @@ -683,6 +683,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • @@ -2300,11 +2321,9 @@

    Quickstart:< 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U ydata-profiling ipywidgets scikit-learn
    %%capture -! pip install -r requirements.txt ! pip install -U ydata-profiling ipywidgets scikit-learn
    diff --git a/en/1-Experiments/Notebooks/YData-Profiling_EN.ipynb b/en/1-Experiments/Notebooks/YData-Profiling_EN.ipynb index 0ee903039..88c6f6773 100644 --- a/en/1-Experiments/Notebooks/YData-Profiling_EN.ipynb +++ b/en/1-Experiments/Notebooks/YData-Profiling_EN.ipynb @@ -26,7 +26,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U ydata-profiling ipywidgets scikit-learn" ] }, diff --git a/en/1-Experiments/Notebooks/img/rerun-cube.png b/en/1-Experiments/Notebooks/img/rerun-cube.png new file mode 100644 index 000000000..28d5d591e Binary files /dev/null and b/en/1-Experiments/Notebooks/img/rerun-cube.png differ diff --git a/en/1-Experiments/Notebooks/img/rerun-dna.png b/en/1-Experiments/Notebooks/img/rerun-dna.png new file mode 100644 index 000000000..21bb51eb1 Binary files /dev/null and b/en/1-Experiments/Notebooks/img/rerun-dna.png differ diff --git a/en/1-Experiments/Notebooks/img/rerun-empty.png b/en/1-Experiments/Notebooks/img/rerun-empty.png new file mode 100644 index 000000000..c8f122994 Binary files /dev/null and b/en/1-Experiments/Notebooks/img/rerun-empty.png differ diff --git a/en/1-Experiments/Notebooks/img/rerun-multi-1.png b/en/1-Experiments/Notebooks/img/rerun-multi-1.png new file mode 100644 index 000000000..8fa533b39 Binary files /dev/null and b/en/1-Experiments/Notebooks/img/rerun-multi-1.png differ diff --git a/en/1-Experiments/Overview.html b/en/1-Experiments/Overview.html index 96e759188..53fa3bad2 100644 --- a/en/1-Experiments/Overview.html +++ b/en/1-Experiments/Overview.html @@ -726,6 +726,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/1-Experiments/RStudio.html b/en/1-Experiments/RStudio.html index 08fd55098..30e586253 100644 --- a/en/1-Experiments/RStudio.html +++ b/en/1-Experiments/RStudio.html @@ -691,6 +691,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/1-Experiments/Remote-Desktop.html b/en/1-Experiments/Remote-Desktop.html index d5dfe572c..fc2965140 100644 --- a/en/1-Experiments/Remote-Desktop.html +++ b/en/1-Experiments/Remote-Desktop.html @@ -757,6 +757,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/1-Experiments/Selecting-an-Image.html b/en/1-Experiments/Selecting-an-Image.html index 981b2e459..2526277b8 100644 --- a/en/1-Experiments/Selecting-an-Image.html +++ b/en/1-Experiments/Selecting-an-Image.html @@ -673,6 +673,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/1-Experiments/Virtual-Environments.html b/en/1-Experiments/Virtual-Environments.html index 6e57e47b7..5176c5d44 100644 --- a/en/1-Experiments/Virtual-Environments.html +++ b/en/1-Experiments/Virtual-Environments.html @@ -811,6 +811,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/2-Publishing/Custom.html b/en/2-Publishing/Custom.html index 19b03c0e3..1dbad48f2 100644 --- a/en/2-Publishing/Custom.html +++ b/en/2-Publishing/Custom.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/2-Publishing/Dash.html b/en/2-Publishing/Dash.html index 738a6ba17..ea51aab31 100644 --- a/en/2-Publishing/Dash.html +++ b/en/2-Publishing/Dash.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/2-Publishing/Datasette.html b/en/2-Publishing/Datasette.html index 1ef9e5fdf..70d4f4b2d 100644 --- a/en/2-Publishing/Datasette.html +++ b/en/2-Publishing/Datasette.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/2-Publishing/Overview.html b/en/2-Publishing/Overview.html index 2deaaad7b..20fb86544 100644 --- a/en/2-Publishing/Overview.html +++ b/en/2-Publishing/Overview.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/2-Publishing/PowerBI.html b/en/2-Publishing/PowerBI.html index bfab34a21..64aecb4e4 100644 --- a/en/2-Publishing/PowerBI.html +++ b/en/2-Publishing/PowerBI.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/2-Publishing/R-Shiny.html b/en/2-Publishing/R-Shiny.html index e92798647..45d91caba 100644 --- a/en/2-Publishing/R-Shiny.html +++ b/en/2-Publishing/R-Shiny.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/3-Pipelines/Argo.html b/en/3-Pipelines/Argo.html index fac4ebbff..cd9ae92dd 100644 --- a/en/3-Pipelines/Argo.html +++ b/en/3-Pipelines/Argo.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/4-Collaboration/Geospatial-Analytical-Environment.html b/en/4-Collaboration/Geospatial-Analytical-Environment.html index 0c95bd439..924370b4c 100644 --- a/en/4-Collaboration/Geospatial-Analytical-Environment.html +++ b/en/4-Collaboration/Geospatial-Analytical-Environment.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/4-Collaboration/Overview.html b/en/4-Collaboration/Overview.html index 3361e8f2a..ec6fd65a9 100644 --- a/en/4-Collaboration/Overview.html +++ b/en/4-Collaboration/Overview.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/4-Collaboration/Request-a-Namespace.html b/en/4-Collaboration/Request-a-Namespace.html index 14e18fa28..399e2d57b 100644 --- a/en/4-Collaboration/Request-a-Namespace.html +++ b/en/4-Collaboration/Request-a-Namespace.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/404.html b/en/404.html index ee13107ba..b55367bba 100644 --- a/en/404.html +++ b/en/404.html @@ -666,6 +666,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/5-Storage/AzureBlobStorage.html b/en/5-Storage/AzureBlobStorage.html index c5f842e79..7d1e77b53 100644 --- a/en/5-Storage/AzureBlobStorage.html +++ b/en/5-Storage/AzureBlobStorage.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/5-Storage/Disks.html b/en/5-Storage/Disks.html index 136556a60..2fcf21af3 100644 --- a/en/5-Storage/Disks.html +++ b/en/5-Storage/Disks.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/5-Storage/Overview.html b/en/5-Storage/Overview.html index a7cc64982..48d18cd52 100644 --- a/en/5-Storage/Overview.html +++ b/en/5-Storage/Overview.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/6-Gitlab/Gitlab.html b/en/6-Gitlab/Gitlab.html index 4de31e30c..d2874177c 100644 --- a/en/6-Gitlab/Gitlab.html +++ b/en/6-Gitlab/Gitlab.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/Machine-Learning-Model-Cloud-Storage.html b/en/7-MLOps/Machine-Learning-Model-Cloud-Storage.html index 4b86e7122..49e6ead24 100644 --- a/en/7-MLOps/Machine-Learning-Model-Cloud-Storage.html +++ b/en/7-MLOps/Machine-Learning-Model-Cloud-Storage.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/Machine-Learning-Model-Serving.html b/en/7-MLOps/Machine-Learning-Model-Serving.html index 2c8fadd99..76d300f90 100644 --- a/en/7-MLOps/Machine-Learning-Model-Serving.html +++ b/en/7-MLOps/Machine-Learning-Model-Serving.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/Machine-Learning-Training-Pipelines.html b/en/7-MLOps/Machine-Learning-Training-Pipelines.html index 4a31e00a7..65e2f80a4 100644 --- a/en/7-MLOps/Machine-Learning-Training-Pipelines.html +++ b/en/7-MLOps/Machine-Learning-Training-Pipelines.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/Machine-Learning.html b/en/7-MLOps/Machine-Learning.html index 5814d470a..f85651e51 100644 --- a/en/7-MLOps/Machine-Learning.html +++ b/en/7-MLOps/Machine-Learning.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/Overview.html b/en/7-MLOps/Overview.html index 32a8843f5..39184dd9a 100644 --- a/en/7-MLOps/Overview.html +++ b/en/7-MLOps/Overview.html @@ -674,6 +674,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/PaaS-Integration.html b/en/7-MLOps/PaaS-Integration.html index 04eaee47f..a2b28ea49 100644 --- a/en/7-MLOps/PaaS-Integration.html +++ b/en/7-MLOps/PaaS-Integration.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/Serving.html b/en/7-MLOps/Serving.html index e19195c7e..d98b0b5fd 100644 --- a/en/7-MLOps/Serving.html +++ b/en/7-MLOps/Serving.html @@ -673,6 +673,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/7-MLOps/sklearn_iris_jsondata.html b/en/7-MLOps/sklearn_iris_jsondata.html index 8b1c2dbb7..bd3d6d86b 100644 --- a/en/7-MLOps/sklearn_iris_jsondata.html +++ b/en/7-MLOps/sklearn_iris_jsondata.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/8-MicroSim/GettingStarted.html b/en/8-MicroSim/GettingStarted.html index 79bd2c78d..65de88a01 100644 --- a/en/8-MicroSim/GettingStarted.html +++ b/en/8-MicroSim/GettingStarted.html @@ -679,6 +679,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/Help.html b/en/Help.html index aaaff07f8..3e8127a74 100644 --- a/en/Help.html +++ b/en/Help.html @@ -677,6 +677,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/index.html b/en/index.html index 47577c22c..1ed2c75c0 100644 --- a/en/index.html +++ b/en/index.html @@ -819,6 +819,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/sitemap.xml b/en/sitemap.xml index dd6b0d9cf..077cf486b 100644 --- a/en/sitemap.xml +++ b/en/sitemap.xml @@ -2,212 +2,217 @@ https://statcan.github.io/aaw/en/index.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/Help.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/welcome-message.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/welcome.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Jupyter.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Kubeflow.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/MLflow.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Overview.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/RStudio.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Remote-Desktop.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Selecting-an-Image.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Virtual-Environments.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Notebooks/DTale_EN.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Notebooks/DrawData_EN.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Notebooks/MitoSheet_EN.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Notebooks/PyGWalker_EN.html - 2023-12-11 + 2023-12-13 + daily + + + https://statcan.github.io/aaw/en/1-Experiments/Notebooks/ReRun_EN.html + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Notebooks/SweetViz_EN.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Notebooks/VisualPython_EN.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/1-Experiments/Notebooks/YData-Profiling_EN.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/2-Publishing/Custom.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/2-Publishing/Dash.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/2-Publishing/Datasette.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/2-Publishing/Overview.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/2-Publishing/PowerBI.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/2-Publishing/R-Shiny.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/3-Pipelines/Argo.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/4-Collaboration/Geospatial-Analytical-Environment.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/4-Collaboration/Overview.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/4-Collaboration/Request-a-Namespace.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/5-Storage/AzureBlobStorage.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/5-Storage/Disks.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/5-Storage/Overview.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/6-Gitlab/Gitlab.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/Machine-Learning-Model-Cloud-Storage.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/Machine-Learning-Model-Serving.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/Machine-Learning-Training-Pipelines.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/Machine-Learning.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/Overview.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/PaaS-Integration.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/Serving.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/7-MLOps/sklearn_iris_jsondata.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/en/8-MicroSim/GettingStarted.html - 2023-12-11 + 2023-12-13 daily \ No newline at end of file diff --git a/en/sitemap.xml.gz b/en/sitemap.xml.gz index 9ba587c28..d08267ba3 100644 Binary files a/en/sitemap.xml.gz and b/en/sitemap.xml.gz differ diff --git a/en/welcome-message.html b/en/welcome-message.html index 945e4e942..6b589d114 100644 --- a/en/welcome-message.html +++ b/en/welcome-message.html @@ -673,6 +673,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/en/welcome.html b/en/welcome.html index 42b080c72..f87224665 100644 --- a/en/welcome.html +++ b/en/welcome.html @@ -673,6 +673,27 @@ +
  • + + + + + ReRun: Fast and Powerful Multimodal Data Visualization + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/Apercu.html b/fr/1-Experiences/Apercu.html index 61c0dd687..d42ace067 100644 --- a/fr/1-Experiences/Apercu.html +++ b/fr/1-Experiences/Apercu.html @@ -745,6 +745,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/Bureau-virtuel.html b/fr/1-Experiences/Bureau-virtuel.html index fba94ac57..8af68a1ba 100644 --- a/fr/1-Experiences/Bureau-virtuel.html +++ b/fr/1-Experiences/Bureau-virtuel.html @@ -776,6 +776,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/Environnements-virtuels.html b/fr/1-Experiences/Environnements-virtuels.html index 2d251da8b..c488d7534 100644 --- a/fr/1-Experiences/Environnements-virtuels.html +++ b/fr/1-Experiences/Environnements-virtuels.html @@ -830,6 +830,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/Jupyter.html b/fr/1-Experiences/Jupyter.html index a56b03ac0..5770ec7c3 100644 --- a/fr/1-Experiences/Jupyter.html +++ b/fr/1-Experiences/Jupyter.html @@ -782,6 +782,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/Kubeflow.html b/fr/1-Experiences/Kubeflow.html index 8bb231e25..ccc9babb3 100644 --- a/fr/1-Experiences/Kubeflow.html +++ b/fr/1-Experiences/Kubeflow.html @@ -749,6 +749,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/MLflow.html b/fr/1-Experiences/MLflow.html index 49ef82a79..19329cf26 100644 --- a/fr/1-Experiences/MLflow.html +++ b/fr/1-Experiences/MLflow.html @@ -692,6 +692,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/RStudio.html b/fr/1-Experiences/RStudio.html index 1592fd4ba..3182ca296 100644 --- a/fr/1-Experiences/RStudio.html +++ b/fr/1-Experiences/RStudio.html @@ -710,6 +710,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/Selectionner-une-image.html b/fr/1-Experiences/Selectionner-une-image.html index aa7874fda..a95dc7767 100644 --- a/fr/1-Experiences/Selectionner-une-image.html +++ b/fr/1-Experiences/Selectionner-une-image.html @@ -692,6 +692,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/1-Experiences/bloc-notes/DTale_FR.html b/fr/1-Experiences/bloc-notes/DTale_FR.html index 1802f02b2..ab6dd7114 100644 --- a/fr/1-Experiences/bloc-notes/DTale_FR.html +++ b/fr/1-Experiences/bloc-notes/DTale_FR.html @@ -760,6 +760,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • @@ -2143,11 +2164,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U dtale
    %%capture -! pip install -r requirements.txt ! pip install -U dtale
    diff --git a/fr/1-Experiences/bloc-notes/DTale_FR.ipynb b/fr/1-Experiences/bloc-notes/DTale_FR.ipynb index a2b65bf2f..3b24211f1 100644 --- a/fr/1-Experiences/bloc-notes/DTale_FR.ipynb +++ b/fr/1-Experiences/bloc-notes/DTale_FR.ipynb @@ -32,7 +32,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U dtale" ] }, diff --git a/fr/1-Experiences/bloc-notes/DrawData_FR.html b/fr/1-Experiences/bloc-notes/DrawData_FR.html index a41df0978..72706b73c 100644 --- a/fr/1-Experiences/bloc-notes/DrawData_FR.html +++ b/fr/1-Experiences/bloc-notes/DrawData_FR.html @@ -778,6 +778,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • @@ -2186,14 +2207,10 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U drawdata
-# sudo apt-get install xsel xclip -y
    %%capture -! pip install -r requirements.txt -! pip install -U drawdata -# sudo apt-get install xsel xclip -y
    +! pip install -U drawdata diff --git a/fr/1-Experiences/bloc-notes/DrawData_FR.ipynb b/fr/1-Experiences/bloc-notes/DrawData_FR.ipynb index 7c220de57..983760388 100644 --- a/fr/1-Experiences/bloc-notes/DrawData_FR.ipynb +++ b/fr/1-Experiences/bloc-notes/DrawData_FR.ipynb @@ -31,9 +31,7 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", - "! pip install -U drawdata\n", - "# sudo apt-get install xsel xclip -y" + "! pip install -U drawdata" ] }, { diff --git a/fr/1-Experiences/bloc-notes/MitoSheet_FR.html b/fr/1-Experiences/bloc-notes/MitoSheet_FR.html index 93900bcc8..b4947c962 100644 --- a/fr/1-Experiences/bloc-notes/MitoSheet_FR.html +++ b/fr/1-Experiences/bloc-notes/MitoSheet_FR.html @@ -769,6 +769,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • @@ -2158,13 +2179,11 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U mitosheet
 ! python -m jupyter nbextension install --py --user mitosheet
 ! python -m jupyter nbextension enable --py --user mitosheet
    %%capture -! pip install -r requirements.txt ! pip install -U mitosheet ! python -m jupyter nbextension install --py --user mitosheet ! python -m jupyter nbextension enable --py --user mitosheet
    diff --git a/fr/1-Experiences/bloc-notes/MitoSheet_FR.ipynb b/fr/1-Experiences/bloc-notes/MitoSheet_FR.ipynb index 983b2f92a..9614062bd 100644 --- a/fr/1-Experiences/bloc-notes/MitoSheet_FR.ipynb +++ b/fr/1-Experiences/bloc-notes/MitoSheet_FR.ipynb @@ -29,7 +29,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U mitosheet\n", "! python -m jupyter nbextension install --py --user mitosheet\n", "! python -m jupyter nbextension enable --py --user mitosheet" diff --git a/fr/1-Experiences/bloc-notes/PyGWalker_FR.html b/fr/1-Experiences/bloc-notes/PyGWalker_FR.html index 3f161918f..e9ea0b161 100644 --- a/fr/1-Experiences/bloc-notes/PyGWalker_FR.html +++ b/fr/1-Experiences/bloc-notes/PyGWalker_FR.html @@ -16,7 +16,7 @@ - + @@ -778,6 +778,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • @@ -2181,11 +2202,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U pygwalker ydata-profiling ipywidgets
    %%capture -! pip install -r requirements.txt ! pip install -U pygwalker ydata-profiling ipywidgets
    diff --git a/fr/1-Experiences/bloc-notes/PyGWalker_FR.ipynb b/fr/1-Experiences/bloc-notes/PyGWalker_FR.ipynb index 3bab34e37..07dc26da2 100644 --- a/fr/1-Experiences/bloc-notes/PyGWalker_FR.ipynb +++ b/fr/1-Experiences/bloc-notes/PyGWalker_FR.ipynb @@ -45,7 +45,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U pygwalker ydata-profiling ipywidgets" ] }, diff --git a/fr/1-Experiences/bloc-notes/ReRun_FR.html b/fr/1-Experiences/bloc-notes/ReRun_FR.html new file mode 100644 index 000000000..0e7f726f5 --- /dev/null +++ b/fr/1-Experiences/bloc-notes/ReRun_FR.html @@ -0,0 +1,2839 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + ReRun : Visualisez tout rapidement et efficacement ! - Espace d'analyse avancée + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +     +
    + +
    + + + + + + +
    + + + + + + + +
    + +
    + + + + +
    +
    + + + +
    +
    +
    + + + + + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    +
    + + + +
    +
    + + + + + + + + + + + + + + + + + + +
    + +
    + + + + + + + + + + + + + + + + +
    +
    + + + + + +
    + +
    + + + +
    +
    +
    +
    + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/fr/1-Experiences/bloc-notes/ReRun_FR.ipynb b/fr/1-Experiences/bloc-notes/ReRun_FR.ipynb new file mode 100644 index 000000000..4f2ead9f2 --- /dev/null +++ b/fr/1-Experiences/bloc-notes/ReRun_FR.ipynb @@ -0,0 +1,315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1bd46748-42b9-46ea-9fea-fee20634a793", + "metadata": {}, + "source": [ + "# ReRun : Visualisez tout rapidement et efficacement !\n", + "\n", + "Bienvenue dans le monde de ReRun, votre SDK incontournable pour visualiser des données multimodales qui évoluent dynamiquement avec le temps. Les ingénieurs et chercheurs dans des domaines tels que la vision par ordinateur et la robotique utilisent ReRun pour vérifier, déboguer et présenter leurs projets avec une efficacité inégalée.\n", + "\n", + "![Multimodal Timeseries Data](./img/rerun-multi-1.png)\n", + "\n", + "## Points Forts\n", + "\n", + "- **Modèle Open-Core :** ReRun fonctionne sur un modèle open-core, garantissant que tout dans ce référentiel reste open source et gratuit. À l'avenir, ReRun introduira un produit commercial construit sur la base solide du projet de base gratuit.\n", + "\n", + "- **Adapté aux individus et aux équipes :** Le projet open source répond aux besoins des développeurs individuels, tandis que le futur produit commercial abordera spécifiquement les exigences des équipes impliquées dans la construction et l'exécution de produits de vision par ordinateur et de robotique.\n", + "\n", + "- **Polyvalent et multiplateforme :** ReRun est un SDK et un moteur conçu pour visualiser et interagir avec des flux de données multimodaux. Il est simple à intégrer et à démarrer, utilisable à partir de Python, Rust et C++, et construit en Rust pour une compatibilité multiplateforme et une rapidité optimale.\n", + "\n", + "- **Open Source :** ReRun s'engage envers les principes open source, avec une double licence MIT et Apache 2.\n", + "\n", + "## Installation\n", + "\n", + "Pour libérer la puissance de ReRun, installez-le dans votre environnement JupyterLab avec une commande simple :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d9f41c51-e09f-4a37-b5e6-3ff4766001ea", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%capture\n", + "! pip install -U rerun-sdk" + ] + }, + { + "cell_type": "markdown", + "id": "b421be69-2741-4d5c-a3fa-f60f8d9187aa", + "metadata": { + "tags": [] + }, + "source": [ + "## Commencer\n", + "\n", + "Pour une expérience ReRun optimale, il est recommandé d'utiliser une session de bureau Linux, Mac ou Windows au lieu de JupyterLab. Accédez à la visionneuse ReRun complète en exécutant `rr.spawn()` dans le script suivant à partir de votre émulateur de terminal :\n", + "\n", + "```python\n", + "importer la réexécution en tant que rr\n", + "\n", + "rr.spawn()\n", + "```\n", + "\n", + "Cependant, si JupyterLab est votre environnement préféré, ReRun y fonctionne de manière transparente. Reportez-vous à la [documentation officielle](https://www.rerun.io/docs/howto/notebook) pour plus de détails sur l'exécution de ReRun dans JupyterLab. L'exemple JupyterLab le plus simple consiste à ouvrir ReRun à l'aide des méthodes `memory_recording()` et `show()` :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9918233", + "metadata": {}, + "outputs": [], + "source": [ + "import rerun as rr\n", + "\n", + "rec = rr.memory_recording()\n", + "rec.show(width=1024, height=768)" + ] + }, + { + "cell_type": "markdown", + "id": "b84e8b9d", + "metadata": {}, + "source": [ + "## Visualisation 3D : Le Cube\n", + "\n", + "Découvrez la simplicité de la visualisation 3D avec ReRun en générant et en traçant des points dans l'espace :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7127bbc", + "metadata": {}, + "outputs": [], + "source": [ + "import rerun as rr\n", + "import numpy as np\n", + "\n", + "rec = rr.memory_recording()\n", + "\n", + "SIZE = 10\n", + "\n", + "pos_grid = np.meshgrid(*[np.linspace(-10, 10, SIZE)]*3)\n", + "positions = np.vstack([d.reshape(-1) for d in pos_grid]).T\n", + "\n", + "col_grid = np.meshgrid(*[np.linspace(0, 255, SIZE)]*3)\n", + "colors = np.vstack([c.reshape(-1) for c in col_grid]).astype(np.uint8).T\n", + "\n", + "rr.log(\n", + " \"my_points\",\n", + " rr.Points3D(positions, colors=colors, radii=0.5)\n", + ")\n", + "\n", + "rec.show(width=1024, height=768)" + ] + }, + { + "cell_type": "markdown", + "id": "759d2169", + "metadata": {}, + "source": [ + "## Visualisation 3D avancée : L'ADN\n", + "\n", + "Explorez un exemple fascinant de visualisation synthétique de données 3D en forme de double hélice :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9bd9a87", + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "import argparse\n", + "from math import tau\n", + "\n", + "import numpy as np\n", + "\n", + "import rerun as rr # pip install rerun-sdk\n", + "from rerun.utilities import bounce_lerp, build_color_spiral\n", + "\n", + "rec = rr.memory_recording()\n", + "\n", + "rr.set_time_seconds(\"stable_time\", 0)\n", + "\n", + "NUM_POINTS = 100\n", + "\n", + "# points and colors are both np.array((NUM_POINTS, 3))\n", + "points1, colors1 = build_color_spiral(NUM_POINTS)\n", + "points2, colors2 = build_color_spiral(NUM_POINTS, angular_offset=tau * 0.5)\n", + "rr.log(\"helix/structure/left\", rr.Points3D(points1, colors=colors1, radii=0.08))\n", + "rr.log(\"helix/structure/right\", rr.Points3D(points2, colors=colors2, radii=0.08))\n", + "\n", + "rr.log(\"helix/structure/scaffolding\", rr.LineStrips3D(np.stack((points1, points2), axis=1), colors=[128, 128, 128]))\n", + "\n", + "time_offsets = np.random.rand(NUM_POINTS)\n", + "for i in range(400):\n", + " time = i * 0.01\n", + " rr.set_time_seconds(\"stable_time\", time)\n", + "\n", + " times = np.repeat(time, NUM_POINTS) + time_offsets\n", + " beads = [bounce_lerp(points1[n], points2[n], times[n]) for n in range(NUM_POINTS)]\n", + " colors = [[int(bounce_lerp(80, 230, times[n] * 2))] for n in range(NUM_POINTS)]\n", + " rr.log(\n", + " \"helix/structure/scaffolding/beads\", rr.Points3D(beads, radii=0.06, colors=np.repeat(colors, 3, axis=-1))\n", + " )\n", + "\n", + " rr.log(\n", + " \"helix/structure\",\n", + " rr.Transform3D(rotation=rr.RotationAxisAngle(axis=[0, 0, 1], radians=time / 4.0 * tau)),\n", + " )\n", + "\n", + "rec.show(width=1024, height=768)" + ] + }, + { + "cell_type": "markdown", + "id": "cb0cbca9", + "metadata": {}, + "source": [ + "## Données de séries chronologiques : des tracés qui impressionnent\n", + "\n", + "ReRun brille vraiment lors de la visualisation de données de séries chronologiques multimodales. L'exemple suivant démontre les prouesses de ReRun dans l'affichage de divers tracés correspondant à différentes lectures sur les mêmes données de série chronologique :" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de21e1f2", + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import annotations\n", + "\n", + "import argparse\n", + "import random\n", + "from math import cos, sin, tau\n", + "\n", + "import numpy as np\n", + "import rerun as rr # pip install rerun-sdk\n", + "\n", + "rec = rr.memory_recording()\n", + "\n", + "def clamp(n, smallest, largest): # type: ignore[no-untyped-def]\n", + " return max(smallest, min(n, largest))\n", + "\n", + "\n", + "def log_bar_chart() -> None:\n", + " rr.set_time_sequence(\"frame_nr\", 0)\n", + " # Log a gauss bell as a bar chart\n", + " mean = 0\n", + " std = 1\n", + " variance = np.square(std)\n", + " x = np.arange(-5, 5, 0.1)\n", + " y = np.exp(-np.square(x - mean) / 2 * variance) / (np.sqrt(2 * np.pi * variance))\n", + " rr.log(\"bar_chart\", rr.BarChart(y))\n", + "\n", + "\n", + "def log_parabola() -> None:\n", + " # Log a parabola as a time series\n", + " for t in range(0, 1000, 10):\n", + " rr.set_time_sequence(\"frame_nr\", t)\n", + "\n", + " f_of_t = (t * 0.01 - 5) ** 3 + 1\n", + " radius = clamp(abs(f_of_t) * 0.1, 0.5, 10.0)\n", + " color = [255, 255, 0]\n", + " if f_of_t < -10.0:\n", + " color = [255, 0, 0]\n", + " elif f_of_t > 10.0:\n", + " color = [0, 255, 0]\n", + "\n", + " rr.log(\n", + " \"curves/parabola\",\n", + " rr.TimeSeriesScalar(\n", + " f_of_t,\n", + " label=\"f(t) = (0.01t - 3)³ + 1\",\n", + " radius=radius,\n", + " color=color,\n", + " ),\n", + " )\n", + "\n", + "\n", + "def log_trig() -> None:\n", + " # Log a time series\n", + " for t in range(0, int(tau * 2 * 100.0)):\n", + " rr.set_time_sequence(\"frame_nr\", t)\n", + "\n", + " sin_of_t = sin(float(t) / 100.0)\n", + " rr.log(\"trig/sin\", rr.TimeSeriesScalar(sin_of_t, label=\"sin(0.01t)\", color=[255, 0, 0]))\n", + "\n", + " cos_of_t = cos(float(t) / 100.0)\n", + " rr.log(\"trig/cos\", rr.TimeSeriesScalar(cos_of_t, label=\"cos(0.01t)\", color=[0, 255, 0]))\n", + "\n", + "\n", + "def log_classification() -> None:\n", + " # Log a time series\n", + " for t in range(0, 1000, 2):\n", + " rr.set_time_sequence(\"frame_nr\", t)\n", + "\n", + " f_of_t = (2 * 0.01 * t) + 2\n", + " color = [255, 255, 0]\n", + " rr.log(\"classification/line\", rr.TimeSeriesScalar(f_of_t, color=color, radius=3.0))\n", + "\n", + " g_of_t = f_of_t + random.uniform(-5.0, 5.0)\n", + " if g_of_t < f_of_t - 1.5:\n", + " color = [255, 0, 0]\n", + " elif g_of_t > f_of_t + 1.5:\n", + " color = [0, 255, 0]\n", + " else:\n", + " color = [255, 255, 255]\n", + " radius = abs(g_of_t - f_of_t)\n", + " rr.log(\"classification/samples\", rr.TimeSeriesScalar(g_of_t, color=color, scattered=True, radius=radius))\n", + "\n", + "\n", + "log_bar_chart()\n", + "log_parabola()\n", + "log_trig()\n", + "log_classification()\n", + "\n", + "rec.show(width=1024, height=768)\n" + ] + }, + { + "cell_type": "markdown", + "id": "d9bd7e11", + "metadata": {}, + "source": [ + "## Plongez plus profondément\n", + "\n", + "Pour une compréhension approfondie de ReRun et de ses fonctionnalités, reportez-vous au [démarrage rapide officiel de ReRun Python](https://www.rerun.io/docs/quickstart/python/).\n", + "\n", + "Désormais, armé de ReRun, embarquez pour un voyage de visualisation et d’exploration de données sans précédent. Bon codage !" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/fr/1-Experiences/bloc-notes/SweetViz_FR.html b/fr/1-Experiences/bloc-notes/SweetViz_FR.html index be0912fa4..ef236989e 100644 --- a/fr/1-Experiences/bloc-notes/SweetViz_FR.html +++ b/fr/1-Experiences/bloc-notes/SweetViz_FR.html @@ -13,7 +13,7 @@ - + @@ -700,6 +700,27 @@ + + +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + @@ -2193,11 +2214,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U sweetviz ydata-profiling
    %%capture -! pip install -r requirements.txt ! pip install -U sweetviz ydata-profiling
    diff --git a/fr/1-Experiences/bloc-notes/SweetViz_FR.ipynb b/fr/1-Experiences/bloc-notes/SweetViz_FR.ipynb index 88d2052ff..2aa5df48d 100644 --- a/fr/1-Experiences/bloc-notes/SweetViz_FR.ipynb +++ b/fr/1-Experiences/bloc-notes/SweetViz_FR.ipynb @@ -44,7 +44,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U sweetviz ydata-profiling" ] }, diff --git a/fr/1-Experiences/bloc-notes/VisualPython_FR.html b/fr/1-Experiences/bloc-notes/VisualPython_FR.html index f0305a2b1..382152e1d 100644 --- a/fr/1-Experiences/bloc-notes/VisualPython_FR.html +++ b/fr/1-Experiences/bloc-notes/VisualPython_FR.html @@ -702,6 +702,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • @@ -2253,11 +2274,9 @@

    Installation: 
    %%capture
-! pip install -r requirements.txt
 ! pip install -U jupyterlab-visualpython plotly wordcloud
    %%capture -! pip install -r requirements.txt ! pip install -U jupyterlab-visualpython plotly wordcloud
    diff --git a/fr/1-Experiences/bloc-notes/VisualPython_FR.ipynb b/fr/1-Experiences/bloc-notes/VisualPython_FR.ipynb index ce59e816c..499e0e766 100644 --- a/fr/1-Experiences/bloc-notes/VisualPython_FR.ipynb +++ b/fr/1-Experiences/bloc-notes/VisualPython_FR.ipynb @@ -40,7 +40,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U jupyterlab-visualpython plotly wordcloud" ] }, diff --git a/fr/1-Experiences/bloc-notes/YData-Profiling_FR.html b/fr/1-Experiences/bloc-notes/YData-Profiling_FR.html index a9c83a107..e974f9f42 100644 --- a/fr/1-Experiences/bloc-notes/YData-Profiling_FR.html +++ b/fr/1-Experiences/bloc-notes/YData-Profiling_FR.html @@ -702,6 +702,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • @@ -2223,11 +2244,9 @@

    Démarrage rapide:
    %%capture
-! pip install -r requirements.txt
 ! pip install -U ydata-profiling ipywidgets scikit-learn
    %%capture -! pip install -r requirements.txt ! pip install -U ydata-profiling ipywidgets scikit-learn
    diff --git a/fr/1-Experiences/bloc-notes/YData-Profiling_FR.ipynb b/fr/1-Experiences/bloc-notes/YData-Profiling_FR.ipynb index 2e2b8f589..1c7991747 100644 --- a/fr/1-Experiences/bloc-notes/YData-Profiling_FR.ipynb +++ b/fr/1-Experiences/bloc-notes/YData-Profiling_FR.ipynb @@ -26,7 +26,6 @@ "outputs": [], "source": [ "%%capture\n", - "! pip install -r requirements.txt\n", "! pip install -U ydata-profiling ipywidgets scikit-learn" ] }, diff --git a/fr/1-Experiences/bloc-notes/img/rerun-multi-1.png b/fr/1-Experiences/bloc-notes/img/rerun-multi-1.png new file mode 100644 index 000000000..8fa533b39 Binary files /dev/null and b/fr/1-Experiences/bloc-notes/img/rerun-multi-1.png differ diff --git a/fr/2-Publication/Dash.html b/fr/2-Publication/Dash.html index 6376bdbd6..e1371207d 100644 --- a/fr/2-Publication/Dash.html +++ b/fr/2-Publication/Dash.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/2-Publication/Datasette.html b/fr/2-Publication/Datasette.html index 93d2cbff5..75f7b854e 100644 --- a/fr/2-Publication/Datasette.html +++ b/fr/2-Publication/Datasette.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/2-Publication/Overview.html b/fr/2-Publication/Overview.html index 3a1689abc..5cbbbcfb0 100644 --- a/fr/2-Publication/Overview.html +++ b/fr/2-Publication/Overview.html @@ -692,6 +692,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/2-Publication/PowerBI.html b/fr/2-Publication/PowerBI.html index d4dcc0170..2991c8917 100644 --- a/fr/2-Publication/PowerBI.html +++ b/fr/2-Publication/PowerBI.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/2-Publication/R-Shiny.html b/fr/2-Publication/R-Shiny.html index 22cd21771..b18043eeb 100644 --- a/fr/2-Publication/R-Shiny.html +++ b/fr/2-Publication/R-Shiny.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/2-Publication/Sur-mesure.html b/fr/2-Publication/Sur-mesure.html index d6f9fa1de..29a898627 100644 --- a/fr/2-Publication/Sur-mesure.html +++ b/fr/2-Publication/Sur-mesure.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/3-Pipelines/Argo.html b/fr/3-Pipelines/Argo.html index e7c7a9658..e23d99235 100644 --- a/fr/3-Pipelines/Argo.html +++ b/fr/3-Pipelines/Argo.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git "a/fr/4-Collaboration/Aper\303\247u.html" "b/fr/4-Collaboration/Aper\303\247u.html" index 6d88a8fcf..f73bee010 100644 --- "a/fr/4-Collaboration/Aper\303\247u.html" +++ "b/fr/4-Collaboration/Aper\303\247u.html" @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/4-Collaboration/Demander-EspaceDeNom.html b/fr/4-Collaboration/Demander-EspaceDeNom.html index 74696988f..193d7a74d 100644 --- a/fr/4-Collaboration/Demander-EspaceDeNom.html +++ b/fr/4-Collaboration/Demander-EspaceDeNom.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/4-Collaboration/Environnement-Analyse-Geospatiale.html b/fr/4-Collaboration/Environnement-Analyse-Geospatiale.html index 2668a4a43..62ffc2612 100644 --- a/fr/4-Collaboration/Environnement-Analyse-Geospatiale.html +++ b/fr/4-Collaboration/Environnement-Analyse-Geospatiale.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/404.html b/fr/404.html index 3189aa736..38b04bba9 100644 --- a/fr/404.html +++ b/fr/404.html @@ -685,6 +685,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git "a/fr/5-Stockage/Aper\303\247u.html" "b/fr/5-Stockage/Aper\303\247u.html" index 2fe70ad97..b2db77086 100644 --- "a/fr/5-Stockage/Aper\303\247u.html" +++ "b/fr/5-Stockage/Aper\303\247u.html" @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/5-Stockage/Disque.html b/fr/5-Stockage/Disque.html index ec1ac6cf6..75a636e34 100644 --- a/fr/5-Stockage/Disque.html +++ b/fr/5-Stockage/Disque.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/5-Stockage/StockageBlobAzure.html b/fr/5-Stockage/StockageBlobAzure.html index cdb3db7b6..5b08c5f1b 100644 --- a/fr/5-Stockage/StockageBlobAzure.html +++ b/fr/5-Stockage/StockageBlobAzure.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/6-Gitlab/Gitlab.html b/fr/6-Gitlab/Gitlab.html index 25b4235c0..de83f5d1d 100644 --- a/fr/6-Gitlab/Gitlab.html +++ b/fr/6-Gitlab/Gitlab.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git "a/fr/7-MLOps/Aper\303\247u.html" "b/fr/7-MLOps/Aper\303\247u.html" index a2ce84b33..5594bfa15 100644 --- "a/fr/7-MLOps/Aper\303\247u.html" +++ "b/fr/7-MLOps/Aper\303\247u.html" @@ -693,6 +693,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/7-MLOps/Integration-PaaS.html b/fr/7-MLOps/Integration-PaaS.html index 5630eedb3..2cc4f07d1 100644 --- a/fr/7-MLOps/Integration-PaaS.html +++ b/fr/7-MLOps/Integration-PaaS.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/7-MLOps/Modele-ML-stockage.html b/fr/7-MLOps/Modele-ML-stockage.html index 943ee16a7..fe3f43892 100644 --- a/fr/7-MLOps/Modele-ML-stockage.html +++ b/fr/7-MLOps/Modele-ML-stockage.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/7-MLOps/Modele-Ml-entrainement.html b/fr/7-MLOps/Modele-Ml-entrainement.html index ffe60c93f..03f7fa6d5 100644 --- a/fr/7-MLOps/Modele-Ml-entrainement.html +++ b/fr/7-MLOps/Modele-Ml-entrainement.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/7-MLOps/Modele-Service-ML.html b/fr/7-MLOps/Modele-Service-ML.html index eee0a9b5f..86619d1e5 100644 --- a/fr/7-MLOps/Modele-Service-ML.html +++ b/fr/7-MLOps/Modele-Service-ML.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git "a/fr/7-MLOps/Mod\303\250les-d'apprentissage-automatique.html" "b/fr/7-MLOps/Mod\303\250les-d'apprentissage-automatique.html" index 996b35fff..ef2c61eb3 100644 --- "a/fr/7-MLOps/Mod\303\250les-d'apprentissage-automatique.html" +++ "b/fr/7-MLOps/Mod\303\250les-d'apprentissage-automatique.html" @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/7-MLOps/Serving.html b/fr/7-MLOps/Serving.html index cb2b5144e..c83e597f2 100644 --- a/fr/7-MLOps/Serving.html +++ b/fr/7-MLOps/Serving.html @@ -692,6 +692,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/7-MLOps/sklearn_iris_jsondata.html b/fr/7-MLOps/sklearn_iris_jsondata.html index 673663997..68d6cfc61 100644 --- a/fr/7-MLOps/sklearn_iris_jsondata.html +++ b/fr/7-MLOps/sklearn_iris_jsondata.html @@ -698,6 +698,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/Aide.html b/fr/Aide.html index c1af82fb7..164518d4d 100644 --- a/fr/Aide.html +++ b/fr/Aide.html @@ -696,6 +696,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/Collaboration.html b/fr/Collaboration.html index 834d6ce2a..8dc6e58d6 100644 --- a/fr/Collaboration.html +++ b/fr/Collaboration.html @@ -692,6 +692,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/index.html b/fr/index.html index df7465b01..29d7e82b1 100644 --- a/fr/index.html +++ b/fr/index.html @@ -838,6 +838,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/message-de-bienvenue.html b/fr/message-de-bienvenue.html index 15cb54748..5dd5fc00d 100644 --- a/fr/message-de-bienvenue.html +++ b/fr/message-de-bienvenue.html @@ -692,6 +692,27 @@ +
  • + + + + + ReRun : Visualisez tout rapidement et efficacement ! + + + + +
    • + + + + + + + + + +
  • diff --git a/fr/search/search_index.json b/fr/search/search_index.json index 67193fc83..a4c872490 100644 --- a/fr/search/search_index.json +++ b/fr/search/search_index.json @@ -1 +1 @@ -{"config":{"lang":["fr"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"]},"docs":[{"location":"index.html","title":"Bienvenue dans l'espace de travail d'analyse avanc\u00e9e","text":""},{"location":"index.html#la-documentation-de-lespace-de-travail-danalyse-avancee","title":"La documentation de l'espace de travail d'analyse avanc\u00e9e","text":"

    Bienvenue dans le monde de la science des donn\u00e9es et de l'apprentissage automatique\u00a0!

    Qu'est-ce que l'ETAA?

    Espace de travail d'analyse avanc\u00e9e est une plateforme open source con\u00e7ue pour les data scientists, les intendants des donn\u00e9es, les analystes et les chercheurs familiaris\u00e9s avec les outils open source et le codage. D\u00e9velopp\u00e9 par des data scientists pour des data scientists, ETAA fournit un environnement flexible qui permet aux praticiens avanc\u00e9s de faire leur travail en toute simplicit\u00e9.

    L'ETAA est une solution compl\u00e8te pour la science des donn\u00e9es et l'analyse des donn\u00e9es. Avec l'ETAA, vous pouvez personnaliser les d\u00e9ploiements de serveurs de bloc-notes en fonction de vos besoins sp\u00e9cifiques en science des donn\u00e9es. Nous avons un petit nombre d'images Docker personnalis\u00e9es r\u00e9alis\u00e9es par notre \u00e9quipe.

    Qu'est-ce que Kubeflow\u00a0?

    L'ETAA est bas\u00e9 sur Kubeflow, une solution compl\u00e8te open source pour le d\u00e9ploiement et la gestion de flux de travail ML de bout en bout.

    Que vous d\u00e9butiez ou que vous soyez d\u00e9j\u00e0 \u00e0 fond dans l'analyse des donn\u00e9es, l'espace de travail Advanced Analytics a tout ce dont vous avez besoin pour faire passer votre travail au niveau sup\u00e9rieur. Des outils puissants pour les pipelines de donn\u00e9es au stockage en nuage pour vos ensembles de donn\u00e9es, notre plateforme a tout pour plaire. Besoin de collaborer avec des coll\u00e8gues ou de publier vos r\u00e9sultats ? Aucun probl\u00e8me. Nous offrons des fonctionnalit\u00e9s de collaboration transparentes qui facilitent la collaboration et le partage de votre travail avec d'autres.

    Quelle que soit l'\u00e9tape \u00e0 laquelle vous vous trouvez dans votre parcours en science des donn\u00e9es, l'espace de travail d'analyse avanc\u00e9e dispose des ressources dont vous avez besoin pour r\u00e9ussir.

    "},{"location":"index.html#premiers-pas-avec-letaa","title":"Premiers pas avec l'ETAA","text":""},{"location":"index.html#le-portail-etaa","title":"Le portail ETAA","text":"

    La page d'accueil du portail ETAA est disponible uniquement pour les utilisateurs internes. Cependant, les utilisateurs externes disposant d'un compte cloud auquel le sponsor commercial a accord\u00e9 l'acc\u00e8s peuvent acc\u00e9der \u00e0 la plate-forme via l'URL de la plate-forme d'analyse.

    Page d'accueil du portail ETAA

    • Page d'accueil du portail pour les employ\u00e9s de Statistique Canada
    • Page d'accueil du portail pour les utilisateurs externes
    "},{"location":"index.html#compte-kubeflow","title":"Compte Kubeflow\ud83d\udc49 Cliquez ici pour configurer votre compte Kubeflow! \ud83d\udc48","text":"

    Attention Utilisateurs Externes!

    Les utilisateurs externes \u00e0 Statistique Canada auront besoin d'un compte cloud auquel l'entreprise commanditaire aura acc\u00e8s.

    A l'attention des employ\u00e9s de Statistique Canada!

    Les utilisateurs internes de Statistique Canada peuvent commencer imm\u00e9diatement sans aucune proc\u00e9dure d'inscription suppl\u00e9mentaire, il suffit de se rendre sur https://kubeflow.ETAA.cloud.statcan.ca/.

    Kubeflow est une plate-forme open source puissante et flexible qui permet une exploitation dynamique du calcul dans le cloud, les utilisateurs ayant la possibilit\u00e9 de contr\u00f4ler les ressources de calcul, de m\u00e9moire et de stockage utilis\u00e9es.

    Kubeflow simplifie les t\u00e2ches suivantes\u00a0:

    • Cr\u00e9ation d'environnements personnalisables pour travailler avec des donn\u00e9es avec un provisionnement de ressources contr\u00f4l\u00e9 par l'utilisateur (CPU, GPU, RAM et stockage personnalis\u00e9s).
    • Gestion des serveurs d'ordinateurs portables, y compris Ubuntu Desktop (via noVNC), R Studio, JupyterLab avec Python, R, Julia et SAS pour les employ\u00e9s de Statistique Canada.

    Tableau de bord Kubeflow

    • Kubeflow Dashboard Utilisez ce lien une fois que vous avez votre compte cloud\u00a0!

    La prise en main de l'espace de travail d'analyse avanc\u00e9e (ETAA) est simple et rapide. Tout d'abord, vous voudrez vous connecter \u00e0 Kubeflow pour cr\u00e9er votre premier serveur de bloc-notes ex\u00e9cutant JupyterLab, RStudio ou Ubuntu Desktop. Nous vous encourageons \u00e0 rejoindre notre cha\u00eene Slack pour entrer en contact avec d'autres data scientists et analystes, poser des questions et partager vos exp\u00e9riences avec la plateforme ETAA.

    "},{"location":"index.html#slack","title":"SlackUtilisez votre adresse de courriel @statcan.gc.ca afin que vous soyez automatiquement approuv\u00e9.","text":"
    • Cliquez ici pour vous connecter \u00e0 notre espace de travail d'assistance Slack
    • Utilisez la cha\u00eene G\u00e9n\u00e9ral\u00a0!

    Chez Statistique Canada, nous comprenons que se lancer dans un nouveau projet peut \u00eatre accablant, et vous aurez probablement de nombreuses questions li\u00e9es \u00e0 la plateforme en cours de route. C'est pourquoi nous avons cr\u00e9\u00e9 un canal Slack d\u00e9di\u00e9 pour vous fournir l'assistance dont vous avez besoin. Notre \u00e9quipe d'experts est l\u00e0 pour r\u00e9pondre \u00e0 vos questions, r\u00e9pondre \u00e0 vos pr\u00e9occupations et vous guider \u00e0 chaque \u00e9tape du processus.

    Pour rejoindre notre canal Slack, cliquez simplement sur le lien fourni et suivez les instructions. Vous serez invit\u00e9 \u00e0 cr\u00e9er un compte dans le coin sup\u00e9rieur droit de la page. Si vous avez une adresse de courriel \u00ab\u00a0@statcan.gc.ca\u00a0\u00bb, utilisez-la lors de votre inscription, car cela garantira que vous \u00eates automatiquement approuv\u00e9 et que vous pouvez commencer \u00e0 vous engager imm\u00e9diatement avec notre communaut\u00e9.

    Une fois que vous avez cr\u00e9\u00e9 votre compte, vous aurez acc\u00e8s \u00e0 une multitude de ressources et d'informations, ainsi que la possibilit\u00e9 de vous connecter avec d'autres utilisateurs qui travaillent sur des projets similaires. Notre cha\u00eene Slack est l'endroit id\u00e9al pour poser des questions, partager des id\u00e9es et collaborer avec vos pairs en temps r\u00e9el. Que vous commenciez tout juste \u00e0 d\u00e9marrer un nouveau projet ou que vous recherchiez des conseils d'experts sur un probl\u00e8me complexe, notre \u00e9quipe est l\u00e0 pour vous aider.

    Alors n'h\u00e9sitez pas\u00a0: rejoignez notre canal Slack d\u00e8s aujourd'hui et commencez \u00e0 obtenir les r\u00e9ponses dont vous avez besoin pour r\u00e9ussir. Nous sommes impatients de vous accueillir dans notre communaut\u00e9\u00a0!

    Cliquez sur le lien, puis choisissez \"Cr\u00e9er un compte\" dans le coin sup\u00e9rieur droit.

    "},{"location":"index.html#mise-en-route","title":"\ud83e\udded Mise en route","text":"

    Pour acc\u00e9der aux services ETAA, vous devez vous connecter \u00e0 Kubeflow avec votre compte cloud invit\u00e9 de Statistique Canada. Une fois connect\u00e9, s\u00e9lectionnez Serveurs de bloc-notes et cliquez sur le bouton \"Nouveau serveur\" pour commencer.

    1. Connectez-vous \u00e0 Kubeflow avec votre compte cloud invit\u00e9 de Statistique Canada. Vous serez invit\u00e9 \u00e0 authentifier le compte.
    2. S\u00e9lectionnez Serveurs de bloc-notes.
    3. Cliquez sur le bouton \"\u2795 Nouveau serveur\".
    "},{"location":"index.html#outils-offerts","title":"\ud83e\uddf0 Outils Offerts","text":"

    ETAA est une plate-forme flexible pour l'analyse de donn\u00e9es et l'apprentissage automatique. Il propose une gamme de langages, notamment Python, R et Julia. ETAA prend \u00e9galement en charge les environnements de d\u00e9veloppement tels que VS Code, R Studio et bloc-notesJupyter. De plus, des bureaux virtuels Linux sont disponibles pour les utilisateurs qui ont besoin d'outils suppl\u00e9mentaires tels que OpenM++ et QGIS.

    Voici une liste d'outils que nous proposons\u00a0:

    • \ud83d\udcdc Languages :
      • \ud83d\udc0d Python
      • \ud83d\udcc8 R
      • \ud83d\udc69\u200d\ud83d\udd2c Julia
    • \ud83e\uddee Environnements de d\u00e9veloppement :
      • Code VS
      • Studio R
      • Cahiers Jupyter
    • \ud83d\udc27 Bureaux virtuels Linux pour des outils suppl\u00e9mentaires (\ud83e\uddeb OpenM++, \ud83c\udf0f QGIS etc.)

    Le partage de code, de disques et d'espaces de travail (ex : deux personnes partageant la m\u00eame machine virtuelle) est d\u00e9crit plus en d\u00e9tail dans la section Collaboration. Le partage de donn\u00e9es via des buckets est d\u00e9crit plus en d\u00e9tail dans Azure Blob Storage section.

    "},{"location":"index.html#aide","title":"\ud83d\udca1 Aide","text":"
    • Disque (\u00e9galement appel\u00e9 Volumes sur l'\u00e9cran de cr\u00e9ation de serveur bloc-notes)
    • Conteneurs (Stockage Blob)
    • Lacs de donn\u00e9es (\u00e0 venir)
    • \ud83d\udcd7 Documentation du portail ETAA
      • https://statcan.github.io/aaw/
    • \ud83d\udcd8 Documentation Kubeflow
      • https://www.kubeflow.org/docs/
    • \ud83e\udd1d Canal d'assistance Slack
      • https://statcan-etaa.slack.com
    "},{"location":"index.html#demos","title":"\ud83d\udc31 D\u00e9mos","text":"

    Si vous avez besoin d'une session de d\u00e9monstration d'int\u00e9gration rapide, avez besoin d'aide ou avez des questions, veuillez nous contacter via notre \ud83e\udd1d Canal d'assistance Slack.

    "},{"location":"index.html#contribuant","title":"Contribuant","text":"

    Si vous avez des bogues \u00e0 signaler ou des fonctionnalit\u00e9s \u00e0 demander, veuillez le faire via https://github.com/Statcan/daaas.

    "},{"location":"Aide.html","title":"Vous avez des questions ou des commentaires?","text":"

    Joignez-vous \u00e0 nous sur le canal Slack de l'espace de travail en analytique avanc\u00e9e! Vous trouverez de nombreux utilisateurs de la plateforme qui pourront peut-\u00eatre r\u00e9pondre \u00e0 vos questions. Quelques ing\u00e9nieurs sont aussi habituellement pr\u00e9sents. Vous pouvez poser des questions et soumettre vos commentaires, dans la langue de votre choix.

    • Slack (fr)

    Nous publierons \u00e9galement des avis de mise \u00e0 jour et d'interruption sur le canal Slack.

    "},{"location":"Aide.html#github","title":"GitHub","text":"

    Vous voulez en savoir plus \u00e0 propos de notre plateforme? Trouvez tous les d\u00e9tailles sur notre page GitHub!

    • Page GitHub de l'Espace d'analyse avanc\u00e9e
    "},{"location":"Collaboration.html","title":"Collaboration en mati\u00e8re d'espace de travail en analytique avanc\u00e9e","text":"

    Il existe de nombreuses fa\u00e7ons de collaborer sur la plateforme, et ce qui vous convient le mieux d\u00e9pend des \u00e9l\u00e9ments que vous partagez et du nombre de personnes avec qui vous souhaitez partager des \u00e9l\u00e9ments. Nous pouvons r\u00e9partir les \u00e9l\u00e9ments partageables en donn\u00e9es et en code. Nous pouvons aussi r\u00e9partir l'ensemble des groupes avec lesquels vous partagez des \u00e9l\u00e9ments en priv\u00e9, \u00e9quipe et StatCan. Cela conduit au tableau d'options suivant :

    Priv\u00e9 \u00c9quipe StatCan Code GitLab/GitHub ou dossier personnel GitLab/GitHub ou dossier d'\u00e9quipe GitLab/GitHub Donn\u00e9es Dossier ou compartiment personnel Dossier ou compartiment d'\u00e9quipe Compartiment partag\u00e9 Quelle est la diff\u00e9rence entre un compartiment et un dossier?

    Les compartiments s'apparentent au stockage r\u00e9seau. Voir la section sur le stockage pour obtenir des pr\u00e9cisions suppl\u00e9mentaires sur les diff\u00e9rences entre ces deux concepts.

    Les acc\u00e8s priv\u00e9 et \u00e9quipe sont configur\u00e9s au moyen des espaces de nommage. Nous commen\u00e7ons donc par parler de Kubeflow et des espaces de nommage Kubeflow.

    Ensuite, les donn\u00e9es et le code sont mieux pris en charge au moyen d'outils l\u00e9g\u00e8rement diff\u00e9rents. C'est pourquoi nous allons les aborder en deux temps. Pour les donn\u00e9es, nous parlons de compartiments et MinIO. Pour le code, nous parlons de Git, GitLab et GitHub.

    C'est sur quoi repose la structure de cette page :

    \u2013 Collaboration en \u00e9quipe (applicable au code et aux donn\u00e9es) \u2013 Partage du code \u2013 Partage des donn\u00e9es

    "},{"location":"Collaboration.html#collaboration-en-equipe","title":"Collaboration en \u00e9quipe","text":""},{"location":"Collaboration.html#que-fait-kubeflow","title":"Que fait Kubeflow?","text":"

    Kubeflow ex\u00e9cute vos espaces de travail. Vous pouvez avoir des serveurs de blocs-notes (appel\u00e9s serveurs Jupyter) et vous pouvez y cr\u00e9er des analyses en R et en Python en utilisant des \u00e9l\u00e9ments visuels interactifs. Vous pouvez enregistrer, t\u00e9l\u00e9verser et t\u00e9l\u00e9charger des donn\u00e9es. Votre \u00e9quipe peut travailler \u00e0 vos c\u00f4t\u00e9s.

    "},{"location":"Collaboration.html#demande-dun-espace-de-nommage","title":"Demande d'un espace de nommage","text":"

    Par d\u00e9faut, chaque personne obtient son propre espace de nommage, pr\u00e9nom-nom. Si vous souhaitez cr\u00e9er un espace de nommage pour une \u00e9quipe, pr\u00e9sentez la demande dans le portail : Cliquez sur le \u22ee de la section Kubeflow du portail.

    L'espace de nommage ne doit comprendre aucun caract\u00e8re sp\u00e9cial autre que le trait d'union.

    Le nom doit seulement comprendre des lettres minuscules (de \u00ab a \u00bb \u00e0 \u00ab z \u00bb) et des traits d'union. Sinon, il sera impossible de cr\u00e9er l'espace de nommage.

    Vous recevrez un avis par courriel vous indiquant que l'espace de nommage est cr\u00e9\u00e9. Une fois que l'espace de nommage partag\u00e9 est cr\u00e9\u00e9, vous pouvez y acc\u00e9der comme tous les autres espaces de nommage dont vous disposez par l'entremise de l'interface utilisateur Kubeflow, comme il est indiqu\u00e9 ci-apr\u00e8s. Vous pourrez ensuite g\u00e9rer la liste des collaborateurs sous l'onglet de gestion des contributeurs de Kubeflow, o\u00f9 vous pourrez ajouter vos coll\u00e8gues \u00e0 l'espace de nommage partag\u00e9.

    Pour changer d'espace de nommage, allez en haut de votre fen\u00eatre, juste \u00e0 droite du logo de Kubeflow.

    "},{"location":"Collaboration.html#code-partage","title":"Code partag\u00e9","text":"

    Les \u00e9quipes ont deux options (mais vous pouvez combiner les deux) :

    "},{"location":"Collaboration.html#partager-un-espace-de-travail-dans-kubeflow","title":"Partager un espace de travail dans Kubeflow","text":"

    Le partage dans Kubeflow pr\u00e9sente l'avantage suivant : il est \u00e0 structure libre et il fonctionne mieux pour les fichiers .ipynb (blocs-notes Jupyter). Cette m\u00e9thode vous permet \u00e9galement de partager un environnement de calcul, de sorte que vous pouvez partager des ressources tr\u00e8s facilement. Lorsque vous partagez un espace de travail, vous partagez :

    \u2013 un compartiment priv\u00e9 et partag\u00e9 (/team-name et /shared/team-name); \u2013 tous les serveurs de blocs-notes dans l'espace de nommage Kubeflow.

    "},{"location":"Collaboration.html#partager-avec-git-au-moyen-de-gitlab-ou-de-github","title":"Partager avec Git, au moyen de GitLab ou de GitHub","text":"

    Le partage au moyen de Git pr\u00e9sente l'avantage suivant : il permet de travailler avec des utilisateurs de tous les espaces de nommage. De plus, le fait de conserver le code dans Git est un excellent moyen de g\u00e9rer les grands projets de logiciels.

    N'oubliez pas d'obtenir une licence d'utilisation!

    Si votre code est public, suivez les directives de l'\u00e9quipe de l'innovation et utilisez une licence appropri\u00e9e si vous r\u00e9alisez des t\u00e2ches pour le compte de Statistique Canada.

    "},{"location":"Collaboration.html#recommandation-combinez-les-deux","title":"Recommandation : combinez les deux.","text":"

    Il est sage de toujours utiliser Git. L'utilisation de Git de concert avec des espaces de travail partag\u00e9s est un bon moyen de combiner le partage ponctuel (par l'entremise de fichiers) tout en assurant l'organisation et le suivi de votre code.

    "},{"location":"Collaboration.html#stockage-partage","title":"Stockage partag\u00e9","text":""},{"location":"Collaboration.html#partage-avec-votre-equipe","title":"Partage avec votre \u00e9quipe","text":"

    Une fois que vous avez un espace de nommage partag\u00e9, deux m\u00e9thodes de stockage partag\u00e9 s'offrent \u00e0 vous :

    Option de stockage Avantages Serveurs/espaces de travail Jupyter partag\u00e9s Mieux adapt\u00e9s aux petits fichiers, aux blocs-notes et aux petites exp\u00e9riences. Compartiments partag\u00e9s (voir Stockage) Mieux adapt\u00e9s \u00e0 une utilisation dans les pipelines et les interfaces API et aux fichiers volumineux.

    Pour en savoir plus sur la technologie sous-jacente, consultez la section sur le stockage.

    "},{"location":"Collaboration.html#partage-avec-statcan","title":"Partage avec StatCan","text":"

    En plus des compartiments priv\u00e9s et des compartiments priv\u00e9s partag\u00e9s en \u00e9quipe, vous pouvez \u00e9galement placer vos fichiers dans un espace de stockage partag\u00e9. Toutes les options de stockage en compartiments (minimal, sup\u00e9rieur, \u00e9l\u00e9phantesque) offrent un compartiment priv\u00e9 et un dossier \u00e0 l'int\u00e9rieur du compartiment partag\u00e9. Par exemple, consultez le lien ci-dessous :

    • shared/blair-drummond/

    Tous les utilisateurs connect\u00e9s peuvent visualiser et consulter ces fichiers librement.

    "},{"location":"Collaboration.html#partage-avec-le-monde","title":"Partage avec le monde","text":"

    Renseignez-vous \u00e0 ce sujet sur notre canal Slack. Il existe de nombreuses m\u00e9thodes de partage avec le monde du point de vue informatique. Cependant, comme il est important de respecter les processus appropri\u00e9s, on n'utilise pas le libre-service, comme dans les autres cas. Cela dit, c'est possible.

    "},{"location":"message-de-bienvenue.html","title":"Message de bienvenue","text":""},{"location":"message-de-bienvenue.html#bienvenue-a-lespace-danalyse-avance-eaa","title":"\ud83e\uddd9\ud83d\udd2e Bienvenue \u00e0 l\u2019Espace d'analyse avanc\u00e9 (EAA)","text":"

    Veuillez trouver ci-dessous des informations, des vid\u00e9os et des liens suppl\u00e9mentaires pour mieux comprendre comment d\u00e9marrer avec l\u2019Espace d'analyse avanc\u00e9 (EAA).

    L\u2019Espace d'analyse avanc\u00e9 (EAA) est notre plateforme open source pour la science des donn\u00e9es et l'apprentissage automatique (ML) destin\u00e9e aux praticiens avanc\u00e9s, qui peuvent ainsi accomplir leur travail dans un environnement sans restriction, con\u00e7u par des scientifiques des donn\u00e9es pour des scientifiques des donn\u00e9es. Avec EAA, vous pouvez personnaliser vos d\u00e9ploiements d'ordinateurs portables pour r\u00e9pondre \u00e0 vos besoins en mati\u00e8re de science des donn\u00e9es. Nous disposons \u00e9galement d'un petit nombre d'images r\u00e9alis\u00e9es par notre \u00e9quipe experte en science des donn\u00e9es.

    EAA est bas\u00e9 sur le projet Kubeflow qui est une solution compl\u00e8te open source pour le d\u00e9ploiement et la gestion de flux de travail ML de bout en bout. Kubeflow est con\u00e7u pour rendre les d\u00e9ploiements de flux de travail ML sur Kubernetes simples, portables et \u00e9volutifs.

    \ud83d\udd14 Important! Les utilisateurs externes \u00e0 Statistique Canada devront disposer d'un compte cloud dont l'acc\u00e8s est accord\u00e9 par le commanditaire de l'entreprise.

    \ud83d\udd14 Important! Les utilisateurs internes \u00e0 Statistique Canada peuvent commencer tout de suite sans proc\u00e9dure d'inscription suppl\u00e9mentaire, il suffit de se rendre \u00e0 l'adresse https://kubeflow.aaw.cloud.statcan.ca/.

    "},{"location":"message-de-bienvenue.html#liens-utiles","title":"\ud83d\udd17 Liens utiles","text":""},{"location":"message-de-bienvenue.html#services-eaa","title":"\ud83d\udece\ufe0f Services EAA","text":"
    • \ud83c\udf00 Page d'accueil du portail EEA
      • Interne seulement https://www.statcan.gc.ca/services-analyse-donnees/etaa
      • Interne/externe https://www.statcan.gc.ca/services-analyse-donnees/etaa
    • \ud83e\udd16 Tableau de bord Kubeflow
      • https://kubeflow.aaw.cloud.statcan.ca/
    "},{"location":"message-de-bienvenue.html#aide","title":"\ud83d\udca1 Aide","text":"
    • \ud83d\udcd7 Documentation du portail EAA
      • https://statcan.github.io/aaw/
    • \ud83d\udcd8 Documentation sur Kubeflow
      • https://www.kubeflow.org/docs/
    • \ud83e\udd1d Canal de support Slack
      • https://statcan-aaw.slack.com
    "},{"location":"message-de-bienvenue.html#mise-en-route","title":"\ud83e\udded Mise en route","text":"

    Afin d'acc\u00e9der aux services de l'EAA, vous devrez:

    1. Vous connecter \u00e0 Kubeflow avec votre compte cloud invit\u00e9 StatCan. Vous serez invit\u00e9 \u00e0 authentifier le compte.
    2. S\u00e9lectionnez Serveurs de bloc-notes.
    3. Cliquez sur le bouton \" \u2795 Nouveau serveur \".
    "},{"location":"message-de-bienvenue.html#outils-offerts","title":"\ud83e\uddf0 Outils offerts","text":"

    AAW est une plateforme flexible pour l'analyse de donn\u00e9es et l'apprentissage automatique, avec:

    • \ud83d\udcdc Langues
      • \ud83d\udc0d Python
      • \ud83d\udcc8 R
      • \ud83d\udc69\ud83d\udd2c Julia
      • SAS (Prochainement!)
    • \ud83e\uddee Environnements de d\u00e9veloppement
      • VS Code
      • R Studio
      • Jupyter Notebooks
    • \ud83d\udc27 Bureaux virtuels Linux pour des outils suppl\u00e9mentaires (\ud83e\uddeb OpenM++, \ud83c\udf0f QGIS, etc.)
    "},{"location":"message-de-bienvenue.html#demonstrations","title":"\ud83d\udc31 D\u00e9monstrations","text":"

    Si vous souhaitez une session d'embarquement/d\u00e9mo rapide ou si vous avez besoin d'aide ou avez des questions, n'h\u00e9sitez pas \u00e0 nous contacter via notre canal de support \ud83e\udd1d Slack.

    "},{"location":"message-de-bienvenue.html#faq","title":"FAQ","text":"
    • \ud83d\udea7 Bient\u00f4t disponible !

    Merci !

    "},{"location":"1-Experiences/Apercu.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Apercu.html#experimentation-de-la-science-des-donnees","title":"Exp\u00e9rimentation de la science des donn\u00e9es","text":"

    Traitez les donn\u00e9es \u00e0 l'aide de R, Python ou Julia avec Kubeflow, une plateforme d'apprentissage automatique qui fournit une infrastructure simple, unifi\u00e9e et \u00e9volutive pour les charges de travail d'apprentissage automatique.

    Avec Kubeflow, vous pouvez traiter les donn\u00e9es de mani\u00e8re \u00e9volutive et efficace en utilisant le langage de programmation de votre choix. Une fois Kubeflow configur\u00e9, utilisez bloc-notes Jupyter pour cr\u00e9er et partager des documents contenant du code en direct, des \u00e9quations ou des visualisations.

    Vous pouvez \u00e9galement ex\u00e9cuter Ubuntu en tant que bureau virtuel avec Kubeflow, vous donnant acc\u00e8s \u00e0 un environnement de d\u00e9veloppement puissant qui peut \u00eatre personnalis\u00e9 selon vos besoins. Avec R Shiny, un cadre d'application Web pour R, vous pouvez facilement cr\u00e9er et publier des tableaux de bord statiques et interactifs pour communiquer les r\u00e9sultats de votre analyse aux parties prenantes.

    Kubeflow fournit \u00e9galement une int\u00e9gration avec des plates-formes externes en tant que service, telles que Google Cloud Platform (GCP) et Amazon Web Services (AWS), vous permettant de d\u00e9placer facilement des donn\u00e9es et des charges de travail entre diff\u00e9rents services cloud. De plus, gr\u00e2ce aux fonctionnalit\u00e9s de collaboration de Kubeflow, vous pouvez travailler sur vos projets avec votre \u00e9quipe en temps r\u00e9el, en partageant votre analyse, votre code et vos r\u00e9sultats de mani\u00e8re transparente.

    L'exp\u00e9rimentation en science des donn\u00e9es fait r\u00e9f\u00e9rence au processus de conception, de r\u00e9alisation et d'analyse d'exp\u00e9riences afin de tester des hypoth\u00e8ses et d'obtenir des informations \u00e0 partir des donn\u00e9es. Ce processus implique g\u00e9n\u00e9ralement plusieurs \u00e9tapes\u00a0:

    1. Formuler une hypoth\u00e8se : Avant de mener une exp\u00e9rience, il est important d\u2019avoir une id\u00e9e claire de ce que vous essayez de tester ou d\u2019apprendre. Cela peut impliquer de formuler une hypoth\u00e8se sur une relation entre des variables ou d\u2019essayer de r\u00e9pondre \u00e0 une question de recherche sp\u00e9cifique.

    2. Conception de l'exp\u00e9rience : Une fois que vous avez une hypoth\u00e8se, vous devez concevoir une exp\u00e9rience qui vous permettra de la tester. Cela peut impliquer de s\u00e9lectionner un \u00e9chantillon de donn\u00e9es, de choisir les variables \u00e0 manipuler ou \u00e0 mesurer et de d\u00e9cider des conditions exp\u00e9rimentales.

    3. Collecte et nettoyage des donn\u00e9es : Une fois l'exp\u00e9rience con\u00e7ue, vous devez collecter les donn\u00e9es n\u00e9cessaires pour tester votre hypoth\u00e8se. Cela peut impliquer de collecter des donn\u00e9es \u00e0 partir de sources existantes ou de mener vos propres exp\u00e9riences. Une fois les donn\u00e9es collect\u00e9es, vous devez les nettoyer pour supprimer toute erreur ou anomalie.

    4. Analyser les donn\u00e9es : Une fois les donn\u00e9es propres, vous pouvez commencer \u00e0 les analyser pour tester votre hypoth\u00e8se. Cela peut impliquer l'ex\u00e9cution de tests statistiques ou d'algorithmes d'apprentissage automatique, la visualisation des donn\u00e9es pour identifier des mod\u00e8les ou des tendances, ou l'utilisation d'autres techniques analytiques pour obtenir des informations.

    5. Tirer des conclusions\u00a0: sur la base des r\u00e9sultats de votre analyse, vous pouvez tirer des conclusions quant \u00e0 savoir si votre hypoth\u00e8se est support\u00e9e ou non. Vous pourrez peut-\u00eatre \u00e9galement identifier des domaines n\u00e9cessitant des recherches ou des exp\u00e9rimentations plus approfondies.

    L'analyse des donn\u00e9es est un \u00e9l\u00e9ment cl\u00e9 de l'exp\u00e9rimentation en science des donn\u00e9es et implique l'utilisation de diverses techniques et outils pour donner un sens \u00e0 de grandes quantit\u00e9s de donn\u00e9es. Cela peut impliquer une analyse exploratoire des donn\u00e9es, dans laquelle vous utilisez des visualisations et des statistiques r\u00e9capitulatives pour acqu\u00e9rir une premi\u00e8re compr\u00e9hension des donn\u00e9es, ou des techniques plus avanc\u00e9es telles que l'apprentissage automatique ou la mod\u00e9lisation statistique. L'analyse des donn\u00e9es peut \u00eatre utilis\u00e9e pour r\u00e9pondre \u00e0 un large \u00e9ventail de questions, depuis de simples questions descriptives sur les donn\u00e9es jusqu'\u00e0 des questions pr\u00e9dictives ou prescriptives plus complexes.

    En r\u00e9sum\u00e9, l\u2019exp\u00e9rimentation et l\u2019analyse des donn\u00e9es sont des \u00e9l\u00e9ments importants du domaine plus large de la science des donn\u00e9es et impliquent l\u2019utilisation de donn\u00e9es pour tester des hypoth\u00e8ses, obtenir des informations et prendre des d\u00e9cisions \u00e9clair\u00e9es.

    "},{"location":"1-Experiences/Bureau-virtuel.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Bureau-virtuel.html#bureau-virtuel-ubuntu","title":"Bureau virtuel Ubuntu","text":"

    Vous pouvez ex\u00e9cuter un Bureau Ubuntu complet, avec des applications typiques, directement dans votre navigateur, en utilisant Kubeflow!

    Le bureau virtuel Ubuntu est un outil puissant pour les scientifiques de donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique qui doivent ex\u00e9cuter des charges de travail gourmandes en ressources dans le nuage informatique. Ubuntu est une distribution Linux populaire largement utilis\u00e9e dans les communaut\u00e9s de science des donn\u00e9es et d'apprentissage automatique en raison de sa forte prise en charge des outils de logiciels libres tels que R et Python. Avec Ubuntu Virtual Desktop, vous pouvez rapidement d\u00e9marrer une machine virtuelle avec Ubuntu pr\u00e9install\u00e9 et y acc\u00e9der depuis n'importe o\u00f9 avec une connexion Internet. Cela signifie que vous pouvez effectuer des t\u00e2ches d'analyse de donn\u00e9es et d'apprentissage automatique depuis votre ordinateur portable, votre tablette ou votre t\u00e9l\u00e9phone sans avoir \u00e0 vous soucier des limitations mat\u00e9rielles.

    "},{"location":"1-Experiences/Bureau-virtuel.html#quest-ce-que-le-bureau-a-distance","title":"Qu'est-ce que le Bureau \u00e0 distance\u00a0?","text":"

    Le bureau \u00e0 distance\u00a0offre une exp\u00e9rience de bureau Ubuntu avec interface graphique dans le navigateur ainsi que l'acc\u00e8s rapide aux outils de support. Le syst\u00e8me d'exploitation est Ubuntu 22.04 avec le XFCE pour environnement de bureau.

    "},{"location":"1-Experiences/Bureau-virtuel.html#geomatique","title":"G\u00e9omatique","text":"

    Notre version de bureau \u00e0 distance est construite sur une image R Geospatiale.

    "},{"location":"1-Experiences/Bureau-virtuel.html#personnalisation","title":"Personnalisation","text":"

    pip, conda, npm et yarn sont disponibles pour installer divers paquets.

    "},{"location":"1-Experiences/Bureau-virtuel.html#installation","title":"Installation","text":""},{"location":"1-Experiences/Bureau-virtuel.html#acceder-au-bureau-a-distance","title":"Acc\u00e9der au bureau \u00e0 distance","text":"

    Pour lancer le Bureau \u00e0 distance ou l'un de ses outils de support, cr\u00e9ez un serveur bloc-notes dans Kubeflow et s\u00e9lectionnez l'option de bureau \u00e0 distance, qui est l'image Ubuntu.

    Une fois cr\u00e9\u00e9, cliquez sur \u00ab\u00a0Connecter\u00a0\u00bb pour \u00eatre redirig\u00e9 vers le serveur de bureau \u00e0 distance

    Remote Desktop vous am\u00e8ne \u00e0 l'interface graphique du bureau via une session noVNC. Cliquer sur le > sur le c\u00f4t\u00e9 gauche de l'\u00e9cran pour d\u00e9velopper un panneau avec des options telles que le plein \u00e9cran et presse-papiers.

    "},{"location":"1-Experiences/Bureau-virtuel.html#acceder-au-presse-papiers","title":"Acc\u00e9der au Presse-papiers","text":"

    Cela se fait via le deuxi\u00e8me bouton en partant du haut du panneau \u00e0 gauche. Il fait appara\u00eetre une zone de texte que nous pouvons modifier pour changer le contenu du presse-papiers ou copiez des \u00e9l\u00e9ments du presse-papiers du bureau distant.

    Par exemple, supposons que nous souhaitions ex\u00e9cuter la commande head -c 20 /dev/urandom | somme md5 et copiez-collez le r\u00e9sultat dans un fichier texte sur notre ordinateur utilis\u00e9 pour se connecter au bureau \u00e0 distance.

    Nous ouvrons d\u2019abord le presse-papiers \u00e0 partir du panneau de gauche et collons cette commande dans la zone de texte :

    Pour fermer la fen\u00eatre du presse-papiers sur le bureau distant, cliquez simplement sur le bouton presse-papiers \u00e0 nouveau.

    Nous faisons ensuite un clic droit sur une fen\u00eatre de terminal pour coller cette commande et appuyons sur Entr\u00e9e pour ex\u00e9cuter la commande. \u00c0 ce stade, nous s\u00e9lectionnons le r\u00e9sultat MD5, faisons un clic droit et cliquons copie:

    Si nous ouvrons \u00e0 nouveau le presse-papiers depuis le panneau de gauche, il aura d\u00e9sormais le nouveau contenu:

    La fen\u00eatre du presse-papiers sera m\u00eame mise \u00e0 jour sur place si nous la laissons ouverte tout le temps et nous s\u00e9lectionnons simplement le nouveau mat\u00e9riel sur le bureau distant et appuyons \u00e0 nouveau sur copier. Nous pouvons simplement copiez ce que nous avons dans cette zone de texte et collez-le dans n'importe quel autre logiciel en cours d'ex\u00e9cution sur l'ordinateur utilis\u00e9 pour se connecter.

    "},{"location":"1-Experiences/Bureau-virtuel.html#outils-dans-le-navigateur","title":"Outils dans le navigateur","text":""},{"location":"1-Experiences/Bureau-virtuel.html#vscode","title":"VSCode","text":"

    Visual Studio Code est un \u00e9diteur de code source l\u00e9ger mais puissant. Il inclut la prise en charge int\u00e9gr\u00e9e de JavaScript, TypeScript et Node.js et dispose d'un riche \u00e9cosyst\u00e8me d'extensions pour plusieurs langages (tels que C++, C#, Java, Python,PHP, Go).

    "},{"location":"1-Experiences/Bureau-virtuel.html#notes-de-bas-de-page","title":"Notes de bas de page","text":"

    Le Bureau \u00e0 distance est bas\u00e9 sur ml-tooling/ml-workspace.

    "},{"location":"1-Experiences/Environnements-virtuels.html","title":"Environnements virtuels","text":"

    Lorsque vous effectuez des exp\u00e9riences de science des donn\u00e9es, il est recommand\u00e9 d'utiliser des environnements virtuels Python et/ou conda pour g\u00e9rer les d\u00e9pendances de votre projet. Il est courant de cr\u00e9er un environnement d\u00e9di\u00e9 pour chaque projet ou, dans certains cas, des environnements distincts pour diff\u00e9rentes fonctionnalit\u00e9s ou aspects de votre travail (par exemple, un environnement pour les projets g\u00e9n\u00e9raux et un environnement suppl\u00e9mentaire adapt\u00e9 aux t\u00e2ches d'apprentissage en profondeur acc\u00e9l\u00e9r\u00e9es par GPU).

    Si vous basculez fr\u00e9quemment entre les environnements et souhaitez un moyen plus pratique d'y acc\u00e9der dans JupyterLab, vous pouvez suivre ces instructions\u00a0:

    "},{"location":"1-Experiences/Environnements-virtuels.html#creation-et-ajout-denvironnements-au-lanceur-jupyterlab","title":"Cr\u00e9ation et ajout d'environnements au lanceur JupyterLab","text":""},{"location":"1-Experiences/Environnements-virtuels.html#etape-1-creer-lenvironnement","title":"\u00c9tape\u00a01\u00a0:\u00a0Cr\u00e9er l'environnement","text":"

    Ouvrez une session de terminal et ex\u00e9cutez le code suivant pour cr\u00e9er un nouvel environnement virtuel. Vous pouvez utiliser conda ou python venv en fonction de vos pr\u00e9f\u00e9rences et des exigences du projet. Chacun a ses propres avantages :

    "},{"location":"1-Experiences/Environnements-virtuels.html#utilisation-de-conda","title":"Utilisation de conda\u00a0:","text":"
    conda create -n torch\n
    "},{"location":"1-Experiences/Environnements-virtuels.html#avantages-de-conda","title":"Avantages de conda\u00a0:","text":"
    • G\u00e8re \u00e0 la fois les packages et les environnements Python.
    • Simplifie la gestion des packages, y compris les biblioth\u00e8ques et d\u00e9pendances non Python.
    "},{"location":"1-Experiences/Environnements-virtuels.html#utilisation-de-venv","title":"Utilisation de venv\u00a0:","text":"
    python -m torch venv\n
    "},{"location":"1-Experiences/Environnements-virtuels.html#avantages-de-venv","title":"Avantages de venv\u00a0:","text":"
    • Fait partie de la biblioth\u00e8que standard Python (aucune installation s\u00e9par\u00e9e requise).
    • Fournit un environnement virtuel l\u00e9ger et centr\u00e9 sur Python.
    "},{"location":"1-Experiences/Environnements-virtuels.html#etape-2-ajouter-lenvironnement-au-lanceur","title":"\u00c9tape 2\u00a0: Ajouter l'environnement au lanceur","text":"

    Apr\u00e8s avoir cr\u00e9\u00e9 l'environnement, ajoutez-le au lanceur JupyterLab avec la commande suivante\u00a0:

    python -m ipykernel install --user --name \"torch\" --display-name \"PyTorch\"\n
    • --name \"torch\" sp\u00e9cifie le nom du noyau (remplacez \"torch\" si n\u00e9cessaire).
    • --display-name \"PyTorch\" d\u00e9finit le nom d'affichage du noyau dans le lanceur JupyterLab (personnalisez si n\u00e9cessaire).
    "},{"location":"1-Experiences/Environnements-virtuels.html#etape-3-actualiser-jupyterlab","title":"\u00c9tape 3\u00a0: Actualiser JupyterLab","text":"

    Pour voir les modifications dans le lanceur JupyterLab, actualisez votre navigateur en cliquant sur le bouton d'actualisation ou en utilisant le raccourci clavier F5.

    Ces \u00e9tapes vous permettent de g\u00e9rer de mani\u00e8re transparente vos environnements Python et d'y acc\u00e9der facilement depuis le lanceur JupyterLab, favorisant ainsi un flux de travail plus organis\u00e9 et plus efficace pour vos exp\u00e9riences de science des donn\u00e9es.

    "},{"location":"1-Experiences/Jupyter.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Jupyter.html#jupyter-experience-conviviale-de-r-et-python","title":"Jupyter: Exp\u00e9rience conviviale de R et Python","text":"

    Jupyter vous propose des bloc-notes pour \u00e9crire votre code et r\u00e9aliser des visualisations. Vous pouvez rapidement it\u00e9rer, visualiser et partager vos analyses. Parce qu'il fonctionne sur un serveur (que vous avez configur\u00e9 dans la section Kubeflow), vous pouvez effectuer de tr\u00e8s grandes analyses sur du mat\u00e9riel centralis\u00e9, en ajoutant autant de puissance que n\u00e9cessaire! Et comme il est sur le nuage, vous pouvez \u00e9galement le partager avec vos coll\u00e8gues.

    "},{"location":"1-Experiences/Jupyter.html#explorez-vos-donnees","title":"Explorez vos donn\u00e9es","text":"

    Jupyter offre un certain nombre de fonctionnalit\u00e9s (et nous pouvons en ajouter d'autres)

    • \u00c9l\u00e9ments visuels int\u00e9gr\u00e9s dans votre bloc-notes
    • Volume de donn\u00e9es pour le stockage de vos donn\u00e9es
    • Possibilit\u00e9 de partager votre espace de travail avec vos coll\u00e8gues

    "},{"location":"1-Experiences/Jupyter.html#explorez-vos-donnees-avec-une-api","title":"Explorez vos donn\u00e9es avec une API","text":"

    Utilisez Datasette , une interface de programmation (API) JSON instantan\u00e9e pour vos bases de donn\u00e9es SQLite. Ex\u00e9cutez des requ\u00eates SQL de mani\u00e8re plus interactive !

    "},{"location":"1-Experiences/Jupyter.html#environnement-de-developpement-dans-le-navigateur","title":"Environnement de d\u00e9veloppement dans le navigateur","text":"

    Cr\u00e9ez pour explorer, et aussi pour \u00e9crire du code

    • Linting et d\u00e9bogage
    • Int\u00e9gration Git
    • Terminal int\u00e9gr\u00e9
    • Th\u00e8me clair/fonc\u00e9 (changer les param\u00e8tres en haut)

    Plus de renseignements sur Jupyter ici

    "},{"location":"1-Experiences/Jupyter.html#installation","title":"Installation","text":""},{"location":"1-Experiences/Jupyter.html#commencez-avec-les-exemples","title":"Commencez avec les exemples","text":"

    Lorsque vous avez d\u00e9marr\u00e9 votre serveur, il a \u00e9t\u00e9 charg\u00e9 de mod\u00e8les de bloc-notes. Parmi les bons blocs-notes pour commencer, il y a R/01-R-Notebook-Demo.ipynb et ceux dans scikitlearn. Les bloc-notes pytorch et tensorflow sont excellents si vous connaissez l'apprentissage automatique. mapreduce-pipeline et ai-pipeline sont plus avanc\u00e9s.

    Certains bloc-notes ne fonctionnent que dans certaines versions de serveur

    Par exemple, gdal ne fonctionne que dans l'image g\u00e9omatique. Donc, si vous utilisez une autre image, un bloc-notes utilisant gdal pourrait ne pas fonctionner.

    "},{"location":"1-Experiences/Jupyter.html#ajout-de-logiciels","title":"Ajout de logiciels","text":"

    Vous n'avez pas sudo dans Jupyter, mais vous pouvez utiliser

    conda install --use-local your_package_name\n

    ou

    pip install --user your_package_name\n

    N'oubliez pas de red\u00e9marrer votre noyau Jupyter par la suite, pour acc\u00e9der \u00e0 de nouvelles trousses.

    Assurez-vous de red\u00e9marrer le noyau Jupyter apr\u00e8s l'installation d'un nouveau logiciel

    Si vous installez un logiciel dans un terminal, mais que votre noyau Jupyter \u00e9tait d\u00e9j\u00e0 en cours d'ex\u00e9cution, il ne sera pas mis \u00e0 jour.

    Y a-t-il quelque chose que vous ne pouvez pas installer?

    Si vous avez besoin d'installer quelque chose, communiquez avec nous ou ouvrir une question GitHub. Nous pouvons l'ajouter au logiciel par d\u00e9faut.

    "},{"location":"1-Experiences/Jupyter.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases ...","text":""},{"location":"1-Experiences/Jupyter.html#entrer-et-sortir-des-donnees-de-jupyter","title":"Entrer et sortir des donn\u00e9es de Jupyter","text":"

    Vous pouvez t\u00e9l\u00e9charger et charger des donn\u00e9es vers ou depuis JupyterHub directement dans le menu. Il y a un bouton de chargement en haut, et vous pouvez cliquer avec le bouton droit de la souris sur la plupart des fichiers ou dossiers pour les t\u00e9l\u00e9charger.

    "},{"location":"1-Experiences/Jupyter.html#stockage-partage-en-compartiment","title":"Stockage partag\u00e9 en compartiment","text":"

    Il existe \u00e9galement un dossier buckets mont\u00e9 dans votre r\u00e9pertoire personnel, qui contient les fichiers dans Stockage Blob Azure.

    Reportez-vous \u00e0 la section Stockage pour plus de d\u00e9tails.

    "},{"location":"1-Experiences/Jupyter.html#lanalyse-des-donnees","title":"L'analyse des donn\u00e9es","text":"

    L'analyse des donn\u00e9es est un art sous-estim\u00e9.

    L'analyse des donn\u00e9es est le processus d'examen et d'interpr\u00e9tation de grandes quantit\u00e9s de donn\u00e9es pour extraire des informations utiles et tirer des conclusions significatives. Cela peut \u00eatre fait \u00e0 l'aide de diverses techniques et outils, tels que l'analyse statistique, l'apprentissage automatique et la visualisation. L'objectif de l'analyse des donn\u00e9es est de d\u00e9couvrir des mod\u00e8les, des tendances et des relations dans les donn\u00e9es, qui peuvent ensuite \u00eatre utilis\u00e9s pour \u00e9clairer les d\u00e9cisions et r\u00e9soudre les probl\u00e8mes. L'analyse de donn\u00e9es est utilis\u00e9e dans un large \u00e9ventail de domaines, des affaires et de la finance aux soins de sant\u00e9 et \u00e0 la science, pour aider les organisations \u00e0 prendre des d\u00e9cisions plus \u00e9clair\u00e9es sur la base de preuves et d'informations bas\u00e9es sur des donn\u00e9es.

    "},{"location":"1-Experiences/Jupyter.html#jupyterlab","title":"JupyterLab","text":"

    Traiter les donn\u00e9es \u00e0 l'aide de R, Python ou Julia dans JupyterLab

    Le traitement des donn\u00e9es \u00e0 l'aide de R, Python ou Julia est simplifi\u00e9 gr\u00e2ce \u00e0 l'espace de travail d'analyse avanc\u00e9e. Que vous d\u00e9butiez dans l'analyse de donn\u00e9es ou que vous soyez un data scientist exp\u00e9riment\u00e9, notre plateforme prend en charge une gamme de langages de programmation pour r\u00e9pondre \u00e0 vos besoins. Vous pouvez installer et ex\u00e9cuter des packages pour R ou Python pour effectuer des t\u00e2ches de traitement de donn\u00e9es telles que le nettoyage, la transformation et la mod\u00e9lisation des donn\u00e9es. Si vous pr\u00e9f\u00e9rez Julia, notre plateforme offre \u00e9galement un support pour ce langage de programmation.

    "},{"location":"1-Experiences/Kubeflow.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Kubeflow.html#que-fait-kubeflow","title":"Que fait Kubeflow?","text":"

    Kubeflow ex\u00e9cute vos espaces de travail. Vous pouvez avoir des serveurs de bloc-notes (appel\u00e9s serveurs Jupyter), et vous pouvez y cr\u00e9er des analyses en R et Python avec des visuels interactifs. Vous pouvez enregistrer et charger des donn\u00e9es, t\u00e9l\u00e9charger des donn\u00e9es, et cr\u00e9er des espaces de travail partag\u00e9s pour votre \u00e9quipe.

    Commen\u00e7ons sans plus tarder!

    "},{"location":"1-Experiences/Kubeflow.html#installation","title":"Installation","text":""},{"location":"1-Experiences/Kubeflow.html#connectez-vous-a-kubeflow","title":"Connectez-vous \u00e0 Kubeflow","text":"

    Connectez-vous au portail Azure \u00e0 l'aide de vos identifiants cloud

    Vous devez vous connecter au portail Azure ** en utilisant vos informations d'identification StatCan **.first.lastname@cloud.statcan.ca ou ** en utilisant vos informations d'identification StatCan ** first.lastname@statcan.gc.ca. Vous pouvez le faire en utilisant Portail Azure.

    • Se connecter \u00e0 Kubeflow
    • Acc\u00e9dez \u00e0 l'onglet Serveurs bloc-notes
    • Assurez-vous que l'espace de noms de votre projet est s\u00e9lectionn\u00e9 dans le menu d\u00e9roulant des espaces de noms et que l'exemple dans la capture d'\u00e9cran est \"aaw-team\".

    • Puis clique + Nouveau serveur
    "},{"location":"1-Experiences/Kubeflow.html#configuration-de-votre-serveur","title":"Configuration de votre serveur","text":"
    • Vous obtiendrez un mod\u00e8le pour cr\u00e9er votre serveur de bloc-notes. Remarque : le nom de votre serveur doit \u00eatre en lettres minuscules avec des tirets. Pas d'espaces, et non souligne.
    "},{"location":"1-Experiences/Kubeflow.html#image","title":"Image","text":"

    Vous devrez choisir une image. Il existe JupyterLab, RStudio, bureau \u00e0 distance Ubuntu et SAS disponibles. L'image SAS est disponible uniquement pour les employ\u00e9s de StatCan (en raison des limitations de licence), les autres sont disponibles pour tout le monde. S\u00e9lectionnez le menu d\u00e9roulant pour s\u00e9lectionner des options suppl\u00e9mentaires parmi celles-ci (par exemple les images CPU, PyTorch et TensorFlow pour JupyterLab).

    V\u00e9rifiez le nom des images et choisissez-en une qui correspond \u00e0 ce que vous souhaitez faire. Je ne sais pas lequel choisir ? D\u00e9couvrez vos options ici.

    "},{"location":"1-Experiences/Kubeflow.html#image-personnalisee","title":"Image personnalis\u00e9e","text":"

    Un utilisateur peut utiliser une image personnalis\u00e9e, auquel cas il doit conna\u00eetre la forme exacte de l'image et son nom.

    Les images personnalis\u00e9es de l'utilisateur sont fournies via le d\u00e9p\u00f4t aaw-contrib-containers qui, une fois pouss\u00e9es vers la branche principale, poussera \u00e9galement l'image vers notre ACR. Une fois cette action termin\u00e9e avec succ\u00e8s, vous pouvez utiliser l'image personnalis\u00e9e.

    Lors de la cr\u00e9ation d'un bloc-notes, cliquez sur \u00ab Options avanc\u00e9es \u00bb, cochez la case pour l'image personnalis\u00e9e et saisissez l'image en saisissant k8scc01covidacr.azurecr.io/[your-image-name-here]:[sha].

    Une fois le bloc-note cr\u00e9\u00e9, si le statut n'est pas pr\u00eat au bout de quelques minutes, cliquez sur son nom pour voir la page de d\u00e9tails. Ensuite l'onglet \u00ab \u00c9v\u00e9nements \u00bb vous permet de savoir exactement ce qui se passe. Si n\u00e9cessaire, contactez le canal d\u2019aide sur Slack si le probl\u00e8me persiste.

    "},{"location":"1-Experiences/Kubeflow.html#cpu-et-memoire","title":"CPU et m\u00e9moire","text":"

    • Au moment de la r\u00e9daction (23 d\u00e9cembre, 2021), il existe deux types d'ordinateurs dans la grappe

      • CPU: D16s v3 (16 CPU , 64 G m\u00e9moire; 15 CPU et 48 G m\u00e9moire sont disponible pour l'utilisateur, 1 CPU et 16 G m\u00e9moire sont r\u00e9serv\u00e9s pour l'utilisation du syst\u00e8me)
      • GPU: NC6s_v3 (6 CPU , 112 G m\u00e9moire, 1 GPU; 96 G de m\u00e9moire disponible pour l'utilisateur, 16 G sont r\u00e9serv\u00e9s pour l'utilisation du syst\u00e8me)

    Lors de la cr\u00e9ation d'un serveur de bloc-notes, le syst\u00e8me vous limitera aux sp\u00e9cifications maximales ci-dessus. Pour les serveurs de bloc-notes CPU, vous pouvez sp\u00e9cifier la quantit\u00e9 exacte de CPU et de m\u00e9moire dont vous avez besoin. Cela vous permet de r\u00e9pondre \u00e0 vos besoins de calcul tout en minimisant les co\u00fbts. Pour un serveur portable GPU, vous obtiendrez toujours le serveur complet (6 c\u0153urs CPU, 96 Gio de m\u00e9moire accessible et 1 GPU).

    Dans les options avanc\u00e9es, vous pouvez s\u00e9lectionner une limite sup\u00e9rieure au nombre de c\u0153urs de processeur et de RAM demand\u00e9s. Le montant demand\u00e9 est le montant garanti disponible pour votre serveur bloc-notes et vous paierez toujours au moins ce montant. Si la limite est sup\u00e9rieure \u00e0 la quantit\u00e9 demand\u00e9e, si des c\u0153urs de RAM et de processeur suppl\u00e9mentaires sont disponibles sur ce serveur partag\u00e9 dans le cluster, votre serveur de bloc-notes peut les utiliser selon vos besoins. Un cas d\u2019utilisation est celui des t\u00e2ches qui ne n\u00e9cessitent g\u00e9n\u00e9ralement qu\u2019un seul c\u0153ur de processeur mais qui peuvent b\u00e9n\u00e9ficier du multithreading pour acc\u00e9l\u00e9rer certaines op\u00e9rations. En demandant un c\u0153ur de processeur mais une limite plus \u00e9lev\u00e9e, vous pouvez payer beaucoup moins pour le serveur boc-notes tout en lui permettant d'utiliser des c\u0153urs de processeur de rechange inutilis\u00e9s si n\u00e9cessaire pour acc\u00e9l\u00e9rer les calculs.

    "},{"location":"1-Experiences/Kubeflow.html#gpus","title":"GPUs","text":"

    Si vous voulez un serveur GPU, s\u00e9lectionnez \u00ab 1 \u00bb comme nombre de GPU et \u00ab NVIDIA \u00bb comme fournisseur de GPU (le bouton de cr\u00e9ation sera gris\u00e9 jusqu'\u00e0 ce que le fournisseur de GPU soit s\u00e9lectionn\u00e9 si vous avez un GPU sp\u00e9cifi\u00e9). Les serveurs multi-GPU sont actuellement pris en charge sur le syst\u00e8me ETAA uniquement sur une base sp\u00e9ciale sur demande, veuillez contacter les mainteneurs d'ETAA si vous souhaitez un serveur multi-GPU.

    Comme mentionn\u00e9 pr\u00e9c\u00e9demment, si vous s\u00e9lectionnez un serveur GPU, vous obtiendrez automatiquement 6 CPU c\u0153urs et 112 Go de m\u00e9moire.

    Utilisez les machines GPU de mani\u00e8re responsable

    Les machines GPU sont nettement plus ch\u00e8res que les machines CPU, alors utilisez-les de mani\u00e8re responsable.

    "},{"location":"1-Experiences/Kubeflow.html#volume-despace-de-travail","title":"Volume d'espace de travail","text":"

    Vous aurez besoin d'un volume d'espace de travail, sur lequel le dossier personnel sera mont\u00e9. Ces diff\u00e9rentes options de configuration sont disponibles\u00a0:

    • Vous pouvez soit r\u00e9utiliser un volume d'espace de travail existant auparavant, soit en cr\u00e9er un nouveau.
    • Vous pouvez sp\u00e9cifier la taille du volume de l'espace de travail, de 4\u00a0Gio \u00e0 32\u00a0Gio.

    V\u00e9rifiez les anciens volumes en regardant l'option Existant

    Lorsque vous cr\u00e9ez votre serveur vous avez la possibilit\u00e9 de r\u00e9utiliser un ancien volume ou en cr\u00e9er un nouveau. Vous souhaitez probablement r\u00e9utiliser votre ancien volume.

    "},{"location":"1-Experiences/Kubeflow.html#volumes-de-donnees","title":"Volumes de donn\u00e9es","text":"

    Vous pouvez \u00e9galement cr\u00e9er des volumes de donn\u00e9es pouvant \u00eatre utilis\u00e9s pour stocker des donn\u00e9es suppl\u00e9mentaires. Plusieurs volumes de donn\u00e9es peuvent \u00eatre cr\u00e9\u00e9s. Cliquez sur le bouton Ajouter un nouveau volume pour cr\u00e9er un nouveau volume et pr\u00e9ciser sa configuration. Cliquez sur le bouton Attacher un volume existant pour monter un volume existant vers le serveur de bloc-notes. Il existe les param\u00e8tres de configuration suivants pour les volumes de donn\u00e9es\u00a0:

    • Nom\u00a0: Nom du volume.
    • Taille en GiB\u00a0: De 4\u00a0Gio \u00e0 512\u00a0Gio.
    • Chemin de montage\u00a0: Chemin o\u00f9 le volume de donn\u00e9es est accessible sur le serveur bloc-notes, par par d\u00e9faut /home/jovyan/vol-1, /home/jovyan/vol-2, etc. (compteur incr\u00e9mentiel par donn\u00e9es volume mont\u00e9).

    Lors du montage d'un volume de donn\u00e9es existant, l'option de nom devient une liste d\u00e9roulante du volumes de donn\u00e9es existants. Uniquement un volume non actuellement mont\u00e9 sur un serveur de bloc-notes existant peut \u00eatre utilis\u00e9. L'option du chemin de montage reste configurable par l'utilisateur avec les m\u00eames valeurs par d\u00e9faut que cr\u00e9er un nouveau volume.

    L'ic\u00f4ne de la poubelle \u00e0 droite peut \u00eatre utilis\u00e9e pour supprimer un volume de donn\u00e9es existant ou cr\u00e9\u00e9 accidentellement.

    "},{"location":"1-Experiences/Kubeflow.html#configuration","title":"Configuration","text":"

    Si des configurations sont disponibles, elles sont pr\u00e9sent\u00e9es ici sous forme de cases \u00e0 cocher. Actuellement, aucune configuration n'existe.

    "},{"location":"1-Experiences/Kubeflow.html#parametres-divers","title":"Param\u00e8tres divers","text":"

    Les \u00e9l\u00e9ments suivants peuvent \u00eatre personnalis\u00e9s ici\u00a0:

    • Activer la m\u00e9moire partag\u00e9e\u00a0: ceci est requis si vous utilisez PyTorch avec plusieurs donn\u00e9es chargeurs, qui autrement g\u00e9n\u00e9reront une erreur. Si vous utilisez PyTorch, assurez-vous de ceci est activ\u00e9, sinon cela n'a pas d'importance sauf si vous avez une autre application cela n\u00e9cessite une m\u00e9moire partag\u00e9e.
    • Langue du syst\u00e8me\u00a0: Vous pouvez sp\u00e9cifier ici l'anglais ou le fran\u00e7ais.

    "},{"location":"1-Experiences/Kubeflow.html#et-creer","title":"Et... Cr\u00e9er!!!","text":"
    • Si vous \u00eates satisfait des param\u00e8tres, vous pouvez maintenant cr\u00e9er le serveur ! Cela pourrait prenez quelques minutes pour d\u00e9marrer en fonction des ressources que vous avez demand\u00e9es. (GPU prendre plus de temps.)

    Votre serveur est en cours d'ex\u00e9cution

    Si tout se passe bien, votre serveur devrait fonctionner !!! Vous aurez maintenant le possibilit\u00e9 de se connecter, et essayer Jupyter!

    "},{"location":"1-Experiences/Kubeflow.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":""},{"location":"1-Experiences/Kubeflow.html#partagez-votre-espace-de-travail","title":"Partagez votre espace de travail","text":"

    Dans Kubeflow, chaque utilisateur dispose d'un espace de noms qui contient son travail (ses serveurs blocs-note, pipelines, disques, etc.). Votre espace de nom vous appartient, mais peut \u00eatre partag\u00e9 si vous souhaitez collaborer avec d'autres. Pour plus de d\u00e9tails sur collaboration sur la plateforme, voir Collaboration.

    "},{"location":"1-Experiences/MLflow.html","title":"Aper\u00e7u","text":"

    !!! danger \"MLflow a \u00e9t\u00e9 retir\u00e9 du projet AAW. Si vous en avez besoin, contactez l'\u00e9quipe de d\u00e9veloppement\"

    MLflow s'agit d'une plateforme libre pour la gestion du cycle de vie de l'apprentissage automatique. C'est un \"registre de mod\u00e8les\" pour stocker vos mod\u00e8les d'apprentissage automatique et les m\u00e9triques associ\u00e9es. Vous pouvez utiliser l'interface web pour examiner vos mod\u00e8les, et vous pouvez utiliser son API REST pour enregistrer vos mod\u00e8les depuis Python, en utilisant le [paquet mlflow pip] (https://pypi.org/project/mlflow/).

    "},{"location":"1-Experiences/RStudio.html","title":"Aper\u00e7u","text":"

    RStudio est un environnement de d\u00e9veloppement int\u00e9gr\u00e9 (IDE) pour R. Il comprend un console, \u00e9diteur et outils de tra\u00e7age, d'historique, de d\u00e9bogage et d'espace de travail gestion.

    "},{"location":"1-Experiences/RStudio.html#didacticiel-video","title":"Didacticiel vid\u00e9o","text":""},{"location":"1-Experiences/RStudio.html#installation","title":"Installation","text":"

    Vous pouvez utiliser l'image rstudio pour obtenir un environnement RStudio ! Lorsque vous cr\u00e9ez votre bloc-notes, choisissez RStudio dans la liste des images disponibles.

    Vous pouvez installer les packages R ou python avec conda ou install.packages().

    "},{"location":"1-Experiences/RStudio.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":""},{"location":"1-Experiences/RStudio.html#r-shiny","title":"R-Shiny","text":"

    Vous pouvez aussi utiliser \u00ab\u00a0Shiny\u00a0\u00bb\u00a0! Shiny est un package R open source qui fournit un cadre web pour cr\u00e9er des applications Web \u00e0 l'aide de R. Shiny vous aide \u00e0 transformer votre analyses en applications Web interactives.

    "},{"location":"1-Experiences/RStudio.html#r-studio","title":"R\u00a0Studio","text":"

    Traiter les donn\u00e9es \u00e0 l'aide de R ou Python dans R Studio

    R Studio est un puissant environnement de d\u00e9veloppement int\u00e9gr\u00e9 (IDE) qui prend en charge les langages de programmation R et Python, ce qui en fait un choix id\u00e9al pour les analystes de donn\u00e9es et les scientifiques. Avec R Studio, vous pouvez effectuer un large \u00e9ventail de t\u00e2ches de traitement de donn\u00e9es, du nettoyage et de la transformation des donn\u00e9es \u00e0 l'analyse statistique et \u00e0 l'apprentissage automatique. Le logiciel fournit une interface conviviale et une vari\u00e9t\u00e9 d'outils et de biblioth\u00e8ques qui simplifient les t\u00e2ches complexes d'analyse de donn\u00e9es. De plus, R Studio facilite le partage de votre travail avec d'autres en cr\u00e9ant des rapports et des visualisations dynamiques et interactifs qui peuvent \u00eatre publi\u00e9s en ligne ou partag\u00e9s sous forme de documents autonomes. Dans l'ensemble, R Studio est un outil polyvalent et puissant, essentiel pour toute personne travaillant avec des donn\u00e9es en R ou Python.

    R Studio vous offre un environnement de d\u00e9veloppement int\u00e9gr\u00e9 pour R et Python. Utilisez l'image r-studio-cpu pour obtenir un environnement R Studio.

    "},{"location":"1-Experiences/Selectionner-une-image.html","title":"S\u00e9lection d'une image pour votre serveur bloc-notes","text":"

    En fonction de votre projet ou du cas d'utilisation du serveur bloc-notes, certaines images peuvent \u00eatre plus adapt\u00e9 que d'autres. Ce qui suit passera en revue les caract\u00e9ristiques principales de chacun pour vous aider \u00e0 choisir l\u2019image la plus appropri\u00e9e pour vous.

    Lors de la s\u00e9lection d'une image, vous disposez de 3 options principales\u00a0:

    • Carnet Jupyter (CPU, TensorFlow, PyTorch)
    • RStudio
    • Bureau \u00e0 distance
    "},{"location":"1-Experiences/Selectionner-une-image.html#bloc-notes-jupyter","title":"Bloc-notes Jupyter","text":"

    Les bloc-notes Jupyter sont utilis\u00e9s pour cr\u00e9er et partager documents interactifs contenant un m\u00e9lange de code en direct, de visualisations et de texte. Ceux-ci peuvent \u00eatre \u00e9crits en Python, Julia ou R.

    Les utilisations courantes incluent\u00a0:

    transformation de donn\u00e9es, simulation num\u00e9rique, statistique mod\u00e9lisation, apprentissage automatique et bien plus encore.

    Les bloc-notes Jupyter sont d'excellents tremplins pour l'analyse, y compris les apprentissage automatique. L'image jupyterlab-cpu donne une bonne exp\u00e9rience de base pour python, y compris des paquets courants tels que numpy, pandas et scikit-learn. Si vous souhaitez sp\u00e9cifiquement utiliser TensorFlow ou PyTorch, nous ont \u00e9galement jupyterlab-tensorflow et jupyterlab-pytorch qui viennent avec ceux outils pr\u00e9install\u00e9s.

    Pour l'image jupyterlab-pytorch, les paquets PyTorch (torch, torchvision, et torchaudio) sont install\u00e9s dans l'environnement conda torch. Vous devez activez cet environnement pour utiliser PyTorch.

    Pour jupyterlab-cpu, jupyterlab-tensorflow et jupyterlab-pytorch images, dans le shell par d\u00e9faut, la commande conda activate peut ne pas fonctionner. C'est en raison de l'environnement qui n'est pas initialis\u00e9 correctement. Dans ce cas, lancez bash, vous devriez voir le logo AAW et quelques instructions appara\u00eetre. Apr\u00e8s \u00e7a conda activate devrait fonctionner correctement. Si vous voyez le logo AAW au d\u00e9marrage signifie que l'environnement est correctement initialis\u00e9 et que conda activate devrait fonctionner correctement. Un correctif pour ce bug est en pr\u00e9paration, une fois celui-ci corrig\u00e9, ce paragraphe sera supprim\u00e9.

    Chaque image est pr\u00e9charg\u00e9e avec VS Code dans le navigateur si vous pr\u00e9f\u00e9rez une exp\u00e9rience IDE compl\u00e8te.

    "},{"location":"1-Experiences/Selectionner-une-image.html#rstudio","title":"RStudio","text":"

    RStudio vous offre un environnement de d\u00e9veloppement int\u00e9gr\u00e9 sp\u00e9cifiquement pour R. Si vous codez en R, il s'agit g\u00e9n\u00e9ralement du Serveur Bloc-notes \u00e0 utiliser. Utilisez l'image rstudio pour obtenir un environnement RStudio.

    "},{"location":"1-Experiences/Selectionner-une-image.html#bureau-a-distance","title":"Bureau \u00e0 distance","text":"

    Pour une exp\u00e9rience de bureau Ubuntu compl\u00e8te, utilisez l'image du bureau \u00e0 distance. Elle est pr\u00e9charg\u00e9e avec les outils Python, R et Geomatics, mais dans une exp\u00e9rience de bureau typique qui comprend \u00e9galement Firefox, VS Code et les outils Open Office. Le syst\u00e8me d'exploitation est Ubuntu 22.04 avec l'environnement de bureau XFCE.

    "},{"location":"1-Experiences/bloc-notes/DTale_FR.html","title":"D-Tale: un outil d'exploration de donn\u00e9es transparente pour Python","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -r requirements.txt\n! pip install -U dtale\n
    %%capture ! pip install -r requirements.txt ! pip install -U dtale In\u00a0[\u00a0]: Copied! 
    import dtale\nimport pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\n\n# R\u00e9cup\u00e9ration de l'ensemble de donn\u00e9es Pok\u00e9mon\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\n# Lecture d'un ensemble de donn\u00e9es \u00e0 l'aide de Pandas\npokemon_df = pd.read_csv(file_name)\n\n# Affichage d'un ensemble de donn\u00e9es avec D-Tale\ndtale.show(pokemon_df)\n
    import dtale import pandas as pd from ydata_profiling.utils.cache import cache_file # R\u00e9cup\u00e9ration de l'ensemble de donn\u00e9es Pok\u00e9mon file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) # Lecture d'un ensemble de donn\u00e9es \u00e0 l'aide de Pandas pokemon_df = pd.read_csv(file_name) # Affichage d'un ensemble de donn\u00e9es avec D-Tale dtale.show(pokemon_df)

    D-Tale vient \u00e0 la rescousse en fournissant une interface conviviale pour les t\u00e2ches essentielles d'exploration de donn\u00e9es, \u00e9liminant ainsi le besoin de code r\u00e9p\u00e9titif et permettant de gagner un temps pr\u00e9cieux dans le processus.

    "},{"location":"1-Experiences/bloc-notes/DTale_FR.html#d-tale-un-outil-dexploration-de-donnees-transparente-pour-python","title":"D-Tale: un outil d'exploration de donn\u00e9es transparente pour Python\u00b6","text":"

    D-Tale, n\u00e9 d'une conversion SAS vers Python, transforme le processus d'exploration des donn\u00e9es en un jeu d'enfant. \u00c0 l'origine un wrapper de script Perl pour la fonction d'analyse de SAS, il a \u00e9volu\u00e9 vers un client Web l\u00e9ger parfaitement int\u00e9gr\u00e9 aux structures de donn\u00e9es Pandas.

    Construit sur un back-end Flask et un front-end React, D-Tale offre une m\u00e9thode simple pour visualiser et analyser les structures de donn\u00e9es Pandas. Son int\u00e9gration transparente avec les bloc-notes Jupyter et les terminaux Python/IPython en fait un outil polyvalent. Actuellement, il prend en charge divers objets Pandas, notamment DataFrame, Series, MultiIndex, DatetimeIndex et RangeIndex.

    D-Tale est une solution qui simplifie l'exploration des donn\u00e9es. Agissant comme un client Web l\u00e9ger sur les structures de donn\u00e9es Pandas, D-Tale offre une interface utilisateur intuitive pour effectuer diverses t\u00e2ches d'exploration de donn\u00e9es sans avoir besoin d'\u00e9crire de code.

    "},{"location":"1-Experiences/bloc-notes/DTale_FR.html#installation","title":"Installation:\u00b6","text":""},{"location":"1-Experiences/bloc-notes/DTale_FR.html#utilisation","title":"Utilisation:\u00b6","text":""},{"location":"1-Experiences/bloc-notes/DrawData_FR.html","title":"Draw Data: cr\u00e9er facilement des ensembles de donn\u00e9es synth\u00e9tiques","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -r requirements.txt\n! pip install -U drawdata\n# sudo apt-get install xsel xclip -y\n
    %%capture ! pip install -r requirements.txt ! pip install -U drawdata # sudo apt-get install xsel xclip -y In\u00a0[\u00a0]: Copied! 
    from drawdata import draw_scatter\n\ndraw_scatter()\n
    from drawdata import draw_scatter draw_scatter() In\u00a0[\u00a0]: Copied! 
    import pandas as pd\n\n# Lecture du presse-papier dans un DataFrame\ndf = pd.read_clipboard(sep=\",\")\ndf\n
    import pandas as pd # Lecture du presse-papier dans un DataFrame df = pd.read_clipboard(sep=\",\") df In\u00a0[\u00a0]: Copied! 
    import plotly.express as px\nimport plotly\n\nplotly.offline.init_notebook_mode(connected=True)\n\n# Creating an interactive scatter plot\nfig = px.scatter(df, x='x', y='y', color='z')\nfig.update_layout(\n    autosize=False,\n    width=800,\n    height=800,\n)\nfig.show()\n
    import plotly.express as px import plotly plotly.offline.init_notebook_mode(connected=True) # Creating an interactive scatter plot fig = px.scatter(df, x='x', y='y', color='z') fig.update_layout( autosize=False, width=800, height=800, ) fig.show()

    Ce guide complet vous permet de dessiner, d'analyser et de visualiser de mani\u00e8re transparente votre ensemble de donn\u00e9es synth\u00e9tiques, rendant ainsi le processus d'enseignement des concepts d'apprentissage automatique plus intuitif et engageant.

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#draw-data-creer-facilement-des-ensembles-de-donnees-synthetiques","title":"Draw Data: cr\u00e9er facilement des ensembles de donn\u00e9es synth\u00e9tiques\u00b6","text":"

    Avez-vous d\u00e9j\u00e0 souhait\u00e9 pouvoir g\u00e9n\u00e9rer sans effort un ensemble de donn\u00e9es en dessinant visuellement des points sur un plan cart\u00e9sien? D\u00e9couvrez Draw Data, une application Python pratique con\u00e7ue pour les bloc-notes Jupyter. Cet outil vous permet de cr\u00e9er des ensembles de donn\u00e9es jouets ou synth\u00e9tiques en dessinant simplement vos id\u00e9es directement sur le graphique. Cela s\u2019av\u00e8re particuli\u00e8rement utile lors de l\u2019enseignement d\u2019algorithmes d\u2019apprentissage automatique.

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#installation","title":"Installation:\u00b6","text":""},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#commencer","title":"Commencer:\u00b6","text":"

    Pour dessiner un ensemble de donn\u00e9es, ex\u00e9cutez la cellule suivante. Vous pouvez esquisser jusqu'\u00e0 quatre classes de points. Ensuite, cliquez sur \u00ab Copier CSV \u00bb et vos points de donn\u00e9es, pr\u00e9sent\u00e9s sous forme de valeurs x, y, z s\u00e9par\u00e9es par des virgules, seront copi\u00e9s dans le presse-papiers. Pour importer les donn\u00e9es dans un Pandas DataFrame, utilisez le code suivant:

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#affichage-du-tableau-de-donnees","title":"Affichage du tableau de donn\u00e9es:\u00b6","text":"

    Une fois que vous avez termin\u00e9 votre dessin, copiez les donn\u00e9es dans le presse-papiers. L'\u00e9tape suivante consiste \u00e0 utiliser Pandas pour lire le presse-papiers et remplir un DataFrame. Voici un aper\u00e7u des premi\u00e8res entr\u00e9es:

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#tracer-les-donnees-dessinees","title":"Tracer les donn\u00e9es dessin\u00e9es:\u00b6","text":"

    Visualiser les points dessin\u00e9s devient un jeu d'enfant avec Plotly, qui fournit un graphique interactif. L'extrait de code suivant accomplit cela:

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html","title":"Mito Sheet: feuilles de calcul de type Excel dans JupyterLab","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -r requirements.txt\n! pip install -U mitosheet\n! python -m jupyter nbextension install --py --user mitosheet\n! python -m jupyter nbextension enable --py --user mitosheet\n
    %%capture ! pip install -r requirements.txt ! pip install -U mitosheet ! python -m jupyter nbextension install --py --user mitosheet ! python -m jupyter nbextension enable --py --user mitosheet In\u00a0[\u00a0]: Copied! 
    import mitosheet\nmitosheet.sheet(analysis_to_replay=\"id-nxpaeypddd\")\n
    import mitosheet mitosheet.sheet(analysis_to_replay=\"id-nxpaeypddd\") In\u00a0[\u00a0]: Copied! 
    import mitosheet\nimport pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\n\n# Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\n# Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame\npokemon_df = pd.read_csv(file_name)\n\n# Lancement de Mito Sheet avec le jeu de donn\u00e9es Pok\u00e9mon\nmitosheet.sheet(pokemon_df, analysis_to_replay=\"id-flhnxtovqt\")\n
    import mitosheet import pandas as pd from ydata_profiling.utils.cache import cache_file # Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) # Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame pokemon_df = pd.read_csv(file_name) # Lancement de Mito Sheet avec le jeu de donn\u00e9es Pok\u00e9mon mitosheet.sheet(pokemon_df, analysis_to_replay=\"id-flhnxtovqt\")

    Mito Sheet vous permet d'exploiter votre ma\u00eetrise d'Excel dans l'environnement JupyterLab. Analysez en toute transparence des ensembles de donn\u00e9es, effectuez des calculs et visualisez les r\u00e9sultats, le tout dans l'interface famili\u00e8re que vous connaissez et aimez. Profitez de la puissance de Mito Sheet pour une exp\u00e9rience d\u2019analyse de donn\u00e9es plus int\u00e9gr\u00e9e et plus efficace.

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#mito-sheet-feuilles-de-calcul-de-type-excel-dans-jupyterlab","title":"Mito Sheet: feuilles de calcul de type Excel dans JupyterLab\u00b6","text":"

    Mito Sheet propose un tableur parfaitement int\u00e9gr\u00e9 \u00e0 JupyterLab, apportant une exp\u00e9rience famili\u00e8re de type Excel \u00e0 votre flux de travail d'analyse de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour installer Mito Sheet, ex\u00e9cutez la cellule suivante dans votre environnement JupyterLab:

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#commencer","title":"Commencer:\u00b6","text":"

    Commencez votre parcours Mito Sheet en ex\u00e9cutant l\u2019extrait de code suivant:

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#travailler-avec-des-donnees-excel","title":"Travailler avec des donn\u00e9es Excel:\u00b6","text":"

    Pour ceux qui sont habitu\u00e9s \u00e0 Excel, la transition vers Mito Sheet se fait en toute transparence. Importons un ensemble de donn\u00e9es de type Excel \u00e0 titre d'illustration. Nous utiliserons un ensemble de donn\u00e9es Pok\u00e9mon populaire disponible en ligne:

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html","title":"PyGWalker:\u00a0simplifier l'analyse exploratoire des donn\u00e9es avec Python","text":"In\u00a0[2]: Copied! 
    %%capture\n! pip install -r requirements.txt\n! pip install -U pygwalker ydata-profiling ipywidgets\n
    %%capture ! pip install -r requirements.txt ! pip install -U pygwalker ydata-profiling ipywidgets In\u00a0[\u00a0]: Copied! 
    import pandas as pd\nimport pygwalker as pyg\nfrom ydata_profiling.utils.cache import cache_file\n\n# Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\n# Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame\npokemon_df = pd.read_csv(file_name)\n\n# Lancement de PyGWalker pour l'exploration visuelle\npyg.walk(pokemon_df)\n
    import pandas as pd import pygwalker as pyg from ydata_profiling.utils.cache import cache_file # Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) # Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame pokemon_df = pd.read_csv(file_name) # Lancement de PyGWalker pour l'exploration visuelle pyg.walk(pokemon_df)

    Avec PyGWalker, transformez sans effort vos donn\u00e9es en applications de visualisation interactive en utilisant une seule ligne de code. Que vous soyez habitu\u00e9 \u00e0 Excel ou Power BI, PyGWalker offre une solution transparente et efficace pour explorer et comprendre vos ensembles de donn\u00e9es dans l'environnement Jupyter Notebook.

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#pygwalker-simplifier-lanalyse-exploratoire-des-donnees-avec-python","title":"PyGWalker:\u00a0simplifier l'analyse exploratoire des donn\u00e9es avec Python\u00b6","text":"

    Pr\u00e9sentation de PyGWalker, une biblioth\u00e8que Python con\u00e7ue pour rationaliser vos t\u00e2ches d'analyse exploratoire de donn\u00e9es (EDA) et de visualisation dans bloc-notes Jupyter. Con\u00e7u pour les statisticiens nationaux familiers avec Excel et Power BI, PyGWalker transforme votre dataframe pandas (et dataframe polaires) en une interface utilisateur intuitive de style Tableau, am\u00e9liorant ainsi votre exp\u00e9rience d'exploration de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#quest-ce-que-pygwalker","title":"Qu'est-ce que PyGWalker?\u00b6","text":"

    PyGWalker, affectueusement prononc\u00e9 comme \u00ab Pig Walker \u00bb, est l'abr\u00e9viation de \u00ab liaison Python de Graphic Walker \u00bb. Il s'int\u00e8gre parfaitement aux bloc-notes Jupyter, fournissant ainsi un pont vers Graphic Walker, une alternative open source \u00e0 Tableau. Cette biblioth\u00e8que permet aux data scientists d'analyser et de visualiser les donn\u00e9es sans effort gr\u00e2ce \u00e0 des op\u00e9rations simples de glisser-d\u00e9poser.

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#principales-caracteristiques","title":"Principales caract\u00e9ristiques:\u00b6","text":"
    • Interface de style Tableau: profitez d'une interface utilisateur famili\u00e8re de style Tableau pour l'exploration visuelle sans quitter l'environnement Jupyter.
    • Fonctionnalit\u00e9 glisser-d\u00e9poser: simplifiez votre flux de travail gr\u00e2ce \u00e0 des op\u00e9rations intuitives de glisser-d\u00e9poser, facilitant ainsi l'exploration des donn\u00e9es.
    • Interface utilisateur conversationnelle: participez \u00e0 l'exploration de donn\u00e9es conversationnelles via une interface conviviale.
    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour d\u00e9marrer avec PyGWalker, installez la biblioth\u00e8que ainsi que les autres d\u00e9pendances n\u00e9cessaires \u00e0 l'aide de la commande suivante:

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#exemple-dutilisation","title":"Exemple d'utilisation:\u00b6","text":"

    Passons maintenant \u00e0 un exemple pratique utilisant un ensemble de donn\u00e9es. Dans ce cas, nous exploiterons un ensemble de donn\u00e9es Pok\u00e9mon disponible en ligne:

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html","title":"SweetViz: rationaliser l'EDA avec des visualisations \u00e9l\u00e9gantes","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -r requirements.txt\n! pip install -U sweetviz ydata-profiling\n
    %%capture ! pip install -r requirements.txt ! pip install -U sweetviz ydata-profiling In\u00a0[\u00a0]: Copied! 
    import sweetviz as sv\nimport pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\n\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\n\nmy_report = sv.analyze(pokemon_df)\nmy_report.show_notebook()\n
    import sweetviz as sv import pandas as pd from ydata_profiling.utils.cache import cache_file file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) my_report = sv.analyze(pokemon_df) my_report.show_notebook() 
                                                 |                                                                \u2026
    In\u00a0[\u00a0]: Copied! 
    from sklearn.model_selection import train_test_split\n\nX = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']]\ny = pokemon_df[['Type 1', 'Type 2']]\n\nX_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.33, random_state=42)\n\ntrain_df = X_train\ntest_df = X_test\n\ncomparison_report = sv.compare(train_df, test_df, target_feat='Attack')\ncomparison_report.show_notebook()\n
    from sklearn.model_selection import train_test_split X = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']] y = pokemon_df[['Type 1', 'Type 2']] X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42) train_df = X_train test_df = X_test comparison_report = sv.compare(train_df, test_df, target_feat='Attack') comparison_report.show_notebook()

    Renforcez votre parcours d'exploration de donn\u00e9es avec SweetViz, en cr\u00e9ant des rapports visuellement attrayants et informatifs avec un minimum d'effort. Que vous soyez un data scientist, un \u00e9tudiant ou un chercheur, SweetViz propose une approche conviviale pour obtenir un aper\u00e7u rapide de vos ensembles de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#sweetviz-rationaliser-leda-avec-des-visualisations-elegantes","title":"SweetViz: rationaliser l'EDA avec des visualisations \u00e9l\u00e9gantes\u00b6","text":"

    SweetViz, une biblioth\u00e8que Python open source, simplifie le processus d'analyse exploratoire des donn\u00e9es (EDA) avec seulement deux lignes de code, g\u00e9n\u00e9rant des visualisations \u00e9poustouflantes et haute densit\u00e9. Le r\u00e9sultat est une application HTML enti\u00e8rement autonome, ce qui en fait un outil pratique pour un aper\u00e7u rapide des caract\u00e9ristiques des donn\u00e9es et des comparaisons entre les ensembles de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#principales-caracteristiques","title":"Principales caract\u00e9ristiques:\u00b6","text":"
    • Analyse cible: Visualisez comment une valeur cible (par exemple, \u00ab\u00a0Surv\u00e9cu\u00a0\u00bb dans l'ensemble de donn\u00e9es Titanic) est en corr\u00e9lation avec d'autres caract\u00e9ristiques, ce qui facilite la compr\u00e9hension des caract\u00e9ristiques de la cible.
    • Visualisez et comparez: Comparez sans effort des ensembles de donn\u00e9es distincts, tels que les donn\u00e9es d'entra\u00eenement et de test, et explorez les caract\u00e9ristiques intra-ensemble (par exemple, homme contre femme).
    • Associations de types mixtes: SweetViz int\u00e8gre de mani\u00e8re transparente des associations pour les types de donn\u00e9es num\u00e9riques (corr\u00e9lation de Pearson), cat\u00e9gorielles (coefficient d'incertitude) et cat\u00e9gorielles-num\u00e9riques (rapport de corr\u00e9lation), fournissant des informations compl\u00e8tes pour divers types de donn\u00e9es.
    • Inf\u00e9rence de type: D\u00e9tecte automatiquement les fonctionnalit\u00e9s num\u00e9riques, cat\u00e9gorielles et textuelles, avec la possibilit\u00e9 de remplacements manuels si n\u00e9cessaire.
    • Informations r\u00e9capitulatives: Obtenez des informations sur le type, les valeurs uniques, les valeurs manquantes, les lignes en double et les valeurs les plus fr\u00e9quentes dans l'ensemble de donn\u00e9es.
    • Analyse num\u00e9rique: Explorez les fonctionnalit\u00e9s num\u00e9riques avec des statistiques telles que min/max/plage, quartiles, moyenne, mode, \u00e9cart type, somme, \u00e9cart absolu m\u00e9dian, coefficient de variation, aplatissement et asym\u00e9trie.
    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour d\u00e9marrer avec SweetViz, installez la biblioth\u00e8que ainsi que les autres d\u00e9pendances n\u00e9cessaires \u00e0 l'aide de la commande suivante:

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#exemple-de-base","title":"Exemple de base:\u00b6","text":"

    Effectuer une EDA de base avec SweetViz ne n\u00e9cessite que deux lignes de code. Dans l'exemple ci-dessous, nous analysons un ensemble de donn\u00e9es Pok\u00e9mon et g\u00e9n\u00e9rons un rapport d\u00e9taill\u00e9:

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#comparaison-de-deux-dataframes","title":"Comparaison de deux dataframes:\u00b6","text":"

    SweetViz \u00e9tend ses capacit\u00e9s pour comparer deux ensembles de donn\u00e9es, tels que des ensembles de formation et de test. Dans cet exemple plus complexe, nous examinons les diff\u00e9rences dans la fonctionnalit\u00e9 \u00ab\u00a0Attaque\u00a0\u00bb:

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html","title":"Visual Python:\u00a0simplifier l'analyse des donn\u00e9es pour les apprenants Python","text":"In\u00a0[1]: Copied! 
    %%capture\n! pip install -r requirements.txt\n! pip install -U jupyterlab-visualpython plotly wordcloud\n
    %%capture ! pip install -r requirements.txt ! pip install -U jupyterlab-visualpython plotly wordcloud In\u00a0[2]: Copied! 
    import pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\nfrom wordcloud import WordCloud\nfrom collections import Counter\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\ncounts = Counter(pokemon_df[[\"Type 1\"]].to_string().split())\ntags = counts.most_common(200)\n\nwc = WordCloud(max_font_size=200, background_color='white', width=1000, height=800)\ncloud = wc.generate_from_frequencies(dict(tags))\n\nplt.figure(figsize=(8, 20))\nplt.imshow(cloud)\nplt.tight_layout(pad=0)\nplt.axis('off')\nplt.show()\n
    import pandas as pd from ydata_profiling.utils.cache import cache_file from wordcloud import WordCloud from collections import Counter import matplotlib.pyplot as plt %matplotlib inline file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) counts = Counter(pokemon_df[[\"Type 1\"]].to_string().split()) tags = counts.most_common(200) wc = WordCloud(max_font_size=200, background_color='white', width=1000, height=800) cloud = wc.generate_from_frequencies(dict(tags)) plt.figure(figsize=(8, 20)) plt.imshow(cloud) plt.tight_layout(pad=0) plt.axis('off') plt.show() 
    Matplotlib is building the font cache; this may take a moment.\n
    In\u00a0[3]: Copied! 
    import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport plotly.express as px\nfrom plotly.offline import init_notebook_mode\nimport pyarrow as pa\n\ninit_notebook_mode(connected=True)\n%matplotlib inline\n\nvp_df = pokemon_df[['HP', 'Attack', 'Defense', 'Speed']].copy()\nvp_df.head()\n
    import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import plotly.express as px from plotly.offline import init_notebook_mode import pyarrow as pa init_notebook_mode(connected=True) %matplotlib inline vp_df = pokemon_df[['HP', 'Attack', 'Defense', 'Speed']].copy() vp_df.head() 
    \n---------------------------------------------------------------------------\nModuleNotFoundError                       Traceback (most recent call last)\nCell In[3], line 7\n      5 import plotly.express as px\n      6 from plotly.offline import init_notebook_mode\n----> 7 import pyarrow as pa\n      9 init_notebook_mode(connected=True)\n     10 get_ipython().run_line_magic('matplotlib', 'inline')\n\nModuleNotFoundError: No module named 'pyarrow'
    In\u00a0[\u00a0]: Copied! 
    from IPython.display import display, Markdown\ndisplay(pd.DataFrame({\n    'N Total':vp_df.shape[0],\n    'N Valid':vp_df.count(numeric_only=True),\n    'N Missing':vp_df.loc[:,vp_df.apply(pd.api.types.is_numeric_dtype)].isnull().sum(),\n    'Mean':vp_df.mean(numeric_only=True),\n    'Median':vp_df.median(numeric_only=True),\n    'Mode':vp_df.mode(numeric_only=True).iloc[0],\n    'Sum':vp_df.sum(numeric_only=True),\n    'Minimun':vp_df.min(numeric_only=True),\n    'Maximum':vp_df.max(numeric_only=True),\n    'Range':vp_df.max(numeric_only=True) - vp_df.min(numeric_only=True),\n    'Std. deviation':vp_df.std(numeric_only=True),\n    'S.E. mean':vp_df.std(numeric_only=True)/np.sqrt(vp_df.count(numeric_only=True)),\n    'Skewness':vp_df.skew(numeric_only=True),\n    'Kurtosis':vp_df.kurtosis(numeric_only=True),\n    'Percentile: 25':vp_df.quantile(q=0.25, numeric_only=True),\n    'Percentile: 50':vp_df.quantile(q=0.50, numeric_only=True),\n    'Percentile: 75':vp_df.quantile(q=0.75, numeric_only=True),\n}).round(3).T)\n
    from IPython.display import display, Markdown display(pd.DataFrame({ 'N Total':vp_df.shape[0], 'N Valid':vp_df.count(numeric_only=True), 'N Missing':vp_df.loc[:,vp_df.apply(pd.api.types.is_numeric_dtype)].isnull().sum(), 'Mean':vp_df.mean(numeric_only=True), 'Median':vp_df.median(numeric_only=True), 'Mode':vp_df.mode(numeric_only=True).iloc[0], 'Sum':vp_df.sum(numeric_only=True), 'Minimun':vp_df.min(numeric_only=True), 'Maximum':vp_df.max(numeric_only=True), 'Range':vp_df.max(numeric_only=True) - vp_df.min(numeric_only=True), 'Std. deviation':vp_df.std(numeric_only=True), 'S.E. mean':vp_df.std(numeric_only=True)/np.sqrt(vp_df.count(numeric_only=True)), 'Skewness':vp_df.skew(numeric_only=True), 'Kurtosis':vp_df.kurtosis(numeric_only=True), 'Percentile: 25':vp_df.quantile(q=0.25, numeric_only=True), 'Percentile: 50':vp_df.quantile(q=0.50, numeric_only=True), 'Percentile: 75':vp_df.quantile(q=0.75, numeric_only=True), }).round(3).T) In\u00a0[\u00a0]: Copied! 
    for col in vp_df.columns:\n    if pd.api.types.is_numeric_dtype(vp_df[col]) and  vp_df[col].value_counts().size > 10:\n        _bins = 10\n    else: _bins = None\n        \n    _dfr = pd.DataFrame({\n              'Frequency':vp_df[col].value_counts(bins=_bins, sort=False),\n              'Percent':100*(vp_df[col].value_counts(bins=_bins, sort=False) / vp_df[col].size),\n              'Valid percent':100*(vp_df[col].value_counts(bins=_bins, sort=False)/vp_df[col].count())\n}).round(2)\n    _dfr['Cumulative percent'] = _dfr['Valid percent'].cumsum()\n    _dfr.loc['N Valid',:] =  _dfr.iloc[:,:3].sum()\n    _dfr.loc['N Missing','Frequency'] =  vp_df[col].isnull().sum()\n    _dfr.loc['N Total','Frequency'] =  vp_df[col].size\n    display(Markdown(f\"### {col}\"))\n    display(_dfr)\n
    for col in vp_df.columns: if pd.api.types.is_numeric_dtype(vp_df[col]) and vp_df[col].value_counts().size > 10: _bins = 10 else: _bins = None _dfr = pd.DataFrame({ 'Frequency':vp_df[col].value_counts(bins=_bins, sort=False), 'Percent':100*(vp_df[col].value_counts(bins=_bins, sort=False) / vp_df[col].size), 'Valid percent':100*(vp_df[col].value_counts(bins=_bins, sort=False)/vp_df[col].count()) }).round(2) _dfr['Cumulative percent'] = _dfr['Valid percent'].cumsum() _dfr.loc['N Valid',:] = _dfr.iloc[:,:3].sum() _dfr.loc['N Missing','Frequency'] = vp_df[col].isnull().sum() _dfr.loc['N Total','Frequency'] = vp_df[col].size display(Markdown(f\"### {col}\")) display(_dfr) In\u00a0[\u00a0]: Copied! 
    import seaborn as sns\nimport warnings\nwith warnings.catch_warnings():\n    warnings.simplefilter(action='ignore', category=Warning)\n\n    display(Markdown(\"### Histogramme\"))\n    idx = 1\n    for col in vp_df.columns:\n        plt.subplot(2,2, idx)\n        if pd.api.types.is_numeric_dtype(vp_df[col]) and  vp_df[col].value_counts().size > 10:\n            sns.histplot(data=vp_df, x=col, kde=True)\n        else:\n            sns.countplot(data=vp_df, x=col)\n        \n        if idx < 4:\n            idx += 1\n        else:\n            idx = 1\n            plt.tight_layout()\n            plt.show()\n        \n    display(Markdown(\"### Matrice de dispersion\"))\n    pd.plotting.scatter_matrix(vp_df, marker='o', hist_kwds={'bins': 30}, s=30, alpha=.8)\n    plt.show()\n\n    display(Markdown(\"### Bo\u00eete \u00e0 moustaches\"))\n    sns.boxplot(vp_df)\n    plt.show()\n
    import seaborn as sns import warnings with warnings.catch_warnings(): warnings.simplefilter(action='ignore', category=Warning) display(Markdown(\"### Histogramme\")) idx = 1 for col in vp_df.columns: plt.subplot(2,2, idx) if pd.api.types.is_numeric_dtype(vp_df[col]) and vp_df[col].value_counts().size > 10: sns.histplot(data=vp_df, x=col, kde=True) else: sns.countplot(data=vp_df, x=col) if idx < 4: idx += 1 else: idx = 1 plt.tight_layout() plt.show() display(Markdown(\"### Matrice de dispersion\")) pd.plotting.scatter_matrix(vp_df, marker='o', hist_kwds={'bins': 30}, s=30, alpha=.8) plt.show() display(Markdown(\"### Bo\u00eete \u00e0 moustaches\")) sns.boxplot(vp_df) plt.show() In\u00a0[\u00a0]: Copied! 
    sns.scatterplot(data=pokemon_df, x='HP', y='Defense', hue='Attack', color='#d6d6d6')\nplt.legend(loc='upper right')\nplt.title('Pokemon')\nplt.xlabel('HP')\nplt.ylabel('Defense')\nplt.show()\n
    sns.scatterplot(data=pokemon_df, x='HP', y='Defense', hue='Attack', color='#d6d6d6') plt.legend(loc='upper right') plt.title('Pokemon') plt.xlabel('HP') plt.ylabel('Defense') plt.show()

    Renforcez votre parcours d'apprentissage Python avec Visual Python, en r\u00e9duisant les obstacles \u00e0 l'analyse et \u00e0 la visualisation des donn\u00e9es, en particulier pour ceux qui sont habitu\u00e9s \u00e0 Excel, Power BI et SAS dans le domaine des organisations statistiques nationales du gouvernement.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#visual-python-simplifier-lanalyse-des-donnees-pour-les-apprenants-python","title":"Visual Python:\u00a0simplifier l'analyse des donn\u00e9es pour les apprenants Python\u00b6","text":"

    Visual Python appara\u00eet comme un g\u00e9n\u00e9rateur de code Python intuitif bas\u00e9 sur une interface graphique, parfaitement int\u00e9gr\u00e9 \u00e0 Jupyter Lab, Jupyter Notebook et Google Colab. De plus, les utilisateurs peuvent opter pour le Visual Python Desktop autonome. Ce projet open source a \u00e9t\u00e9 lanc\u00e9 pour aider les \u00e9tudiants \u00e0 naviguer dans les cours Python pour la science des donn\u00e9es, en offrant une approche rationalis\u00e9e du codage.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#avantages-cles","title":"Avantages cl\u00e9s:\u00b6","text":"
    • Gestion des donn\u00e9es avec un codage minimal: Visual Python facilite la gestion de grands ensembles de donn\u00e9es avec un minimum de comp\u00e9tences en codage, ce qui en fait un outil id\u00e9al pour les d\u00e9butants.
    • Surmonter les barri\u00e8res d'apprentissage: Con\u00e7u pour les \u00e9tudiants, les analystes commerciaux et les chercheurs, Visual Python aide \u00e0 surmonter les barri\u00e8res d'apprentissage associ\u00e9es \u00e0 la programmation Python.
    • Gestion des extraits de code: Enregistrez et r\u00e9utilisez sans effort les extraits de code fr\u00e9quemment utilis\u00e9s.
    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour exploiter la puissance de Visual Python, installez les packages requis \u00e0 l'aide de la commande suivante:

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#exemple-avec-lensemble-de-donnees-pokemon","title":"Exemple avec l'ensemble de donn\u00e9es Pok\u00e9mon:\u00b6","text":"

    Explorons les capacit\u00e9s de Visual Python \u00e0 l'aide de l'ensemble de donn\u00e9es Pok\u00e9mon. Cet exemple montre comment Visual Python g\u00e9n\u00e8re du code pour un nuage de mots, fournissant une repr\u00e9sentation visuelle sans avoir besoin de m\u00e9moriser la syntaxe complexe de matplotlib.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#statistiques-descriptives-et-visualisation","title":"Statistiques descriptives et visualisation:\u00b6","text":"

    Visual Python \u00e9tend ses capacit\u00e9s aux statistiques descriptives et \u00e0 la visualisation de donn\u00e9es. L'extrait de code ci-dessous montre comment Visual Python simplifie le processus, en g\u00e9n\u00e9rant des graphiques et des statistiques avec un minimum d'effort.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#statistiques-descriptives","title":"Statistiques descriptives\u00b6","text":""},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#tableau-des-frequences","title":"Tableau des fr\u00e9quences\u00b6","text":""},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#graphiques","title":"Graphiques\u00b6","text":""},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#visualisation-seaborn-avec-visual-python","title":"Visualisation Seaborn avec Visual Python:\u00b6","text":"

    Visual Python simplifie la cr\u00e9ation de cartes Seaborn. Pas besoin de fouiller dans la documentation; Visual Python fonctionne comme un syst\u00e8me de mod\u00e8les, g\u00e9n\u00e9rant du code pouvant \u00eatre facilement modifi\u00e9.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html","title":"Profilage YData: rationalisation de l'analyse des donn\u00e9es","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -r requirements.txt\n! pip install -U ydata-profiling ipywidgets scikit-learn\n
    %%capture ! pip install -r requirements.txt ! pip install -U ydata-profiling ipywidgets scikit-learn In\u00a0[\u00a0]: Copied! 
    import numpy as np\nimport pandas as pd\n\nfrom ydata_profiling import ProfileReport\nfrom ydata_profiling.utils.cache import cache_file\n\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\n\nprofile_report = ProfileReport(\n    pokemon_df,\n    sort=None,\n    html={\n        \"style\": {\"full_width\": True}\n    }, \n    progress_bar=False,\n    correlations={\n        \"auto\": {\"calculate\": True},\n        \"pearson\": {\"calculate\": False},\n        \"spearman\": {\"calculate\": False},\n        \"kendall\": {\"calculate\": False},\n        \"phi_k\": {\"calculate\": True},\n        \"cramers\": {\"calculate\": True},\n    },\n    explorative=True,\n    title=\"Profiling Report\"\n)\n\nprofile_report.to_file(\"../output/pokemon.html\")\n\nprofile_report\n
    import numpy as np import pandas as pd from ydata_profiling import ProfileReport from ydata_profiling.utils.cache import cache_file file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) profile_report = ProfileReport( pokemon_df, sort=None, html={ \"style\": {\"full_width\": True} }, progress_bar=False, correlations={ \"auto\": {\"calculate\": True}, \"pearson\": {\"calculate\": False}, \"spearman\": {\"calculate\": False}, \"kendall\": {\"calculate\": False}, \"phi_k\": {\"calculate\": True}, \"cramers\": {\"calculate\": True}, }, explorative=True, title=\"Profiling Report\" ) profile_report.to_file(\"../output/pokemon.html\") profile_report In\u00a0[\u00a0]: Copied! 
    import numpy as np\nfrom sklearn.model_selection import train_test_split\n\nfrom ydata_profiling import ProfileReport\n\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\n\nX = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']]\ny = pokemon_df[['Type 1', 'Type 2']]\n\nX_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.33, random_state=42)\n\ntrain_df = X_train\ntrain_report = ProfileReport(train_df, title=\"Train\")\n\ntest_df = X_test\ntest_report = ProfileReport(test_df, title=\"Test\")\n\ncomparison_report = train_report.compare(test_report)\ncomparison_report.to_file(\"../output/comparison.html\")\n\ncomparison_report\n
    import numpy as np from sklearn.model_selection import train_test_split from ydata_profiling import ProfileReport file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) X = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']] y = pokemon_df[['Type 1', 'Type 2']] X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42) train_df = X_train train_report = ProfileReport(train_df, title=\"Train\") test_df = X_test test_report = ProfileReport(test_df, title=\"Test\") comparison_report = train_report.compare(test_report) comparison_report.to_file(\"../output/comparison.html\") comparison_report In\u00a0[\u00a0]: Copied! 
    import numpy as np\nimport pandas as pd\nfrom ydata_profiling import ProfileReport\nfrom ydata_profiling.utils.cache import cache_file\n\nfile_name = cache_file(\n    \"msft.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/msft.csv\"\n)\n\nmsft_df = pd.read_csv(file_name)\nmsft_df[\"Date\"] = pd.to_datetime(msft_df[\"Date\"])\n\n# Enable tsmode to True to automatically identify time-series variables\n# Provide the column name that provides the chronological order of your time-series\nprofile = ProfileReport(msft_df, tsmode=True, sortby=\"Date\", title=\"Time-Series EDA\")\n\nprofile.to_file(\"../output/msft-report-timeseries.html\")\n\nprofile\n
    import numpy as np import pandas as pd from ydata_profiling import ProfileReport from ydata_profiling.utils.cache import cache_file file_name = cache_file( \"msft.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/msft.csv\" ) msft_df = pd.read_csv(file_name) msft_df[\"Date\"] = pd.to_datetime(msft_df[\"Date\"]) # Enable tsmode to True to automatically identify time-series variables # Provide the column name that provides the chronological order of your time-series profile = ProfileReport(msft_df, tsmode=True, sortby=\"Date\", title=\"Time-Series EDA\") profile.to_file(\"../output/msft-report-timeseries.html\") profile

    Explorez les capacit\u00e9s de YData Profiling et transformez votre flux de travail d'analyse de donn\u00e9es en une exp\u00e9rience transparente et compl\u00e8te, align\u00e9e sur la familiarit\u00e9 d'Excel, Power BI et SAS.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#profilage-ydata-rationalisation-de-lanalyse-des-donnees","title":"Profilage YData: rationalisation de l'analyse des donn\u00e9es\u00b6","text":"

    YData Profiling se pr\u00e9sente comme un outil puissant con\u00e7u pour simplifier et am\u00e9liorer l'exp\u00e9rience d'exploration des donn\u00e9es, r\u00e9pondant sp\u00e9cifiquement aux besoins des statisticiens et des data scientists. En mettant l'accent sur la fourniture d'une solution d'analyse exploratoire des donn\u00e9es (EDA) en une seule ligne, YData Profiling fournit une analyse \u00e9tendue de votre DataFrame, semblable \u00e0 la commodit\u00e9 offerte par la fonction df.describe() de pandas. Cette analyse peut \u00eatre export\u00e9e de mani\u00e8re transparente dans diff\u00e9rents formats tels que HTML et JSON.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#demarrage-rapide","title":"D\u00e9marrage rapide:\u00b6","text":"

    D\u00e9marrer avec YData Profiling est simple. Commencez par installer la biblioth\u00e8que \u00e0 l'aide de l'une des commandes suivantes:

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#principales-caracteristiques","title":"Principales caract\u00e9ristiques:\u00b6","text":"
    • Inf\u00e9rence de type: D\u00e9tecte automatiquement les types de donn\u00e9es des colonnes, notamment cat\u00e9goriques, num\u00e9riques, date, etc.
    • Avertissements: R\u00e9sume les probl\u00e8mes potentiels de qualit\u00e9 des donn\u00e9es tels que les donn\u00e9es manquantes, les inexactitudes, l'asym\u00e9trie, etc.
    • Analyse univari\u00e9e: Fournit des statistiques descriptives et des visualisations informatives telles que des histogrammes de distribution.
    • Analyse multivari\u00e9e: Comprend des corr\u00e9lations, une analyse d\u00e9taill\u00e9e des donn\u00e9es manquantes, des lignes en double et une prise en charge visuelle des interactions par paires.
    • Analyse des s\u00e9ries chronologiques: Offre des informations statistiques relatives aux donn\u00e9es d\u00e9pendantes du temps, ainsi que des informations sur l'autocorr\u00e9lation et la saisonnalit\u00e9.
    • Analyse de texte et de fichiers: Comprend la d\u00e9tection de cat\u00e9gories de texte et l'analyse de fichiers/images pour une exploration compl\u00e8te.
    • Comparaison d'ensembles de donn\u00e9es: Permet d'obtenir un rapport rapide et complet sur la comparaison d'ensembles de donn\u00e9es avec une seule ligne de code.
    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#exemple-de-code","title":"Exemple de code:\u00b6","text":"

    Pour une d\u00e9monstration pratique, consid\u00e9rons l'exemple suivant g\u00e9n\u00e9rant un rapport standard pour un ensemble de donn\u00e9es Pok\u00e9mon:

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#generation-dun-rapport-standard","title":"G\u00e9n\u00e9ration d'un rapport standard\u00b6","text":"

    Cette cellule contient un script pour r\u00e9cup\u00e9rer un ensemble de donn\u00e9es Pok\u00e9mon et afficher le \u00ab ProfileReport \u00bb par d\u00e9faut \u00e0 partir de \u00ab ydata_profiling \u00bb. Le rapport comprend des calculs de corr\u00e9lation suppl\u00e9mentaires (voir ligne 23 ci-dessous). La ligne 34 profile_report.to_file(\"pokemon.html\") enregistre le rapport dans un fichier HTML que vous pouvez ouvrir dans un nouvel onglet de navigateur.

    Cliquez ici pour voir le r\u00e9sultat.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#comparaison-densembles-de-donnees","title":"Comparaison d'ensembles de donn\u00e9es\u00b6","text":"

    Nous pouvons \u00e9galement g\u00e9n\u00e9rer des rapports comparant deux ensembles de donn\u00e9es. Cet exemple ci-dessous compare les ensembles de donn\u00e9es d'entra\u00eenement et de test Pok\u00e9mon. train_test_split de scikit-learn est utilis\u00e9 pour cr\u00e9er les ensembles de donn\u00e9es d'entra\u00eenement et de test.

    Cliquez ici pour voir le r\u00e9sultat.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#analyse-des-donnees-de-series-chronologiques","title":"Analyse des donn\u00e9es de s\u00e9ries chronologiques:\u00b6","text":"

    Pour les ensembles de donn\u00e9es de s\u00e9ries chronologiques, YData Profiling introduit un mode de s\u00e9rie chronologique sp\u00e9cialis\u00e9, comme l'illustre l'analyse du cours de l'action Microsoft:

    Cliquez ici pour voir le r\u00e9sultat.

    "},{"location":"2-Publication/Dash.html","title":"Aper\u00e7u","text":"

    Dash est un excellent outil utilis\u00e9 par beaucoup pour l'analyse et l'exploration de donn\u00e9es, la visualisation, la mod\u00e9lisation, le contr\u00f4le des instruments et la cr\u00e9ation de rapports.

    L'exemple suivant illustre une application Dash hautement r\u00e9active et personnalis\u00e9e avec peu de code.

    Ex\u00e9cution de votre serveur bloc-note et acc\u00e8s au port

    Lorsque vous ex\u00e9cutez un outil de votre bloc-note Jupyter qui publie un site Web sur un port, vous ne pourrez pas simplement y acc\u00e9der depuis http://localhost:5000/ car normalement sugg\u00e9r\u00e9 dans la sortie lors de l'ex\u00e9cution de l'application Web.

    Pour acc\u00e9der au serveur Web, vous devrez utiliser l'URL de base. Dans ton cahier ex\u00e9cution terminale\u00a0:

    echo https://kubeflow.covid.cloud.statcan.ca${JUPYTER_SERVER_URL:19}proxy/5000/\n
    "},{"location":"2-Publication/Dash.html#visualisation-des-donnees-avec-dash","title":"Visualisation des donn\u00e9es avec Dash","text":"

    Dash simplifie la cr\u00e9ation d'une interface graphique interactive autour de votre code d'analyse de donn\u00e9es. Ceci est un exemple de mise en page avec figure et curseur de Dash.

    "},{"location":"2-Publication/Dash.html#plotly-dash","title":"Plotly Dash","text":"

    Publier avec des logiciels fabriqu\u00e9s au Canada.

    Plotly Dash est une biblioth\u00e8que Python populaire qui vous permet de cr\u00e9er facilement des visualisations et des tableaux de bord Web interactifs. D\u00e9velopp\u00e9 par la soci\u00e9t\u00e9 montr\u00e9alaise Plotly, Dash a acquis la r\u00e9putation d'\u00eatre un outil puissant et flexible pour cr\u00e9er des graphiques de science des donn\u00e9es personnalis\u00e9s. Avec Dash, vous pouvez tout cr\u00e9er, des simples graphiques lin\u00e9aires aux tableaux de bord complexes de plusieurs pages avec des widgets et des commandes interactifs. Parce qu'il repose sur des technologies open source telles que Flask, React et Plotly.js, Dash est hautement personnalisable et peut \u00eatre facilement int\u00e9gr\u00e9 \u00e0 d'autres outils et workflows de science des donn\u00e9es. Que vous soyez data scientist, analyste ou d\u00e9veloppeur, Dash peut vous aider \u00e0 cr\u00e9er des visualisations attrayantes et informatives qui donnent vie \u00e0 vos donn\u00e9es.

    "},{"location":"2-Publication/Dash.html#commencer","title":"Commencer","text":"

    Ouvrez une fen\u00eatre de terminal dans votre bloc-note Jupyter et ex\u00e9cutez les commandes suivantes\u00a0:

    #\u00a0installations requises si elles ne sont pas d\u00e9j\u00e0 install\u00e9es\npip3 install dash==1.16.3\npip3 install pandas\n

    Cr\u00e9ez un fichier appel\u00e9 app.py avec le contenu suivant\u00a0:

    # app.py\n\n#!/usr/bin/env python3\n\nimport dash\nimport dash_core_components as dcc\nimport dash_html_components as html\nfrom dash.dependencies import Input, Output\nimport plotly.express as px\n\nimport pandas as pd\n\ndf = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminderDataFiveYear.csv')\n\nexternal_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n\napp = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n\napp.layout = html.Div([\n    dcc.Graph(id='graph-with-slider'),\n    dcc.Slider(\n        id='year-slider',\n        min=df['year'].min(),\n        max=df['year'].max(),\n        value=df['year'].min(),\n        marks={str(year): str(year) for year in df['year'].unique()},\n        step=None\n    )\n])\n\n@app.callback(\n    Output('graph-with-slider', 'figure'),\n    [Input('year-slider', 'value')])\ndef update_figure(selected_year):\n    filtered_df = df[df.year == selected_year]\n\n    fig = px.scatter(filtered_df, x=\"gdpPercap\", y=\"lifeExp\",\n                     size=\"pop\", color=\"continent\", hover_name=\"country\",\n                     log_x=True, size_max=55)\n\n    fig.update_layout(transition_duration=500)\n\n    return fig\n\nif __name__ == '__main__':\n    app.run_server(debug=True)\n
    "},{"location":"2-Publication/Dash.html#executez-votre-application","title":"Ex\u00e9cutez votre application","text":"
    python app.py\n\n# ou vous pouvez utiliser\u00a0:\n\nexport FLASK_APP=app.py\nflask run\n
    "},{"location":"2-Publication/Datasette.html","title":"Aper\u00e7u","text":"

    Datasette est une API JSON instantan\u00e9e pour vos bases de donn\u00e9es SQLite qui permet d'explorer la BD et d'ex\u00e9cuter des requ\u00eates SQL de mani\u00e8re plus interactive.

    Vous pouvez trouver une liste d'exemples de datasettes ici.

    \u00c9cosyst\u00e8me de Datasette

    Il existe toutes sortes d'outils pour convertir des donn\u00e9es depuis et vers sqlite. ici. Par exemple, vous pouvez charger des fichiers de forme dans sqlite, ou cr\u00e9er des graphes Vega \u00e0 partir d'une base de donn\u00e9es sqlite. SQLite fonctionne bien avec R, Python, et plusieurs autres outils.

    "},{"location":"2-Publication/Datasette.html#exemple-datasette","title":"Exemple Datasette","text":"

    Voici quelques captures d'\u00e9cran du Datasette global-power-plants, vous pouvez pr\u00e9visualiser et explorer les donn\u00e9es dans le navigateur, que ce soit par des clics ou des requ\u00eates SQL.

    Vous pouvez m\u00eame explorer des cartes au sein de l'outil!

    "},{"location":"2-Publication/Datasette.html#commencer","title":"Commencer","text":""},{"location":"2-Publication/Datasette.html#installation-de-datasette","title":"Installation de Datasette","text":"

    Dans votre bloc-notes Jupyter, ouvrez une fen\u00eatre de terminal et ex\u00e9cutez la commande pip3 install datasette.

    "},{"location":"2-Publication/Datasette.html#demarrage-de-datasette","title":"D\u00e9marrage de Datasette","text":"

    Pour afficher votre propre base de donn\u00e9es dans votre bloc-notes Jupyter, cr\u00e9ez un fichier appel\u00e9 start.sh dans le r\u00e9pertoire de votre projet et copiez-y le code ci-dessous. Rendez le fichier ex\u00e9cutable en utilisant chmod +x start.sh. Ex\u00e9cutez le fichier avec ./start.sh. Acc\u00e9dez au serveur Web \u00e0 l'aide de l'URL de base avec le num\u00e9ro de port que vous utilisez dans le fichier ci-dessous.

    start.sh

    #!/bin/bash\n\n# This script just starts Datasette with the correct URL, so\n# that you can use it within kubeflow.\n\n# Get an example database\nwget https://github.com/StatCan/aaw-contrib-r-notebooks/raw/master/database-connections/latin_phrases.db\n\n# If you have your own database, you can change this line!\nDATABASE=latin_phrases.db\n\nexport BASE_URL=\"https://kubeflow.covid.cloud.statcan.ca${JUPYTER_SERVER_URL:19}proxy/8001/\"\necho \"Base url: ${BASE_URL}\"\ndatasette $DATABASE --cors --config max_returned_rows:100000 --config sql_time_limit_ms:5500 --config base_url:${BASE_URL}\n

    Regardez ce tutoriel

    Un utilisateur de la plateforme a utilis\u00e9 Datasette avec un tableau de bord. Voir la vid\u00e9o pour une d\u00e9monstration.

    Ex\u00e9cuter le serveur de votre bloc-notes et acc\u00e9der au port

    Lorsque vous ex\u00e9cutez un outil depuis votre bloc-notes Jupyter qui affiche un site web sur un port, vous ne serez pas en mesure d'y acc\u00e9der simplement \u00e0 partir de http://localhost:5000/ comme normalement sugg\u00e9r\u00e9 dans la sortie lors de l'ex\u00e9cution de l'application web.

    Pour acc\u00e9der au serveur web, vous devrez utiliser l'URL de base. Dans le terminal du bloc-note, ex\u00e9cutez:

    echo https://kubeflow.covid.cloud.statcan.ca${JUPYTER_SERVER_URL:19}proxy/5000/\n
    "},{"location":"2-Publication/Overview.html","title":"Overview","text":""},{"location":"2-Publication/Overview.html#publication-statistique","title":"Publication statistique","text":"

    De beaux graphiques sont importants dans la publication statistique car ils rendent les donn\u00e9es plus accessibles et compr\u00e9hensibles pour un public plus large.

    La publication est un aspect essentiel de la science des donn\u00e9es et des statistiques. Il permet aux chercheurs de partager leurs d\u00e9couvertes avec la communaut\u00e9 scientifique au sens large, permettant ainsi \u00e0 d\u2019autres de s\u2019appuyer sur leurs travaux et de faire avancer le domaine. En partageant ouvertement leurs donn\u00e9es et leurs m\u00e9thodes, les chercheurs peuvent recevoir des commentaires sur leurs travaux et garantir que leurs r\u00e9sultats sont pr\u00e9cis et fiables.

    La publication permet aux chercheurs d\u2019\u00e9tablir leur r\u00e9putation et d\u2019obtenir la reconnaissance de leurs travaux, ce qui peut contribuer \u00e0 obtenir des financements et de futures opportunit\u00e9s de recherche. En outre, la publication des r\u00e9sultats de la recherche peut avoir des implications importantes sur les politiques publiques et la prise de d\u00e9cision, dans la mesure o\u00f9 les d\u00e9cideurs s\u2019appuient souvent sur des preuves scientifiques pour prendre des d\u00e9cisions \u00e9clair\u00e9es. Dans l\u2019ensemble, la publication fait partie int\u00e9grante du processus scientifique et joue un r\u00f4le essentiel dans l\u2019avancement des connaissances et la r\u00e9solution de probl\u00e8mes du monde r\u00e9el.

    La publication statistique consiste \u00e0 communiquer des informations statistiques \u00e0 un public plus large en utilisant diverses formes de m\u00e9dias, tels que des tableaux, des graphiques et des infographies. Avoir de beaux graphiques est important dans la publication statistique car cela rend les donn\u00e9es plus accessibles et compr\u00e9hensibles pour un public plus large. Des visualisations bien con\u00e7ues peuvent aider \u00e0 communiquer des concepts et des mod\u00e8les statistiques complexes de mani\u00e8re claire et convaincante, permettant au public de saisir rapidement les principales informations et conclusions.

    De superbes graphiques peuvent am\u00e9liorer l\u2019impact global des publications statistiques, les rendant plus attrayantes et m\u00e9morables. Cela peut \u00eatre particuli\u00e8rement important lors de la communication d'informations importantes aux d\u00e9cideurs, aux parties prenantes ou au grand public, o\u00f9 la capacit\u00e9 de communiquer clairement et efficacement des informations bas\u00e9es sur les donn\u00e9es peut \u00eatre essentielle pour r\u00e9ussir.

    En r\u00e9sum\u00e9, la science des donn\u00e9es et la publication statistique sont essentielles pour transformer des donn\u00e9es complexes en informations significatives, et disposer de superbes graphiques est un aspect crucial pour communiquer efficacement ces informations \u00e0 un public plus large.

    "},{"location":"2-Publication/PowerBI.html","title":"Aper\u00e7u","text":""},{"location":"2-Publication/PowerBI.html#chargement-des-donnees-dans-power-bi","title":"Chargement des donn\u00e9es dans Power BI","text":"

    Nous ne proposons pas de serveur Power BI, mais vous pouvez extraire vos donn\u00e9es dans Power BI \u00e0 partir de notre syst\u00e8me de stockage et les utiliser comme une trame de donn\u00e9es pandas.

    "},{"location":"2-Publication/PowerBI.html#installation","title":"Installation","text":""},{"location":"2-Publication/PowerBI.html#ce-dont-vous-aurez-besoin","title":"Ce dont vous aurez besoin","text":"
    1. Un ordinateur avec Power BI et Python 3.6
    2. Vos ACCESS_KEY et SECRET_KEY MinIO (voir Stockage)
    "},{"location":"2-Publication/PowerBI.html#configurez-power-bi","title":"Configurez Power BI","text":"

    Ouvrez votre syst\u00e8me Power BI et ouvrez d\u00e9marrage rapide de Power BI dans votre \u00e9diteur de texte pr\u00e9f\u00e9r\u00e9.

    Assurez-vous que pandas, boto3 et numpy sont install\u00e9s et que vous utilisez le bon environnement virtuel Conda (le cas \u00e9ch\u00e9ant).

    Ensuite, assurez-vous que Power BI utilise le bon environnement Python. Vous pouvez modifier cet \u00e9l\u00e9ment \u00e0 partir du menu des options. Le chemin d'acc\u00e8s exact est indiqu\u00e9 dans le guide de d\u00e9marrage rapide.

    "},{"location":"2-Publication/PowerBI.html#modifiez-votre-script-python","title":"Modifiez votre script Python","text":"

    Ensuite, modifiez votre script Python pour utiliser vos ACCESS_KEY et SECRET_KEY MinIO, puis cliquez sur \u00ab Obtenir des donn\u00e9es \u00bb et copiez-le en tant que script Python.

    "},{"location":"2-Publication/R-Shiny.html","title":"Aper\u00e7u","text":"

    R-Shiny est un package R qui facilite la cr\u00e9ation d'applications Web interactives dans R.

    H\u00e9bergement d'applications R Shiny

    Nous ne prenons actuellement pas en charge l'h\u00e9bergement d'applications R Shiny, mais vous pouvez les cr\u00e9er. Nous souhaitons activer l'h\u00e9bergement de l'application R Shiny \u00e0 l'avenir.

    "},{"location":"2-Publication/R-Shiny.html#r-shiny","title":"R Shiny","text":"

    Publier des graphismes de qualit\u00e9 professionnelle

    R Shiny est un framework d'application Web open source qui permet aux scientifiques de donn\u00e9es et aux analystes de cr\u00e9er des tableaux de bord et des visualisations de donn\u00e9es interactifs bas\u00e9s sur le Web \u00e0 l'aide du langage de programmation R. L'un des principaux avantages de R Shiny est qu'il offre un moyen simple de cr\u00e9er des tableaux de bord interactifs de haute qualit\u00e9 sans avoir besoin d'une expertise approfondie en d\u00e9veloppement Web. Avec R Shiny, les scientifiques de donn\u00e9es peuvent tirer parti de leurs comp\u00e9tences en codage R pour cr\u00e9er des applications Web dynamiques, bas\u00e9es sur les donn\u00e9es, qui peuvent \u00eatre facilement partag\u00e9es avec les acteurs.

    Un autre avantage de R Shiny est qu'il prend en charge une vari\u00e9t\u00e9 de visualisations de donn\u00e9es qui peuvent \u00eatre facilement personnalis\u00e9es pour r\u00e9pondre aux besoins du projet. Les utilisateurs peuvent cr\u00e9er une large gamme de diagrammes et de graphiques, allant de simples diagrammes \u00e0 barres et nuages de points \u00e0 des cartes thermiques et des graphiques de r\u00e9seau plus complexes. De plus, R Shiny prend en charge une vari\u00e9t\u00e9 de widgets interactifs qui permettent aux utilisateurs de manipuler et d'explorer des donn\u00e9es en temps r\u00e9el.

    R Shiny est \u00e9galement hautement extensible et peut \u00eatre int\u00e9gr\u00e9 \u00e0 d'autres outils et plates-formes open source pour cr\u00e9er des workflows de science des donn\u00e9es de bout en bout. Avec ses fonctionnalit\u00e9s puissantes et flexibles, R Shiny est un choix populaire pour cr\u00e9er des tableaux de bord de visualisation de donn\u00e9es pour un large \u00e9ventail d'applications, de la recherche scientifique \u00e0 l'analyse commerciale. Dans l'ensemble, R Shiny offre une solution puissante, personnalisable et rentable pour cr\u00e9er des tableaux de bord interactifs et des visualisations de donn\u00e9es.

    Utilisez R-Shiny pour cr\u00e9er des applications Web interactives directement \u00e0 partir de R. Vous pouvez d\u00e9ployer votre tableau de bord R Shiny en soumettant une demande d'extraction \u00e0 notre R\u00e9f\u00e9rentiel R-Dashboards GitHub .

    "},{"location":"2-Publication/R-Shiny.html#editeur-dinterface-utilisateur-r-shiny","title":"\u00c9diteur d'interface utilisateur R Shiny","text":"

    Le script Rscript suivant installe les packages requis pour ex\u00e9cuter \"shinyuieditor\" sur l'ETAA. Il commence par installer les packages R n\u00e9cessaires et utilise conda pour installer yarn.

    Une fois l'installation termin\u00e9e, vous pouvez acc\u00e9der au code de votre application dans ./my-app

    Ex\u00e9cutez ce script depuis rstudio. RStudio peut demander la permission d'ouvrir une nouvelle fen\u00eatre si vous avez un bloqueur de popup.

    setup-shinyuieditor.R
    #!/usr/bin/env Rscript\n\n#' Installer les packages n\u00e9cessaires\ninstall.packages(c(\n  \"shiny\",\n  \"plotly\",\n  \"gridlayout\",\n  \"bslib\",\n  \"remotes\",\n  \"rstudioapi\"\n))\n\n#' n'a pas \u00e9t\u00e9 install\u00e9 lors de l'installation ci-dessus\ninstall.packages(\"DT\")\n\n#' Cela installe shinyuieditor de Github\nremotes::install_github(\"rstudio/shinyuieditor\", upgrade = F)\n\n#' Nous avons besoin de fil donc nous allons l'installer avec conda\nsystem(\"conda install yarn\", wait = T)\n\n#' Ceci clone Shinyuieditor et un exemple d'application de Github\nsystem(\"git clone https://github.com/rstudio/shinyuieditor\", wait = T)\n\n#' Copiez l'application des vignettes vers notre r\u00e9pertoire de travail actuel\nsystem(\"cp -R ./shinyuieditor/vignettes/demo-app/ ./my-app\")\n\n#' D\u00e9finit le r\u00e9pertoire de travail actuel sur le r\u00e9pertoire racine de l'application\nsetwd(\"./my-app\")\n\n#' Yarn va mettre en place notre projet\nsystem(\"yarn install\", wait = T)\n\n#' Chargez et lancez shinyuieditor\nlibrary(shinyuieditor)\nshinyuieditor::launch_editor(app_loc = \"./\")\n
    "},{"location":"2-Publication/R-Shiny.html#choisissez-un-modele-dapplication","title":"Choisissez un mod\u00e8le d'application","text":"

    La premi\u00e8re chose que vous verrez est le s\u00e9lecteur de mod\u00e8le. Il existe trois options au moment d'\u00e9crire ces lignes (shinyuieditor est actuellement en alpha).

    "},{"location":"2-Publication/R-Shiny.html#mode-fichier-unique-ou-multi","title":"Mode fichier unique ou multi","text":"

    Je recommande le mode multi-fichiers, cela mettra le code back-end dans un fichier appel\u00e9 server.R et le front-end dans un fichier appel\u00e9 ui.R.

    "},{"location":"2-Publication/R-Shiny.html#concevez-votre-application","title":"Concevez votre application","text":"

    Vous pouvez concevoir votre application avec du code ou l'interface utilisateur graphique. Essayez de concevoir la mise en page avec l'interface graphique et de concevoir les trac\u00e9s avec du code.

    Toutes les modifications que vous apportez dans shinyuieditor appara\u00eetront imm\u00e9diatement dans le code.

    Toute modification que vous apportez au code appara\u00eetra imm\u00e9diatement dans le shinyuieditor.

    "},{"location":"2-Publication/R-Shiny.html#publication-sur-letaa","title":"Publication sur l'ETAA","text":""},{"location":"2-Publication/R-Shiny.html#envoyez-simplement-une-pull-request","title":"Envoyez simplement une pull request\u00a0!","text":"

    Tout ce que vous avez \u00e0 faire est d'envoyer une demande d'extraction \u00e0 notre r\u00e9f\u00e9rentiel R-Dashboards. Incluez votre r\u00e9f\u00e9rentiel dans un dossier avec le nom que vous voulez (par exemple, \"air-quality-dashboard\"). Ensuite, nous l'approuverons et il sera mis en ligne.

    Si vous avez besoin d'installer des biblioth\u00e8ques R suppl\u00e9mentaires, envoyez votre liste au d\u00e9p\u00f4t R-Shiny en cr\u00e9ant un probl\u00e8me GitHub et nous ajouterons les d\u00e9pendances.

    Voir le tableau de bord ci-dessus ici

    Le tableau de bord ci-dessus est dans GitHub. Jetez un \u0153il \u00e0 la source.

    "},{"location":"2-Publication/R-Shiny.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":""},{"location":"2-Publication/R-Shiny.html#integrer-des-tableaux-de-bord-dans-vos-sites-web","title":"Int\u00e9grer des tableaux de bord dans vos sites Web","text":"

    Int\u00e9grer des tableaux de bord dans d'autres sites

    Nous n'avons pas encore eu l'occasion de l'examiner ou de le prototyper, mais si vous avez un cas d'utilisation, n'h\u00e9sitez pas \u00e0 contacter l'ing\u00e9nierie. Nous travaillerons avec vous pour trouver quelque chose.

    "},{"location":"2-Publication/Sur-mesure.html","title":"Aper\u00e7u","text":""},{"location":"2-Publication/Sur-mesure.html#applications-web-personnalisees","title":"Applications Web personnalis\u00e9es","text":"

    Nous pouvons tout d\u00e9ployer, dans la mesure o\u00f9 il s'agit de logiciel libre, et nous pouvons le mettre dans un conteneur Docker (p. ex. applications Node.js, Flask, Dash).

    Voir le code de source de cette application

    Nous int\u00e9grons ces types d'applications au serveur au moyen de GitHub.

    "},{"location":"2-Publication/Sur-mesure.html#installation","title":"Installation","text":""},{"location":"2-Publication/Sur-mesure.html#comment-faire-heberger-votre-application","title":"Comment faire h\u00e9berger votre application","text":"

    Si vous avez d\u00e9j\u00e0 une application Web dans un r\u00e9pertoire Git, d\u00e8s qu'elle est plac\u00e9e dans un conteneur Docker, nous pouvons int\u00e9grer le r\u00e9pertoire Git dans le r\u00e9pertoire GitHub de StatCan et pointer une URL vers elle. Pour la mettre \u00e0 jour, il vous suffit d'interagir avec le r\u00e9pertoire GitHub de StatCan au moyen de demandes d'extraction.

    Si vous avez des questions, n'h\u00e9sitez pas \u00e0 communiquer avec nous.

    "},{"location":"3-Pipelines/Argo.html","title":"Argo","text":""},{"location":"3-Pipelines/Argo.html#flux-de-travail-argo","title":"Flux de travail Argo","text":"

    Flux de travail Argo est un moteur de flux de travail \u00e0 logiciel libre natif de conteneur pour orchestrer des t\u00e2ches parall\u00e8les sur Kubernetes. Les flux de travails Argo sont impl\u00e9ment\u00e9s en tant que Kubernetes CRD (Custom Resource Definition). Il est particuli\u00e8rement adapt\u00e9 aux flux de travail de science des donn\u00e9es et aux flux de travail d\u2019apprentissage automatique.

    La documentation compl\u00e8te peut \u00eatre trouv\u00e9e ici.

    Les flux de travails Argo ont les avantages suivants:

    • Les t\u00e2ches des flux de travail peuvent \u00eatre d\u00e9finies sous forme de scripts (ex. Python) ou \u00eatre conteneuris\u00e9es (ex. Docker).
    • Des flux de travail complexes peuvent \u00eatre mod\u00e9lis\u00e9s \u00e0 l'aide de graphes acycliques dirig\u00e9s (DAG) pour capturer les cha\u00eenes de d\u00e9pendance.
    • Les t\u00e2ches ind\u00e9pendantes peuvent \u00eatre ex\u00e9cut\u00e9es en parall\u00e8le avec une granularit\u00e9 jusqu'au niveau de mise en \u0153uvre, r\u00e9duisant ainsi les charges de t\u00e2ches chronophages.
    • Agnositique de la plateforme Kubernetes, ce qui signifie que votre travail est tr\u00e8s portable.

    Avec les flux de travails Argo, vous pouvez facilement cr\u00e9er des flux de travails qui int\u00e8grent des t\u00e2ches telles que des constructions et des d\u00e9ploiements automatis\u00e9s, le pr\u00e9traitement des donn\u00e9es, la formation de mod\u00e8les et le d\u00e9ploiement de mod\u00e8les, le tout dans un environnement Cloud Native Kubernetes.

    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\u00e8le d'apprentissage automatique \u00e0 l'aide des flux de travail Argo sur AAW.

    "},{"location":"3-Pipelines/Argo.html#1-ecrivez-un-script-pour-entrainer-votre-modele","title":"1. \u00c9crivez un script pour entra\u00eener votre mod\u00e8le","text":"

    Voici un exemple de script qui entra\u00eene un mod\u00e8le de r\u00e9gression logistique sur l'ensemble de donn\u00e9es iris. N'oubliez pas de consulter le code de chaque langue ci-dessous.

    PythonR train.py
    #!/usr/bin/env python\n\n# Importer les biblioth\u00e8ques n\u00e9cessaires\nimport argparse\nimport pandas as pd\nfrom sklearn.datasets import load_iris\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import accuracy_score\nimport joblib\n\n# Analyser les arguments d'entr\u00e9e\nparser = argparse.ArgumentParser(description=\"Train logistic regression model on iris dataset.\")\nparser.add_argument(\"--input\", default=\"iris.csv\", help=\"Path to input dataset file.\")\nparser.add_argument(\"--output\", default=\"model.pkl\", help=\"Path to output model file.\")\nargs = parser.parse_args()\n\n# Charger l'ensemble de donn\u00e9es d'iris\ndata = load_iris()\nX, y = data.data, data.target\n\n# Divisez les donn\u00e9es en ensembles d'entra\u00eenement et de test\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n\n# Entra\u00eener un mod\u00e8le de r\u00e9gression logistique\nclf = LogisticRegression(random_state=42)\nclf.fit(X_train, y_train)\n\n# \u00c9valuer le mod\u00e8le sur l'ensemble de test\ny_pred = clf.predict(X_test)\naccuracy = accuracy_score(y_test, y_pred)\nprint(\"Accuracy:\", accuracy)\n\n# Enregistrer le mod\u00e8le dans un fichier\njoblib.dump(clf, args.output)\n
    train.R
    #!/usr/bin/env Rscript\n\n# Importer les biblioth\u00e8ques n\u00e9cessaires\nlibrary(caret)\n\n# Copier les arguments d'entr\u00e9e\nargs <- commandArgs(trailingOnly = TRUE)\ninput_file <- ifelse(length(args) > 0, args[1], \"iris.csv\")\noutput_file <- ifelse(length(args) > 1, args[2], \"model.rds\")\n\n# Charger l'ensemble de donn\u00e9es d'iris\ndata(iris)\nX <- iris[, 1:4]\ny <- iris[, 5]\n\n# Divisez les donn\u00e9es en ensembles d'entra\u00eenement et de test\nset.seed(42)\ntrain_index <- createDataPartition(y, p = 0.8, list = FALSE)\nX_train <- X[train_index, ]\ny_train <- y[train_index]\nX_test <- X[-train_index, ]\ny_test <- y[-train_index]\n\n# Entra\u00eener un mod\u00e8le de r\u00e9gression logistique\nclf <- train(x = X_train, y = y_train, method = \"glm\")\n\n# \u00c9valuer le mod\u00e8le sur l'ensemble de test\ny_pred <- predict(clf, newdata = X_test)\naccuracy <- confusionMatrix(y_pred, y_test)$overall[\"Accuracy\"]\nprint(paste0(\"Accuracy: \", accuracy))\n\n# Enregistrer le mod\u00e8le dans un fichier\nsaveRDS(clf, output_file)\n
    "},{"location":"3-Pipelines/Argo.html#2-ecrivez-un-dockerfile-pour-executer-votre-code","title":"2. \u00c9crivez un Dockerfile pour ex\u00e9cuter votre code","text":"

    Vous aurez besoin d'un Dockerfile qui inclut toutes les d\u00e9pendances n\u00e9cessaires pour entra\u00eener votre mod\u00e8le 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\u00e8ques ou scripts personnalis\u00e9s
    • le code de votre mod\u00e8le d'apprentissage automatique sous la forme d'un script comme dans l'exemple ci-dessus.

    Utilisez le Dockerfile suivant comme point de d\u00e9part pour vos projets R et Python.

    PythonR Dockerfile
    FROM python:3.8-slim-buster\n\n# Installez toutes les d\u00e9pendances n\u00e9cessaires\nRUN pip install --no-cache-dir scikit-learn pandas numpy\n\n# D\u00e9finir le r\u00e9pertoire de travail\nWORKDIR /app\n\n# Copier le code dans le conteneur\nCOPY train.py .\n\n# D\u00e9finir le point d'entr\u00e9e\nENTRYPOINT [\"python\", \"train.py\"]\n
    Dockerfile
    FROM rocker/r-base:latest\n\nRUN apt-get update && apt-get install -y --no-install-recommends \\\n    libssl-dev \\\n    libcurl4-openssl-dev \\\n    libxml2-dev \\\n    && apt-get clean \\\n    && rm -rf /var/lib/apt/lists/*\n\nRUN R -e 'install.packages(c(\"caret\", \"janitor\", \"tidyverse\"))'\n\nCOPY train.R /app/train.R\n\nWORKDIR /app\n\nENTRYPOINT [\"Rscript\", \"train.R\"]\n
    "},{"location":"3-Pipelines/Argo.html#3-ecrivez-votre-flux-de-travail-en-yaml","title":"3. \u00c9crivez votre flux de travail en YAML","text":"

    YAML est encore un autre langage de balisage et vous devrez \u00e9crire les \u00e9tapes de votre pipeline de formation dans un fichier YAML de flux de travails Argo. Ce fichier doit inclure une r\u00e9f\u00e9rence au Dockerfile que vous avez cr\u00e9\u00e9 \u00e0 l'\u00c9tape 1, ainsi que toutes les donn\u00e9es d'entr\u00e9e et de sortie avec lesquelles vous travaillerez.

    Voici un exemple de fichier YAML pour un pipeline d'apprentissage automatique simple qui entra\u00eene un mod\u00e8le de r\u00e9gression logistique sur l'ensemble de donn\u00e9es iris. La seule vraie diff\u00e9rence entre les versions Python et R est la commande command: [\"python\", \"train.py\"] vs command: [\"Rscript\", \"train.R\"] et le les mod\u00e8les sont stock\u00e9s dans diff\u00e9rents formats, pkl pour python et rds pour R.

    Le fichier YAML d\u00e9finit une seule \u00e9tape appel\u00e9e train qui ex\u00e9cute un script appel\u00e9 train.py ou train.R dans l'image Docker machine-learning:v1. Le script prend un fichier d'ensemble de donn\u00e9es d'entr\u00e9e, sp\u00e9cifi\u00e9 par un param\u00e8tre appel\u00e9 dataset, et g\u00e9n\u00e8re un fichier de mod\u00e8le entra\u00een\u00e9 vers un artefact de sortie appel\u00e9 model.pkl ou model.rds selon le langage utilis\u00e9.

    PythonR workflow.yaml
    apiVersion: argoproj.io/v1alpha1\nkind: Workflow\nmetadata:\ngenerateName: ml-pipeline-\nspec:\nentrypoint: train\ntemplates:\n- name: train\n    container:\n    image: machine-learning:v1\n    command: [\"python\", \"train.py\"]\n    args: [\"--input\", \"{{inputs.parameters.dataset}}\", \"--output\", \"{{outputs.artifacts.model}}\"]\n    inputs:\n    parameters:\n    - name: dataset\n        default: \"iris.csv\"\n    outputs:\n    artifacts:\n    - name: model\n        path: /output/model.pkl\n
    workflow.yaml
    apiVersion: argoproj.io/v1alpha1\nkind: Workflow\nmetadata:\ngenerateName: ml-pipeline-\nspec:\nentrypoint: train\ntemplates:\n- name: train\n    container:\n    image: machine-learning:v1\n    command: [\"Rscript\", \"train.R\"]\n    args: [\"--input\", \"{{inputs.parameters.dataset}}\", \"--output\", \"{{outputs.artifacts.model}}\"]\n    inputs:\n    parameters:\n    - name: dataset\n        default: \"iris.csv\"\n    outputs:\n    artifacts:\n    - name: model\n        path: /output/model.rds\n
    "},{"location":"3-Pipelines/Argo.html#4-soumettez-le-flux-de-travail-a-laide-de-lentree-de-ligne-de-commandecli-du-flux-de-travail-argo","title":"4. Soumettez le flux de travail \u00e0 l'aide de l'entr\u00e9e de ligne de commande(CLI) du flux de travail Argo","text":"

    Pour ex\u00e9cuter le flux de travail ci-dessus, vous devrez d'abord envoyer le Dockerfile vers notre registre de conteneurs, puis soumettre le fichier YAML \u00e0 l'aide de la commande argo submit. Une fois le pipeline termin\u00e9, vous pouvez r\u00e9cup\u00e9rer le fichier de mod\u00e8le entra\u00een\u00e9 en t\u00e9l\u00e9chargeant l'artefact de sortie \u00e0 partir de la commande argo logs.

    Terminal
    $ argo submit workflow.yaml # soumettre une sp\u00e9cification de flux de travail \u00e0 Kubernetes\n

    Il est \u00e9galement possible de soumettre des flux de travail argo \u00e0 partir des flux de travail \u00e0 l'aide de SDK et d'appels API (c'est juste un autre service Web\u00a0!). Voir cette section.

    "},{"location":"3-Pipelines/Argo.html#5-surveillez-le-pipeline-a-laide-de-la-cli-du-flux-de-travail-argo","title":"5. Surveillez le pipeline \u00e0 l'aide de la CLI du flux de travail Argo","text":"

    Pendant l'ex\u00e9cution du pipeline, vous pouvez surveiller sa progression \u00e0 l'aide de la CLI de flux de travail Argo. Cela vous montrera quelles \u00e9tapes se sont termin\u00e9es avec succ\u00e8s et lesquelles sont toujours en cours. Vous trouverez ci-dessous quelques commandes utiles. Pour plus d'informations sur la CLI des flux de travail Argo, veuillez consulter la documentation officielle de la CLI de flux de travail Argo .

    Terminal
    $ argo list                       # lister les flux de travail actuels\n$ argo get workflow-xxx           # obtenir des informations sur un flux de travail sp\u00e9cifique\n$ argo logs workflow-xxx          # imprimer les journaux d'un flux de travail\n$ argo delete workflow-xxx        # suprimer un flux de travail\n
    "},{"location":"3-Pipelines/Argo.html#6-recuperer-le-modele-entraine","title":"6. R\u00e9cup\u00e9rer le mod\u00e8le entra\u00een\u00e9","text":"

    Une fois le pipeline termin\u00e9, vous pouvez r\u00e9cup\u00e9rer les donn\u00e9es de sortie \u00e0 l'aide de la commande argo logs ou en affichant les artefacts de sortie \u00e0 l'aide de la CLI, c'est-\u00e0-dire acc\u00e9der au r\u00e9pertoire que vous avez sp\u00e9cifi\u00e9 dans votre script et localiser le fichier model.pkl ou model.rds. L'extrait de code suivant, extrait du script de formation ci-dessus, indique au langage de programmation respectif o\u00f9 enregistrer le mod\u00e8le entra\u00een\u00e9.

    PythonR Saving Output Data
    #!/usr/bin/env python\n\nparser.add_argument(\"--output\", default=\"model.pkl\", help=\"Path to output model file.\")\n\n# Enregistrer le mod\u00e8le dans un fichier\njoblib.dump(clf, args.output)\n
    Saving Output Data
    #!/usr/bin/env Rscript\n\noutput_file <- ifelse(length(args) > 1, args[2], \"model.rds\")\n\n# Enregistrer le mod\u00e8le dans un fichier\nsaveRDS(clf, output_file)\n
    "},{"location":"3-Pipelines/Argo.html#exemples-utilisant-des-sdk-bases-sur-flux-de-travail-argo","title":"Exemples utilisant des SDK bas\u00e9s sur flux de travail Argo","text":"

    Argo prend en charge les biblioth\u00e8ques client, g\u00e9n\u00e9r\u00e9es automatiquement et g\u00e9r\u00e9es par la communaut\u00e9, qui incluent les SDK Java et Python.

    Si vous pr\u00e9f\u00e9rez utiliser un cadres de niveau sup\u00e9rieur, alors Couler et Hera sont des alternatives bien adapt\u00e9es. Ces cadress rendent la cr\u00e9ation et la gestion de flux de travail complexes plus accessibles \u00e0 un public plus large.

    "},{"location":"3-Pipelines/Argo.html#hera","title":"Hera","text":"

    Hera vise \u00e0 simplifier le processus de cr\u00e9ation et de soumission de flux de travail en \u00e9liminant de nombreux d\u00e9tails techniques via une interface de programmation d'application simple. Il utilise \u00e9galement un ensemble coh\u00e9rent 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.

    "},{"location":"3-Pipelines/Argo.html#couler","title":"Couler","text":"

    Couler fournit une interface de programmation d'applications simple et unifi\u00e9e pour d\u00e9finir des flux de travail \u00e0 l'aide d'un style de programmation imp\u00e9ratif. Il construit \u00e9galement automatiquement des graphiques acycliques dirig\u00e9s (DAG) pour les flux de travail, ce qui peut contribuer \u00e0 simplifier le processus de cr\u00e9ation et de gestion de ceux-ci.

    CoulerHera couler.py
    #!/usr/bin/env python\n\n# Pr\u00e9parez votre syst\u00e8me\n!pip config --user set global.index-url https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple\n!python3 -m pip install git+https://github.com/couler-proj/couler --ignore-installed\n\n# D\u00e9finir une variable globale pour plus de commodit\u00e9\nNAMESPACE = \"<your-namespace>\"\n\n# Importer les packages n\u00e9cessaires\nimport json\nimport random\n\nimport couler.argo as couler\nfrom couler.argo_submitter import ArgoSubmitter\n\n\n# D\u00e9finir les \u00e9tapes (fonctions) utilis\u00e9es dans le flux de travail\ndef random_code():\n    import random\n    res = \"heads\" if random.randint(0, 1) == 0 else \"tails\"\n    print(res)\n\n\ndef flip_coin():\n    return couler.run_script(\n        image=\"k8scc01covidacr.azurecr.io/ubuntu\",\n        source=random_code\n    )\n\n\ndef heads():\n    return couler.run_container(\n        image=\"k8scc01covidacr.azurecr.io/ubuntu\",\n        command=[\"sh\", \"-c\", 'echo \"it was heads\"']\n    )\n\n\ndef tails():\n    return couler.run_container(\n        image=\"k8scc01covidacr.azurecr.io/ubuntu\",\n        command=[\"sh\", \"-c\", 'echo \"it was tails\"']\n    )\n\n\nresult = flip_coin()\n\ncouler.when(couler.equal(result, \"heads\"), lambda: heads())\ncouler.when(couler.equal(result, \"tails\"), lambda: tails())\n\nsubmitter = ArgoSubmitter(namespace=\"NAMESPACE\")\nresult = couler.run(submitter=submitter)\n\nprint(json.dumps(result, indent=2))\n
    hera.py
    #!/usr/bin/env python\n\n# Pr\u00e9parez votre syst\u00e8me\n!pip config --user set global.index-url https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple\n!pip install hera-workflows\n\n# Importer les packages n\u00e9cessaires\nimport hera\nfrom hera import Task, Workflow\n\n# Configurer Hera\nhera.global_config.GlobalConfig.token = \"<your-token>\"\nhera.global_config.GlobalConfig.host = \"https://argo-workflows.aaw-dev.cloud.statcan.ca:443\"\nhera.global_config.GlobalConfig.namespace = \"<your-namespace>\"\nhera.global_config.GlobalConfig.service_account_name = \"<your-account-name>\"\n\n\n# D\u00e9finir les \u00e9tapes (fonctions) utilis\u00e9es dans le workflow\ndef random_code():\n    res = \"heads\" if random.randint(0, 1) == 0 else \"tails\"\n    print(res)\n\n\ndef heads():\n    print(\"it was heads\")\n\n\ndef tails():\n    print(\"it was tails\")\n\n# D\u00e9finir le flux de travail\nwith Workflow(\"coin-flip\") as w:\n    r = Task(\"r\", random_code)\n    h = Task(\"h\", heads)\n    t = Task(\"t\", tails)\n\n    h.on_other_result(r, \"heads\")\n    t.on_other_result(r, \"tails\")\n\n# Ex\u00e9cuter le flux de travail\nw.create()\n
    "},{"location":"3-Pipelines/Argo.html#ressources-supplementaires-pour-les-flux-de-travail-argo","title":"Ressources suppl\u00e9mentaires pour les flux de travail Argo","text":"

    Des exemples de flux de travail Argo peuvent \u00eatre trouv\u00e9s dans les r\u00e9f\u00e9rentiels Github suivants\u00a0:

    • Documentation des flux de travail Argo
    • R\u00e9f\u00e9rence Argo CLI
    "},{"location":"4-Collaboration/Aper%C3%A7u.html","title":"Aper\u00e7u","text":"

    La collaboration est essentielle en science des donn\u00e9es car elle permet \u00e0 des individus ayant des perspectives et des parcours diff\u00e9rents de travailler ensemble pour r\u00e9soudre des probl\u00e8mes complexes et g\u00e9n\u00e9rer de nouvelles informations. En science des donn\u00e9es, la collaboration peut impliquer de travailler avec des personnes issues de divers domaines tels que les math\u00e9matiques, l\u2019informatique et les affaires, ainsi qu\u2019avec des experts en la mati\u00e8re poss\u00e9dant une connaissance approfondie d\u2019une industrie ou d\u2019un domaine particulier.

    Il existe de nombreuses fa\u00e7ons de collaborer sur la plateforme. Selon votre situation,ce qu vous voulez partager et le nombre de personnes que vous souhaitez partager avec. Les sc\u00e9narios se d\u00e9composent en gros en ce que vous voulez partager (Donn\u00e9es, Code, ou Environnements de calcul (e.g.: Partager les m\u00eames machines virtuelles)) et avec qui vous voulez le partager (Personne, Mon \u00e9quipe, ou Tout le monde). Cela conduit au tableau d'options suivant:

    Priv\u00e9e \u00c9quipe StatCan Code GitLab/GitHub ou un dossier personnel GitLab/GitHub or dossier d'\u00e9quipe GitLab/GitHub Donn\u00e9es Dossier personnel ou compartiment Dossier d'\u00e9quipe ou compartiment , ou espace de noms partag\u00e9 Compartiment partag\u00e9 Calcul Espace de nom personnel Espace de noms partag\u00e9 N/A

    Le partage de code, de disques et d'espaces de travail (par exemple\u00a0: deux personnes partageant la m\u00eame machine virtuelle) est d\u00e9crit plus en d\u00e9tail ci-dessous. Le partage de donn\u00e9es via des compartiments est d\u00e9crit plus en d\u00e9tail dans la section Stockage Blob Azure.

    Quelle est la diff\u00e9rence entre un compartiment et un dossier?

    Les compartiments sont comme le stockage sur r\u00e9seau. Consulter pr\u00e9sentation du stockage pour plus de d\u00e9tails sur les diff\u00e9rences entre ces deux options.

    Choisir la meilleure fa\u00e7on de partager le code, les donn\u00e9es et le calcul implique un ensemble de diff\u00e9rent facteurs, mais vous pouvez g\u00e9n\u00e9ralement m\u00e9langer et assortir (partager le code avec votre \u00e9quipe via github, mais stockez vos donn\u00e9es en priv\u00e9 dans un compartiment personnel). Ces cas sont d\u00e9crits plus en d\u00e9tail dans les sections ci-dessous

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-le-code-entre-les-membres-de-lequipe","title":"Partager le code entre les membres de l'\u00e9quipe","text":"

    Dans la plupart des cas, il est plus facile de partager du code en utilisant GitHub ou GitLab. L'avantage du partage avec GitHub ou GitLab est que cela fonctionne avec les utilisateurs \u00e0 travers les espaces de noms, et conserver le code dans git est un excellent moyen de g\u00e9rer de grands projets logiciels.

    N'oubliez pas d'inclure une licence !

    Si votre code est public, n'oubliez pas de respecter les directives de l'\u00e9quipe d'innovation et d'utiliser une licence appropri\u00e9e si votre travail est effectu\u00e9 pour Statistique Canada.

    Si vous devez partager du code sans le publier sur un r\u00e9f\u00e9rentiel, partager un espace de nom) pourrait aussi fonctionner.

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-le-calcul-espace-de-nom-dans-kubeflow","title":"Partager le calcul (espace de nom) dans Kubeflow","text":"

    Partager un espace de nom signifie que vous partagez toutes les choses dans l'espace de nom

    Kubeflow ne prend pas en charge le partage granulaire d'une ressource (un bloc-notes, un volume, etc.), mais plut\u00f4t le partage de toutes ressources. Si vous souhaitez partager un serveur bloc-notes Jupyter avec quelqu'un, vous devez partager l'int\u00e9gralit\u00e9 de votre espace de nom et ils auront acc\u00e8s \u00e0 toutes les autres ressources (Storage Blob Azure, etc.).

    Dans Kubeflow, chaque utilisateur dispose d'un espace de noms qui contient son travail (ses serveurs bloc-notes, pipelines, disques, etc.). Votre espace de noms vous appartient, mais peut \u00eatre partag\u00e9 si vous souhaitez collaborer avec d'autres. Vous pouvez \u00e9galement demander un nouvel espace de noms (soit pour vous-m\u00eame, soit pour le partager avec une \u00e9quipe). Une option de collaboration consiste \u00e0 partager des espaces de noms avec d\u2019autres.

    L'avantage du partage d'un espace de noms Kubeflow est qu'il vous permet, \u00e0 vous et \u00e0 vos coll\u00e8gues, de partager l'environnement de calcul et les volumes associ\u00e9s \u00e0 l'espace de noms. Cela en fait un moyen de partage tr\u00e8s simple et libre.

    Pour partager votre espace de noms, consultez gestion des contributeurs

    Demander de l'aide en production

    Le personnel d'assistance d'Espace de travail d'analyse avanc\u00e9e se fera un plaisir de vous aider avec les cas d'utilisation orient\u00e9s vers la production, et nous pouvons probablement vous faire gagner beaucoup de temps. Ne soyez pas timide Demander pour l'aide!

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-des-donnees","title":"Partager des donn\u00e9es","text":"

    Une fois que vous avez un espace de nom partag\u00e9, vous avez deux approches de stockage partag\u00e9

    Possibilit\u00e9 de stockage Avantages Serveurs/espaces de travail Jupyter partag\u00e9s Plus adapt\u00e9 aux petits fichiers, aux cahiers et aux petites exp\u00e9riences. Compartiments partag\u00e9s( consultez Stockage) Mieux adapt\u00e9 pour une utilisation dans les pipelines, les API et pour les fichiers volumineux.

    Pour en savoir plus sur la technologie qui les sous-tend, consultez le Stockage.

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-avec-le-monde","title":"Partager avec le monde","text":"

    Renseignez-vous \u00e0 ce sujet sur notre cha\u00eene Slack. Il existe de nombreuses fa\u00e7ons de proc\u00e9der du c\u00f4t\u00e9 informatique, mais il est important que cela passe par des processus appropri\u00e9s, afin que cela ne se fasse pas de mani\u00e8re \u00ab libre-service \u00bb comme le sont les autres. Cela dit, c'est tout \u00e0 fait possible.

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#gestion-des-contributeurs","title":"Gestion des contributeurs","text":"

    Vous pouvez ajouter ou supprimer des personnes d'un espace de noms que vous poss\u00e9dez d\u00e9j\u00e0 via le menu G\u00e9rer les contributeurs dans Kubeflow.

    Maintenant, vous et vos coll\u00e8gues pouvez partager l'acc\u00e8s \u00e0 un serveur!

    Essayer le!

    "},{"location":"4-Collaboration/Demander-EspaceDeNom.html","title":"Aper\u00e7u","text":"

    Par d\u00e9faut, chaque personne a son espace de nom personnel, pr\u00e9nom-nom. Si vous souhaitez collaborer avec votre \u00e9quipe, vous pouvez demander un Espace de nom \u00e0 partager.

    "},{"location":"4-Collaboration/Demander-EspaceDeNom.html#installation","title":"Installation","text":""},{"location":"4-Collaboration/Demander-EspaceDeNom.html#demander-un-espace-de-nom","title":"Demander un espace de nom","text":"

    Pour cr\u00e9er un espace de noms pour une \u00e9quipe, acc\u00e9dez au portail ETAA. Cliquez Commencer.

    L'espace de noms ne peut pas avoir de caract\u00e8res sp\u00e9ciaux autres que des traits d'union

    Le nom de l'espace de noms ne doit \u00eatre compos\u00e9 que de lettres minuscules \u00ab a-z \u00bb avec des tirets. Sinon,l'espace de noms ne sera pas cr\u00e9\u00e9.

    Vous recevrez une notification par e-mail lorsque l'espace de noms sera cr\u00e9\u00e9. Une fois l'espace de noms partag\u00e9 cr\u00e9\u00e9, vous pouvez y acc\u00e9der de la m\u00eame mani\u00e8re que n'importe quel autre espace de noms dont vous disposez via l'interface utilisateur de Kubeflow, comme illustr\u00e9 ci-dessous. Vous serez alors capable de partager et g\u00e9rer) \u00e0 votre espace de nom.

    Pour changer d'espace de noms, regardez en haut de votre fen\u00eatre, juste \u00e0 droite du logo Kubeflow.

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html","title":"Environnement d'Analyse G\u00e9ospatiale (EAG) - Acc\u00e8s multi-plateforme","text":"Donn\u00e9es non prot\u00e9g\u00e9es uniquement, SSI bient\u00f4t disponible!

    \u00c0 l'heure actuelle, notre serveur g\u00e9ospatial ne peut h\u00e9berger et donner acc\u00e8s qu'\u00e0 des informations statistiques non sensibles.

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#demarrage","title":"D\u00e9marrage","text":"

    Conditions pr\u00e9alables

    1. Un projet int\u00e9gr\u00e9 avec acc\u00e8s au portail SAD EAG ArcGIS
    2. Un identifiant client ArcGIS Portal (cl\u00e9 API)

    Le portail ArcGIS Enterprise est accessible dans ETAA ou EAC \u00e0 l'aide de l'API, \u00e0 partir de n'importe quel service qui exploite le langage de programmation Python.

    Par exemple, dans ETAA et l'utilisation de Bloc-notes Jupyter dans l'espace, ou pour EAC l'utilisation de Databricks, DataFactory, etc.

    Le portail DAS GAE ArcGIS Enterprise est accessible directement ici

    Pour obtenir de l'aide sur l'auto-inscription en tant qu'utilisateur du portail g\u00e9ospatial SAD

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#utilisation-de-lapi-arcgis-pour-python","title":"Utilisation de l'API ArcGIS pour Python","text":""},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#connexion-a-arcgis-enterprise-portal-a-laide-de-lapi-arcgis","title":"Connexion \u00e0 ArcGIS Enterprise Portal \u00e0 l'aide de l'API ArcGIS","text":"

    1. Installez les packages\u00a0:

      conda install -c esri arcgis\n

      ou utilisez Artifactory

      conda install -c https://jfrog.aaw.cloud.statcan.ca/artifactory/api/conda/esri-remote arcgis\n

    2. Importez les biblioth\u00e8ques n\u00e9cessaires dont vous aurez besoin dans le bloc-note. 

      from arcgis.gis import GIS\nfrom arcgis.gis import Item\n

    3. Acc\u00e9der au portail Votre groupe de projet recevra un identifiant client lors de l'int\u00e9gration. Collez l'ID client entre les guillemetsclient_id='######'. 

      gis = GIS(\"https://geoanalytics.cloud.statcan.ca/portal\", client_id=' ')\nprint(\"Connexion r\u00e9ussie sous le nom de: \" + gis.properties.user.username)\n

    4. La sortie vous redirigera vers un portail de connexion.

      • Utilisez l'option de connexion Azure de StatCan et votre identifiant Cloud
      • Apr\u00e8s une connexion r\u00e9ussie, vous recevrez un code pour vous connecter en utilisant SAML.

      • Collez ce code dans la sortie.

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#afficher-les-informations-utilisateur","title":"Afficher les informations utilisateur","text":"

    En utilisant la fonction \u00ab me \u00bb, nous pouvons afficher diverses informations sur l'utilisateur connect\u00e9. 

    me = gis.users.me\nusername = me.username\ndescription = me.description\ndisplay(me)\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#rechercher-du-contenu","title":"Rechercher du contenu","text":"

    Recherchez le contenu que vous avez h\u00e9berg\u00e9 sur le portail SAD EAG. En utilisant la fonction \u00ab me \u00bb, nous pouvons rechercher tout le contenu h\u00e9berg\u00e9 sur le compte. Il existe plusieurs fa\u00e7ons de rechercher du contenu. Deux m\u00e9thodes diff\u00e9rentes sont d\u00e9crites ci-dessous.

    Recherchez tous vos \u00e9l\u00e9ments h\u00e9berg\u00e9s dans le portail g\u00e9ographique SAD. 

    my_content = me.items()\nmy_content\n
    Recherchez du contenu sp\u00e9cifique que vous poss\u00e9dez dans le portail g\u00e9ographique SAD.

    Ceci est similaire \u00e0 l'exemple ci-dessus, mais si vous connaissez le titre de la couche que vous souhaitez utiliser, vous pouvez l'enregistrer en tant que fonction. 

    my_items = me.items()\nfor items in my_items:\n    print(items.title, \" | \", items.type)\n    if items.title == \"Inondation \u00e0 Sorel-Tracy\":\n        flood_item = items\n\n    else:\n        continue\nprint(flood_item)\n

    Recherchez tout le contenu auquel vous avez acc\u00e8s, pas seulement le v\u00f4tre.

    flood_item = gis.content.search(\"tags: flood\", item_type =\"Service des caract\u00e9ristiques\")\nflood_item\n
    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#obtenir-du-contenu","title":"Obtenir du contenu","text":"

    Nous devons obtenir l'\u00e9l\u00e9ment du portail g\u00e9ographique SAD afin de l'utiliser dans le bloc-notes Jupyter. Cela se fait en fournissant le num\u00e9ro d'identification unique de l'article que vous souhaitez utiliser. Trois exemples sont d\u00e9crits ci-dessous, tous acc\u00e9dant \u00e0 la m\u00eame couche.

    item1 = gis.content.get(my_content[5].id) #de la recherche de votre contenu ci-dessus\ndisplay(item1)\n\nitem2 = gis.content.get(flood_item.id) #de la recherche de votre contenu ci-dessus\ndisplay(item2)\n\nitem3 = gis.content.get('edebfe03764b497f90cda5f0bfe727e2') #le num\u00e9ro d'identification du contenu\ndisplay(item3)\n
    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#effectuer-une-analyse","title":"Effectuer une analyse","text":"

    Une fois les couches import\u00e9es dans le bloc-note Jupyter, nous sommes en mesure d'effectuer des types d'analyse similaires \u00e0 ceux que vous vous attendriez \u00e0 trouver dans un logiciel SIG tel qu'ArcGIS. Il existe de nombreux modules contenant de nombreux sous-modules qui peuvent effectuer plusieurs types d'analyses.

    \u00c0 l'aide du module arcgis.features, importez le sous-module use_proximity from arcgis.features import use_proximity. Ce sous-module nous permet de .create_buffers - des zones \u00e0 \u00e9gale distance des entit\u00e9s. Ici, nous sp\u00e9cifions la couche que nous voulons utiliser, la distance, les unit\u00e9s et le nom de sortie (vous pouvez \u00e9galement sp\u00e9cifier d'autres caract\u00e9ristiques telles que le champ, le type d'anneau, le type de fin et autres). En sp\u00e9cifiant un nom de sortie, apr\u00e8s avoir ex\u00e9cut\u00e9 la commande buffer, une nouvelle couche sera automatiquement t\u00e9l\u00e9charg\u00e9e dans le portail SAD EAG contenant la nouvelle fonctionnalit\u00e9 que vous venez de cr\u00e9er. 

    buffer_lyr = use_proximity.create_buffers(item1, distances=[1], \n                                          units = \"Kilom\u00e8tres\", \n                                          output_name='item1_buffer')\n\ndisplay(item1_buffer)\n

    Certains utilisateurs pr\u00e9f\u00e8rent travailler avec des packages Open Source. La traduction d'ArcGIS vers Spatial Dataframes est simple. 

    # cr\u00e9er un objet DataFrame spatialis\u00e9\nsdf = pd.DataFrame.spatial.from_layer(feature_layer)\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#mettre-a-jour-les-elements","title":"Mettre \u00e0 jour les \u00e9l\u00e9ments","text":"

    En obtenant l'\u00e9l\u00e9ment comme nous l'avons fait similaire \u00e0 l'exemple ci-dessus, nous pouvons utiliser la fonction .update pour mettre \u00e0 jour l'\u00e9l\u00e9ment existant dans le portail SAD EAG. Nous pouvons mettre \u00e0 jour les propri\u00e9t\u00e9s, les donn\u00e9es, les vignettes et les m\u00e9tadonn\u00e9es des \u00e9l\u00e9ments. 

    item1_buffer = gis.content.get('c60c7e57bdb846dnbd7c8226c80414d2')\nitem1_buffer.update(item_properties={'title': 'Saisir le titre'\n                                     'tags': 'tag1, tag2, tag3, tag4',\n                                     'description': 'Saisir la description de l'article'}\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#visualisez-vos-donnees-sur-une-carte-interactive","title":"Visualisez vos donn\u00e9es sur une carte interactive","text":"

    Exemple\u00a0: biblioth\u00e8que MatplotLib Dans le code ci-dessous, nous cr\u00e9ons un objet ax, qui est un trac\u00e9 de style carte. Nous tra\u00e7ons ensuite notre colonne de changement de donn\u00e9es (\"Population Change\") sur les axes 

    import matplotlib.pyplot as plt\nax = sdf.boundary.plot(figsize=(10, 5))\nshape.plot(ax=ax, column='Population Change', legend=True)\nplt.show()\n

    Exemple\u00a0: biblioth\u00e8que ipyleaflet Dans cet exemple, nous utiliserons la biblioth\u00e8que ipyleaflet pour cr\u00e9er une carte interactive. Cette carte sera centr\u00e9e autour de Toronto, ON. Les donn\u00e9es utilis\u00e9es seront d\u00e9crites ci-dessous. Commencez par coller conda install -c conda-forge ipyleaflet vous permettant d'installer les biblioth\u00e8ques ipyleaflet dans l'environnement Python.

    Importer les biblioth\u00e8ques n\u00e9cessaires.

    import ipyleaflet \nfrom ipyleaflet import *\n
    Maintenant que nous avons import\u00e9 le module ipyleaflet, nous pouvons cr\u00e9er une carte simple en sp\u00e9cifiant la latitude et la longitude de l'emplacement que nous voulons, le niveau de zoom et le fond de carte (plus de fonds de carte). Des contr\u00f4les suppl\u00e9mentaires ont \u00e9t\u00e9 ajout\u00e9s tels que les calques et l'\u00e9chelle. 
    toronto_map = Map(center=[43.69, -79.35], zoom=11, basemap=basemaps.Esri.WorldStreetMap)\n\ntoronto_map.add_control(LayersControl(position='topright'))\ntoronto_map.add_control(ScaleControl(position='bottomleft'))\ntoronto_map\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#en-savoir-plus-sur-lapi-arcgis-pour-python","title":"En savoir plus sur l'API ArcGIS pour Python","text":"

    La documentation compl\u00e8te de l'API ArcGIS peut \u00eatre trouv\u00e9e ici

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#en-savoir-plus-sur-lenvironnement-analytique-geospatial-gae-et-les-services-sad","title":"En savoir plus sur l'environnement analytique g\u00e9ospatial (GAE) et les services SAD","text":"

    Guide d'aide GAE

    "},{"location":"5-Stockage/Aper%C3%A7u.html","title":"Stockage","text":"

    La plateforme propose plusieurs types de stockage :

    • Disque (\u00e9galement appel\u00e9 Volumes sur l'\u00e9cran de cr\u00e9ation de serveur de blocs-note)
    • Compartiment (Stockage Azure Blob)
    • Data Lakes (\u00e0 venir)

    Selon votre cas d'utilisation, le disque ou le compartiment peut \u00eatre le plus appropri\u00e9 :

    Type Utilisateurs simultan\u00e9s Vitesse Taille totale Partageable avec d'autres utilisateurs Disque Une machine/serveur de bloc-notes \u00e0 la fois Le plus rapide (d\u00e9bit et latence) <=512GB total par stockage Non Compartiment (via Stockage Blob Azure) Acc\u00e8s simultan\u00e9 depuis plusieurs machines/serveurs d'ordinateurs portables en m\u00eame temps Fast-ish (t\u00e9l\u00e9chargement rapide, t\u00e9l\u00e9chargement modeste, latence modeste) Infini (dans la limite du raisonnable) [Oui] Si vous ne savez pas lequel choisir, ne vous en faites pas

    Ce sont des lignes directrices, pas une science exacte - choisissez ce qui sonne le mieux maintenant et ex\u00e9cutez-le. Le meilleur choix pour une utilisation compliqu\u00e9e n'est pas \u00e9vident et n\u00e9cessite souvent une exp\u00e9rience pratique, donc essayer quelque chose vous aidera. Dans la plupart des situations, les deux options fonctionnent bien m\u00eame si elles ne sont pas parfaites, et n'oubliez pas que les donn\u00e9es peuvent toujours \u00eatre copi\u00e9es plus tard si vous changez d'avis.

    "},{"location":"5-Stockage/Disque.html","title":"Aper\u00e7u","text":"

    Les disques sont les syst\u00e8mes de fichiers familiers de type disque dur auxquels vous \u00eates habitu\u00e9, fournis \u00e0 vous des disques SSD rapides !

    "},{"location":"5-Stockage/Disque.html#installation","title":"Installation","text":"

    Lors de la cr\u00e9ation de votre serveur bloc-notes, vous demandez des disques en ajoutant des volumes de donn\u00e9es \u00e0 votre serveur de bloc-note (illustr\u00e9 ci-dessous, en allant dans Options avanc\u00e9es). Ils sont automatiquement mont\u00e9s dans le r\u00e9pertoire (Point de montage) que vous choisissez et constituent un moyen simple et fiable de conserver les donn\u00e9es attach\u00e9es \u00e0 un serveur bloc-note.

    Vous payez pour tous les disques que vous poss\u00e9dez, qu'ils soient connect\u00e9s \u00e0 un serveur bloc-note ou non

    D\u00e8s que vous cr\u00e9ez un disque, vous le payez jusqu'\u00e0 ce qu'il soit supprim\u00e9, m\u00eame si le Serveur de blocs-note d'origine est supprim\u00e9. Voir Suppression du stockage sur disque pour plus d'informations

    "},{"location":"5-Stockage/Disque.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":"

    Lorsque vous supprimez votre serveur bloc-notes, vos disques ne sont pas supprim\u00e9s. Cela vous permet de r\u00e9utiliser ult\u00e9rieurement ce m\u00eame disque (avec tout son contenu) sur un nouveau serveur bloc-notes (comme indiqu\u00e9 ci-dessus avec Type = Existant et le Nom d\u00e9fini sur le volume que vous souhaitez r\u00e9utiliser). Si vous en avez termin\u00e9 avec le disque et son contenu, supprimez-le.

    "},{"location":"5-Stockage/Disque.html#suppression-du-stockage-sur-disque","title":"Suppression du stockage sur disque","text":"

    Pour voir vos disques, consultez la section Volumes de la page Serveur bloc-notes (illustr\u00e9 ci-dessous). Vous pouvez supprimer n'importe quel disque non connect\u00e9 (ic\u00f4ne \u00e0 gauche) en cliquant sur l'ic\u00f4ne de la corbeille.

    "},{"location":"5-Stockage/Disque.html#prix","title":"Prix","text":"Les mod\u00e8les de tarification sont provisoires et peuvent changer

    Au moment de la r\u00e9daction, la tarification est couverte par la plate-forme pour les utilisateurs initiaux. Ce guide explique comment les choses devraient \u00eatre tarif\u00e9es \u00e0 l'avenir, mais cela peut changer.

    Lors du montage d'un disque, vous obtenez un Disque manag\u00e9 Azure. La tarification des Disques g\u00e9r\u00e9s SSD Premium indique le co\u00fbt par disque en fonction de la taille. Notez que vous payez pour la taille du disque demand\u00e9e, et non pour la quantit\u00e9 d'espace que vous utilisez actuellement.

    Conseils pour minimiser les co\u00fbts

    Comme les disques peuvent \u00eatre attach\u00e9s \u00e0 un Serveur blocs-note et r\u00e9utilis\u00e9s, un mod\u00e8le d'utilisation typique pourrait \u00eatre :

    • \u00c0 9h, cr\u00e9ez un Serveur blocs-note (demandez 2CPU/8GB RAM et un 32GB attach\u00e9 disque)
    • Travaillez tout au long de la journ\u00e9e, en enregistrant les r\u00e9sultats sur le disque attach\u00e9
    • \u00c0 17h, \u00e9teignez votre Serveur blocs-note pour \u00e9viter de le payer du jour au lendemain
    • REMARQUE : Le disque attach\u00e9 ** n'est pas d\u00e9truit ** par cette action
    • \u00c0 9 heures du matin le lendemain, cr\u00e9ez un nouveau serveur blocs-note et ** joignez votre disque**
    • Continuez votre travail...

    Cela prot\u00e8ge tout votre travail sans payer pour l'ordinateur lorsque vous ne l'utilisez pas

    "},{"location":"5-Stockage/StockageBlobAzure.html","title":"Aper\u00e7u","text":"

    Azure Blob Storage est la solution de stockage d'objets de Microsoft pour le nuage informatique. Le stockage blob est optimis\u00e9 pour stocker des quantit\u00e9s massives de donn\u00e9es non structur\u00e9es. Les donn\u00e9es non structur\u00e9es sont des donn\u00e9es qui n'adh\u00e8rent pas \u00e0 un mod\u00e8le de donn\u00e9es ou \u00e0 une d\u00e9finition particuli\u00e8re, comme du texte ou des donn\u00e9es binaires.

    Les conteneurs de stockage blob Azure sont efficaces dans trois domaines\u00a0:

    • De grandes quantit\u00e9s de donn\u00e9es - Les conteneurs peuvent \u00eatre \u00e9normes : bien plus gros que les disques durs. Et ils sont toujours rapides.
    • Accessible par plusieurs consommateurs \u00e0 la fois - Vous pouvez acc\u00e9der \u00e0 la m\u00eame source de donn\u00e9es \u00e0 partir de plusieurs serveurs bloc-note et pipelines en m\u00eame temps sans avoir besoin de dupliquer les donn\u00e9es.
    • Partage - Les espaces de noms de projet peuvent partager un conteneur. C'est id\u00e9al pour partager des donn\u00e9es avec des personnes ext\u00e9rieures \u00e0 votre espace de travail.
    "},{"location":"5-Stockage/StockageBlobAzure.html#installation","title":"Installation","text":"

    Les conteneurs de stockage Azure Blob et le support de buckets remplaceront les supports de stockage Minio Buckets et Minio

    Les utilisateurs seront responsables de la migration des donn\u00e9es des Minio Buckets vers les dossiers Azure Storage. Pour les fichiers plus volumineux, les utilisateurs peuvent contacter AAW pour obtenir de l'aide.

    "},{"location":"5-Stockage/StockageBlobAzure.html#conteneur-blob-monte-sur-un-serveur-de-bloc-note","title":"Conteneur Blob mont\u00e9 sur un serveur de bloc-note","text":"

    Les volumes Blob CSI sont conserv\u00e9s sous /home/jovyan/buckets lors de la cr\u00e9ation d'un serveur bloc-notes. Les fichiers sous /buckets sont sauvegard\u00e9s par le stockage Blob. Tous les ordinateurs portables AAW auront le /buckets mont\u00e9 sur le syst\u00e8me de fichiers, rendant les donn\u00e9es accessibles de partout.

    "},{"location":"5-Stockage/StockageBlobAzure.html#support-de-dossier-aaw-pour-ordinateur-portable-non-classe","title":"Support de dossier AAW pour ordinateur portable non class\u00e9","text":""},{"location":"5-Stockage/StockageBlobAzure.html#support-de-dossier-aaw-pour-ordinateur-portable-protege-b","title":"Support de dossier AAW pour ordinateur portable prot\u00e9g\u00e9-b","text":"

    Ces dossiers peuvent \u00eatre utilis\u00e9s comme n'importe quel autre : vous pouvez copier des fichiers vers/depuis l'explorateur de fichiers, \u00e9crire \u00e0 partir de Python/R, etc. La seule diff\u00e9rence est que les donn\u00e9es sont stock\u00e9es dans le conteneur de stockage Blob plut\u00f4t que sur un disque local. (et est donc accessible partout o\u00f9 vous pouvez acc\u00e9der \u00e0 votre bloc-note Kubeflow).

    "},{"location":"5-Stockage/StockageBlobAzure.html#comment-migrer-de-minio-vers-azure-blob-storage","title":"Comment migrer de MinIO vers Azure Blob Storage","text":"

    Tout d\u2019abord, importez les variables d\u2019environnement stock\u00e9es dans votre coffre-fort de secrets. Vous importerez soit depuis minio-gateway soit depuis fdi-gateway selon l'endroit o\u00f9 vos donn\u00e9es ont \u00e9t\u00e9 ing\u00e9r\u00e9es.

    jovyan@rstudio-0\u00a0:~$ source /vault/secrets/fdi-gateway-protected-b\n

    Ensuite, vous cr\u00e9ez un alias pour acc\u00e9der \u00e0 vos donn\u00e9es.

    jovyan@rstudio-0\u00a0: ~$ mc alias d\u00e9fini minio $MINIO_URL $MINIO_ACCESS_KEY $MINIO_SECRET_KEY\n

    R\u00e9pertoriez le contenu de votre dossier de donn\u00e9es avec mc ls.

    jovyan@rstudio-0:~$ mc ls minio\n

    Enfin, copiez vos donn\u00e9es MinIO dans votre r\u00e9pertoire Azure Blob Storage avec mc cp --recursive.

    jovyan@rstudio-0:~$ mc cp --recursive minio ~/buckets/\n

    Si vous disposez de donn\u00e9es prot\u00e9g\u00e9es-b, vous pouvez copier vos donn\u00e9es dans le compartiment prot\u00e9g\u00e9-b.

    jovyan@rstudio-0:~$ mc cp \u2014-recursive minio ~/buckets/aaw-protected-b\n
    "},{"location":"5-Stockage/StockageBlobAzure.html#types-de-conteneurs","title":"Types de conteneurs","text":"

    Les conteneurs Blob suivants sont disponibles\u00a0:

    L\u2019acc\u00e8s \u00e0 tous les conteneurs Blob est le m\u00eame. La diff\u00e9rence entre les conteneurs r\u00e9side dans le type de stockage qui les sous-tend\u00a0:

    • aaw-unclassified\u00a0: Par d\u00e9faut, utilisez celui-ci. Stocke les donn\u00e9es non classifi\u00e9es.
    • aaw-protected-b\u00a0: Stocke les donn\u00e9es sensibles prot\u00e9g\u00e9es-b.
    • aaw-unclassified-ro\u00a0: Cette classification est prot\u00e9g\u00e9e-b mais en acc\u00e8s en lecture seule. Cela permet aux utilisateurs de visualiser les donn\u00e9es non classifi\u00e9es dans un bloc-notes prot\u00e9g\u00e9-b.
    "},{"location":"5-Stockage/StockageBlobAzure.html#acces-aux-donnees-internes","title":"Acc\u00e8s aux donn\u00e9es internes","text":"

    L'acc\u00e8s aux donn\u00e9es internes utilise la connexion de stockage commune DAS qui est utilis\u00e9e par les utilisateurs internes et externes qui ont besoin d'acc\u00e9der \u00e0 des donn\u00e9es non classifi\u00e9es ou prot\u00e9g\u00e9es-b. Les conteneurs suivants peuvent \u00eatre mis \u00e0 disposition :

    • externe-non class\u00e9
    • externe-prot\u00e9g\u00e9-b
    • interne-non class\u00e9
    • interne-prot\u00e9g\u00e9-b

    Ils suivent la m\u00eame convention que les conteneurs AAW ci-dessus en termes de donn\u00e9es, mais il existe une couche d'isolement entre les employ\u00e9s de StatCan et les non-employ\u00e9s de StatCan. Les employ\u00e9s non-Statcan ne sont autoris\u00e9s que dans les conteneurs externes, tandis que les employ\u00e9s de StatCan peuvent avoir acc\u00e8s \u00e0 n'importe quel conteneur.

    AAW dispose d'une int\u00e9gration avec l'\u00e9quipe FAIR Data Infrastructure qui permet aux utilisateurs de transf\u00e9rer des donn\u00e9es non classifi\u00e9es et prot\u00e9g\u00e9es vers des comptes de stockage Azure, permettant ainsi aux utilisateurs d'acc\u00e9der \u00e0 ces donn\u00e9es \u00e0 partir de serveurs bloc-note.

    Veuillez contacter l'\u00e9quipe FAIR Data Infrastructure si vous avez un cas d'utilisation de ces donn\u00e9es.

    "},{"location":"5-Stockage/StockageBlobAzure.html#tarifs","title":"Tarifs","text":"

    Les mod\u00e8les de tarification sont bas\u00e9s sur l'utilisation du processeur et de la m\u00e9moire

    Le prix est couvert par KubeCost pour les espaces de noms utilisateur (dans Kubeflow en bas de l'onglet bloc-notes).

    En g\u00e9n\u00e9ral, le stockage Blob est beaucoup moins cher que Azure Manage Disks et offre de meilleures E/S que les SSD g\u00e9r\u00e9s.

    "},{"location":"6-Gitlab/Gitlab.html","title":"Guide de configuration de GitLab","text":"

    Bienvenue sur GitLab\u00a0! GitLab est une plateforme puissante qui facilite le d\u00e9veloppement collaboratif \u00e0 l'aide de Git. Avant de plonger dans le monde des r\u00e9f\u00e9rentiels, assurons-nous que votre configuration Git correspond \u00e0 votre identit\u00e9 GitLab. Vous trouverez ci-dessous des instructions sur la personnalisation de \u00ab git \u00bb et la cr\u00e9ation d'un jeton d'acc\u00e8s personnel (PAT) pour une interaction transparente avec les r\u00e9f\u00e9rentiels GitLab.

    "},{"location":"6-Gitlab/Gitlab.html#personnalisation-de-git","title":"Personnalisation de Git","text":"

    Lorsque vous utilisez git, il est essentiel de configurer votre identit\u00e9. Ouvrez une nouvelle session de terminal et ex\u00e9cutez les commandes suivantes pour configurer votre nom et votre adresse e-mail associ\u00e9s \u00e0 GitLab\u00a0:

    "},{"location":"6-Gitlab/Gitlab.html#nom-dutilisateur","title":"Nom d'utilisateur","text":"
    git config --global user.name \"Votre nom\"\n
    "},{"location":"6-Gitlab/Gitlab.html#e-mail","title":"E-mail","text":"
    git config --global user.email \"votreemail@votredomaine.com\"\n

    D\u00e9sormais, chaque fois que vous interagissez avec GitLab, git utilisera ces informations pour vous identifier.

    "},{"location":"6-Gitlab/Gitlab.html#creer-un-jeton-dacces-personnel-pat","title":"Cr\u00e9er un jeton d'acc\u00e8s personnel (PAT)","text":"

    Pour interagir (push, pull) avec n'importe quel r\u00e9f\u00e9rentiel GitLab de Statistique Canada, vous devez cr\u00e9er un jeton d'acc\u00e8s personnel. Suivez ces \u00e9tapes:

    1. Allez sur GitLab.
    2. Cliquez sur votre ic\u00f4ne de profil dans le coin sup\u00e9rieur gauche.
    3. S\u00e9lectionnez Pr\u00e9f\u00e9rences, puis Jetons d'acc\u00e8s.
    "},{"location":"6-Gitlab/Gitlab.html#icone-de-profil","title":"Ic\u00f4ne de profil","text":""},{"location":"6-Gitlab/Gitlab.html#jetons-dacces","title":"Jetons d'acc\u00e8s","text":""},{"location":"6-Gitlab/Gitlab.html#formulaire-de-jeton-dacces-personnel","title":"Formulaire de jeton d'acc\u00e8s personnel","text":"
    • Remplissez le formulaire en fournissant un nom pour le jeton (pour une identification facile), en d\u00e9finissant la date d'expiration du jeton et en accordant des autorisations (par exemple, read_repository et write_repository).
    • Le token expire \u00e0 cette date \u00e0 minuit UTC.
    • Si vous ne saisissez pas de date d'expiration, la date d'expiration est automatiquement fix\u00e9e \u00e0 365 jours apr\u00e8s la date du jour.
    • Par d\u00e9faut, cette date peut \u00eatre post\u00e9rieure au maximum de 365 jours \u00e0 la date du jour.
    "},{"location":"6-Gitlab/Gitlab.html#le-jeton","title":"Le jeton","text":"

    Gardez vos secrets pour vous!

    1. Veuillez NE PAS stocker votre jeton d'acc\u00e8s personnel n'importe o\u00f9 dans le syst\u00e8me de fichiers de votre serveur d'espace de travail. Les contributeurs \u00e0 un espace de noms y auront acc\u00e8s\u00a0!
    2. S'il y a un contributeur externe \u00e0 Statistique Canada dans votre espace de noms, vous perdrez l'acc\u00e8s \u00e0 l'acc\u00e8s principal au cloud GitLab\u00a0!

    Le jeton g\u00e9n\u00e9r\u00e9 pourra \u00eatre copi\u00e9 en haut apr\u00e8s avoir cliqu\u00e9 sur Cr\u00e9er un jeton d'acc\u00e8s personnel. Copiez et enregistrez ce jeton en toute s\u00e9curit\u00e9, car il ne pourra pas \u00eatre r\u00e9cup\u00e9r\u00e9 ult\u00e9rieurement.

    "},{"location":"6-Gitlab/Gitlab.html#fournissez-le-jeton-genere-comme-mot-de-passe-gitlab","title":"Fournissez le jeton g\u00e9n\u00e9r\u00e9 comme mot de passe GitLab","text":"

    Utilisez le jeton g\u00e9n\u00e9r\u00e9 comme mot de passe GitLab lorsque vous y \u00eates invit\u00e9. Voici un exemple de la fa\u00e7on d'incorporer le jeton dans vos commandes\u00a0:

    Nous pouvons utiliser git-credential-cache pour mettre en cache notre nom d'utilisateur et notre mot de passe pendant une p\u00e9riode donn\u00e9e. Entrez simplement ce qui suit dans votre CLI (terminal ou invite de commande)\u00a0:

    git config --global credential.helper cache\n

    Vous pouvez \u00e9galement d\u00e9finir le d\u00e9lai d'attente (en secondes) comme tel\u00a0:

    git config --global credential.helper 'cache --timeout=3600'\n

    Pour plus d'informations sur les jetons d'acc\u00e8s personnels Gitlab, veuillez visiter\u00a0: la documentation officielle. Avec ces \u00e9tapes, vous \u00eates d\u00e9sormais pr\u00eat \u00e0 collaborer de mani\u00e8re transparente sur GitLab\u00a0! Bon codage\u00a0!

    "},{"location":"7-MLOps/Aper%C3%A7u.html","title":"Aper\u00e7u","text":"

    MLOps, ou Machine Learning Operations, fait r\u00e9f\u00e9rence \u00e0 l'ensemble de pratiques et d'outils qui permettent aux organisations de d\u00e9velopper, d\u00e9ployer et maintenir des mod\u00e8les d'apprentissage automatique \u00e0 grande \u00e9chelle. MLOps vise \u00e0 rationaliser le processus de bout en bout de cr\u00e9ation et de d\u00e9ploiement de mod\u00e8les d'apprentissage automatique en int\u00e9grant les diff\u00e9rentes \u00e9tapes du cycle de vie de l'apprentissage automatique dans un flux de travail coh\u00e9rent et automatis\u00e9.

    MLOps implique une gamme d'activit\u00e9s diff\u00e9rentes, notamment la pr\u00e9paration et le pr\u00e9traitement des donn\u00e9es, la formation et l'optimisation des mod\u00e8les, le d\u00e9ploiement et la maintenance des mod\u00e8les, la surveillance et la maintenance, ainsi que l'am\u00e9lioration continue. Certains des composants cl\u00e9s de MLOps incluent\u00a0:

    1. Gestion des donn\u00e9es\u00a0: MLOps implique la gestion et le traitement de grandes quantit\u00e9s de donn\u00e9es pour garantir la qualit\u00e9 et l'exactitude des mod\u00e8les d'apprentissage automatique. Cela implique des activit\u00e9s telles que le nettoyage des donn\u00e9es, l'int\u00e9gration des donn\u00e9es et la transformation des donn\u00e9es.

    2. Formation et optimisation des mod\u00e8les\u00a0: MLOps implique le d\u00e9veloppement et le test de mod\u00e8les d'apprentissage automatique, ainsi que leur optimisation en termes de performances et de pr\u00e9cision. Cela peut impliquer d'exp\u00e9rimenter diff\u00e9rents algorithmes, hyperparam\u00e8tres et techniques de pr\u00e9traitement des donn\u00e9es.

    3. D\u00e9ploiement de mod\u00e8les\u00a0: MLOps implique le d\u00e9ploiement de mod\u00e8les d'apprentissage automatique dans des environnements de production, les rendant disponibles pour une utilisation dans des applications du monde r\u00e9el. Cela peut impliquer la conteneurisation des mod\u00e8les pour un d\u00e9ploiement et une mise \u00e0 l'\u00e9chelle faciles, ainsi que la configuration d'API et d'autres interfaces pour la diffusion de mod\u00e8les.

    4. Surveillance et maintenance\u00a0: MLOps implique la surveillance des mod\u00e8les d'apprentissage automatique en production pour garantir qu'ils fonctionnent comme pr\u00e9vu. Cela peut impliquer la configuration d'alertes et de notifications en cas de d\u00e9faillance du mod\u00e8le, ainsi que la mise en \u0153uvre de processus de maintenance et de mise \u00e0 jour du mod\u00e8le.

    5. Am\u00e9lioration continue\u00a0: MLOps implique l'am\u00e9lioration continue des mod\u00e8les d'apprentissage automatique au fil du temps, sur la base des commentaires des utilisateurs et de l'analyse continue des donn\u00e9es de performances. Cela peut impliquer de recycler les mod\u00e8les avec de nouvelles donn\u00e9es ou d'int\u00e9grer les commentaires des utilisateurs pour affiner les mod\u00e8les.

    Afin de mettre en \u0153uvre efficacement les MLOps, les organisations doivent g\u00e9n\u00e9ralement adopter une gamme d'outils et de technologies diff\u00e9rents, notamment des plates-formes de gestion de donn\u00e9es, des cadres d'apprentissage automatique, des outils de conteneurisation et des outils de surveillance et de journalisation. Ils doivent \u00e9galement \u00e9tablir des flux de travail et des processus clairs pour g\u00e9rer les diff\u00e9rentes \u00e9tapes du cycle de vie du machine learning, ainsi que mettre en \u0153uvre des mesures de gouvernance et de conformit\u00e9 pour garantir la confidentialit\u00e9 et la s\u00e9curit\u00e9 des donn\u00e9es.

    En r\u00e9sum\u00e9, MLOps est un composant essentiel du cycle de vie du machine learning, permettant aux organisations de d\u00e9velopper, d\u00e9ployer et maintenir des mod\u00e8les de machine learning \u00e0 grande \u00e9chelle. En adoptant les pratiques et outils MLOps, les organisations peuvent rationaliser leurs flux de travail d'apprentissage automatique, am\u00e9liorer la pr\u00e9cision et les performances des mod\u00e8les et offrir plus de valeur aux utilisateurs et aux parties prenantes.

    "},{"location":"7-MLOps/Integration-PaaS.html","title":"Aper\u00e7u","text":"

    L'un des principaux avantages de la plateforme ETAA est sa capacit\u00e9 \u00e0 s'int\u00e9grer aux plateformes d'apprentissage automatique populaires telles que Databricks et AzureML.

    L'Espace de travail d'analyse avanc\u00e9e (ETAA) est une plateforme d'analyse de donn\u00e9es open source con\u00e7ue pour \u00eatre hautement int\u00e9grable. Cela signifie qu'il peut \u00eatre facilement int\u00e9gr\u00e9 \u00e0 d'autres plates-formes et outils pour \u00e9tendre ses capacit\u00e9s et rationaliser les flux de travail.

    Un exemple de diagramme illustrant une strat\u00e9gie de connexion PaaS possible\u00a0:

    Configuration\u00a0: Si vous avez besoin d'aide pour int\u00e9grer une offre de plateforme en tant que service, nous serons heureux de vous aider!

    "},{"location":"7-MLOps/Integration-PaaS.html#integration-avec-les-offres-de-plateforme-externe-en-tant-que-service-paas","title":"Int\u00e9gration avec les offres de plateforme externe en tant que service (PaaS)","text":"

    L'int\u00e9gration est la cl\u00e9 du succ\u00e8s.

    Notre plateforme open source offre une optionnalit\u00e9 in\u00e9gal\u00e9e \u00e0 nos utilisateurs. En permettant aux utilisateurs d'utiliser des outils open source, nous leur permettons d'utiliser leurs cadres pr\u00e9f\u00e9r\u00e9s de science des donn\u00e9es et d'apprentissage automatique. Mais la v\u00e9ritable puissance de notre plateforme vient de sa capacit\u00e9 \u00e0 s'int\u00e9grer \u00e0 de nombreuses offres Platform as a Service (PaaS), comme Databricks ou AzureML. Cela signifie que nos utilisateurs peuvent tirer parti de la puissance du cloud pour ex\u00e9cuter des pipelines complexes de traitement de donn\u00e9es et d\u2019apprentissage automatique \u00e0 grande \u00e9chelle. Avec la possibilit\u00e9 de s'int\u00e9grer aux offres PaaS, notre plateforme permet \u00e0 nos utilisateurs de faire passer leur travail au niveau sup\u00e9rieur, en leur donnant le pouvoir d'adapter facilement leurs charges de travail et de profiter des derni\u00e8res innovations dans le domaine de la science des donn\u00e9es et des machines. apprentissage. En offrant ce niveau d'optionnalit\u00e9, nous garantissons que nos utilisateurs peuvent toujours choisir le bon outil pour le travail et garder une longueur d'avance dans un domaine en constante \u00e9volution.

    Nous pouvons int\u00e9grer de nombreuses offres Platform as a Service (PaaS), comme Databricks ou AzureML.

    "},{"location":"7-MLOps/Integration-PaaS.html#databricks","title":"Databricks","text":"
    • Databricks de Microsoft

    Databricks est une plateforme bas\u00e9e sur le nuage qui fournit une plateforme d'analyse unifi\u00e9e pour le traitement du Big Data et l'apprentissage automatique. Avec son puissant moteur informatique distribu\u00e9 et ses outils de flux de travail rationalis\u00e9s, Databricks est un choix populaire pour cr\u00e9er et d\u00e9ployer des mod\u00e8les d'apprentissage automatique. En s'int\u00e9grant \u00e0 Databricks, la plateforme ETAA peut exploiter ses capacit\u00e9s informatiques distribu\u00e9es pour former et d\u00e9ployer des mod\u00e8les d'apprentissage automatique \u00e0 grande \u00e9chelle.

    "},{"location":"7-MLOps/Integration-PaaS.html#azureml","title":"AzureML","text":"
    • Azure ML de Microsoft

    AzureML est une autre plate-forme d'apprentissage automatique populaire qui fournit une large gamme d'outils pour cr\u00e9er, former et d\u00e9ployer des mod\u00e8les d'apprentissage automatique. En s'int\u00e9grant \u00e0 AzureML, la plateforme ETAA peut tirer parti de ses puissants outils de cr\u00e9ation et de formation de mod\u00e8les, ainsi que de sa capacit\u00e9 \u00e0 d\u00e9ployer des mod\u00e8les dans le nuage.

    "},{"location":"7-MLOps/Integration-PaaS.html#exemples","title":"Exemples","text":"

    Des exemples de la fa\u00e7on d'int\u00e9grer la plate-forme ETAA avec ces plates-formes et d'autres peuvent \u00eatre trouv\u00e9s sur le r\u00e9f\u00e9rentiel MLOps Github.

    • D\u00e9p\u00f4t Github MLOps

    Ce r\u00e9f\u00e9rentiel contient une gamme d'exemples et de didacticiels permettant d'utiliser la plateforme ETAA dans divers flux de travail d'apprentissage automatique, notamment la pr\u00e9paration des donn\u00e9es, la formation de mod\u00e8les et le d\u00e9ploiement de mod\u00e8les.

    "},{"location":"7-MLOps/Integration-PaaS.html#conclusion","title":"Conclusion","text":"

    En s'int\u00e9grant \u00e0 des plateformes d'apprentissage automatique populaires telles que Databricks et AzureML, la plateforme ETAA fournit une solution puissante et flexible pour cr\u00e9er, d\u00e9ployer et g\u00e9rer des flux de travail d'apprentissage automatique \u00e0 grande \u00e9chelle.

    En tirant parti des int\u00e9grations et des outils fournis par ces plateformes, les data scientists et les ing\u00e9nieurs en apprentissage automatique peuvent acc\u00e9l\u00e9rer leurs flux de travail et obtenir de meilleurs r\u00e9sultats avec moins d'efforts.

    "},{"location":"7-MLOps/Modele-ML-stockage.html","title":"Donn\u00e9es B prot\u00e9g\u00e9es par Statcan","text":"

    Prot\u00e9g\u00e9 B

    L'ETAA est certifi\u00e9 pour l'h\u00e9bergement de donn\u00e9es Prot\u00e9g\u00e9 B\u00a0!

    Afin de t\u00e9l\u00e9charger des donn\u00e9es Prot\u00e9g\u00e9 B vers l'ETAA, les utilisateurs devront demander l'acc\u00e8s via la Customer Success Unit (CSU). Les utilisateurs d'ETAA devront \u00e9galement fournir un espace de noms, trouver un sponsor et obtenir l'approbation d'OPMIC. Une fois le processus approuv\u00e9, notre \u00e9quipe Fair Data Infrastructure (FDI) cr\u00e9era ensuite un dossier sur Net A qui \u00e0 son tour donnera acc\u00e8s aux utilisateurs via l'annuaire actif. Les donn\u00e9es pourront ensuite \u00eatre transf\u00e9r\u00e9es de Net A vers le nuage ETAA

    Le stockage des mod\u00e8les d'apprentissage automatique dans un environnement de stockage cloud prot\u00e9g\u00e9 est essentiel pour garantir la s\u00e9curit\u00e9 et la confidentialit\u00e9 des donn\u00e9es sensibles. L'espace de travail d'analyse avanc\u00e9e (ETAA) fournit un environnement de nuage stockage s\u00e9curis\u00e9 et robuste qui peut \u00eatre utilis\u00e9 pour stocker des mod\u00e8les d'apprentissage automatique et d'autres actifs de donn\u00e9es.

    La plate-forme ETAA fournit un environnement de nuage stockage prot\u00e9g\u00e9 con\u00e7u pour r\u00e9pondre aux exigences les plus strictes en mati\u00e8re de s\u00e9curit\u00e9 et de confidentialit\u00e9 des donn\u00e9es. L'environnement de stockage est prot\u00e9g\u00e9 par un cryptage et des contr\u00f4les d'acc\u00e8s conformes aux normes de l'industrie, ce qui garantit que seul le personnel autoris\u00e9 peut acc\u00e9der aux donn\u00e9es sensibles. Cela prot\u00e8ge contre les acc\u00e8s non autoris\u00e9s, les violations de donn\u00e9es et autres menaces de s\u00e9curit\u00e9.

    En plus de ses fonctionnalit\u00e9s de s\u00e9curit\u00e9 robustes, l'environnement de nuage stockage ETAA est \u00e9galement hautement \u00e9volutif et flexible. Cela signifie que les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique peuvent facilement faire \u00e9voluer leurs besoins de stockage \u00e0 mesure que leurs ensembles de donn\u00e9es et la taille de leurs mod\u00e8les augmentent. Cela leur permet de stocker et de g\u00e9rer de gros volumes de donn\u00e9es et de mod\u00e8les sans avoir \u00e0 se soucier des limitations de stockage ou des goulots d'\u00e9tranglement des performances.

    Le stockage des mod\u00e8les d'apprentissage automatique dans un environnement de stockage en nuage prot\u00e9g\u00e9 sur l'espace de travail d'analyse avanc\u00e9e fournit une solution s\u00e9curis\u00e9e, \u00e9volutive et flexible pour g\u00e9rer et prot\u00e9ger les donn\u00e9es sensibles. En tirant parti des capacit\u00e9s de nuage stockage fournies par la plateforme ETAA, les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique peuvent se concentrer sur la cr\u00e9ation et le d\u00e9ploiement de leurs mod\u00e8les en toute confiance, sachant que leurs donn\u00e9es sont prot\u00e9g\u00e9es et s\u00e9curis\u00e9es.

    "},{"location":"7-MLOps/Modele-ML-stockage.html#stockage-en-ligne","title":"Stockage en ligne","text":"

    Avantages du nuage de stockage

    Le stockage en nuage offre plusieurs avantages pour la science des donn\u00e9es et l'apprentissage automatique, notamment en termes d'\u00e9volutivit\u00e9, d'accessibilit\u00e9 et de rentabilit\u00e9.

    Premi\u00e8rement, le stockage dans le nuage permet aux scientifiques des donn\u00e9es de stocker et de traiter de grandes quantit\u00e9s de donn\u00e9es sans avoir \u00e0 se soucier des limites du stockage local. Ceci est particuli\u00e8rement important dans le contexte de l\u2019apprentissage automatique, o\u00f9 de grands ensembles de donn\u00e9es sont n\u00e9cessaires pour la formation et le test des mod\u00e8les. Le stockage dans le nuage permet aux scientifiques des donn\u00e9es d'augmenter leur capacit\u00e9 de stockage selon leurs besoins, sans avoir \u00e0 investir dans du mat\u00e9riel co\u00fbteux.

    Deuxi\u00e8mement, le stockage dans le nuage permet aux scientifiques des donn\u00e9es d'acc\u00e9der aux donn\u00e9es de n'importe o\u00f9, en utilisant n'importe quel appareil dot\u00e9 d'une connexion Internet. Cela permet la collaboration entre des \u00e9quipes g\u00e9ographiquement r\u00e9parties et permet aux scientifiques des donn\u00e9es de travailler \u00e0 distance. De plus, le stockage dans le nuage facilite le partage de donn\u00e9es avec d'autres parties prenantes, telles que des partenaires commerciaux ou des clients. Enfin, le stockage dans le nuage est g\u00e9n\u00e9ralement plus rentable que le stockage sur site, en particulier pour les petites organisations ou celles disposant de ressources informatiques limit\u00e9es.

    Dans l\u2019ensemble, le stockage dans le nuage est une solution fiable et pratique pour stocker et g\u00e9rer vos donn\u00e9es. Que vous ayez besoin de stocker de grandes quantit\u00e9s de donn\u00e9es ou seulement quelques fichiers, le stockage dans le 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 (\u00e9galement appel\u00e9s Volumes sur l'\u00e9cran de cr\u00e9ation de Kubeflow Serveur Bloc-notes)
    • Lacs de donnees (\u00e0 venir)

    Selon votre cas d'utilisation, le disque ou le compartiment peuvent \u00eatre les plus adapt\u00e9s. Notre aper\u00e7u du stockage vous aidera \u00e0 les comparer.

    "},{"location":"7-MLOps/Modele-ML-stockage.html#disques","title":"Disques","text":"

    Disques sont ajout\u00e9s \u00e0 votre serveur bloc-notes en augmentant les volumes de donn\u00e9es.

    "},{"location":"7-MLOps/Modele-ML-stockage.html#lacs-de-donnees-a-venir","title":"Lacs de donn\u00e9es (\u00e0 venir)","text":"

    Un lac de donn\u00e9es est un r\u00e9f\u00e9rentiel central qui vous permet de stocker toutes vos donn\u00e9es structur\u00e9es et non structur\u00e9es \u00e0 n'importe quelle \u00e9chelle. C'est un moyen rentable de stocker et de g\u00e9rer tous les types de donn\u00e9es, des donn\u00e9es brutes aux donn\u00e9es trait\u00e9es, et c'est un outil essentiel pour les scientifiques des donn\u00e9es.

    L\u2019un des principaux avantages d\u2019un lac de donn\u00e9es est sa flexibilit\u00e9. Il permet de stocker tous types de donn\u00e9es sans avoir besoin de d\u00e9finir un sch\u00e9ma au pr\u00e9alable, ce qui est particuli\u00e8rement utile lorsqu'il s'agit de donn\u00e9es non structur\u00e9es. Cette flexibilit\u00e9 permet aux scientifiques des donn\u00e9es d'explorer, d'exp\u00e9rimenter et d'extraire facilement des informations \u00e0 partir de leurs donn\u00e9es sans \u00eatre contraints par les limites d'une base de donn\u00e9es relationnelle traditionnelle.

    Les lacs de donn\u00e9es permettent \u00e9galement aux scientifiques des donn\u00e9es de centraliser leurs donn\u00e9es, facilitant ainsi la gestion et l'analyse de gros volumes de donn\u00e9es provenant de diverses sources. Avec un lac de donn\u00e9es, les scientifiques des donn\u00e9es peuvent facilement ing\u00e9rer et stocker des donn\u00e9es provenant de diverses sources, telles que des bases de donn\u00e9es, le stockage cloud et des API tierces. De plus, les lacs de donn\u00e9es fournissent souvent des fonctionnalit\u00e9s de gouvernance des donn\u00e9es, de gestion des m\u00e9tadonn\u00e9es et de contr\u00f4le d'acc\u00e8s, ce qui permet de garantir que les donn\u00e9es sont de haute qualit\u00e9 et conformes aux r\u00e9glementations en vigueur.

    De plus, les lacs de donn\u00e9es bas\u00e9s sur le cloud offrent des solutions de stockage \u00e9volutives et rentables qui peuvent \u00eatre facilement \u00e9tendues d'un simple clic. \u00c0 mesure que les besoins de stockage des donn\u00e9es des scientifiques des donn\u00e9es augmentent, ils peuvent ajouter une capacit\u00e9 de stockage suppl\u00e9mentaire \u00e0 leur lac de donn\u00e9es avec un minimum d'effort, sans se soucier de l'infrastructure ou de la maintenance sous-jacente.

    Dans l'ensemble, les lacs de donn\u00e9es sont un outil essentiel pour les scientifiques des donn\u00e9es, car ils offrent la flexibilit\u00e9, l'\u00e9volutivit\u00e9 et la facilit\u00e9 d'utilisation n\u00e9cessaires pour stocker et g\u00e9rer de grands volumes de donn\u00e9es, permettant aux data scientists de se concentrer sur l'extraction d'informations et de valeur \u00e0 partir des donn\u00e9es.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html","title":"Formation de mod\u00e8les d'apprentissage automatique sur l'ETAA","text":"

    Info

    La formation de mod\u00e8les d'apprentissage automatique implique l'utilisation d'algorithmes pour apprendre des mod\u00e8les et des relations dans les donn\u00e9es. Ce processus implique d'identifier les caract\u00e9ristiques ou les variables pertinentes pour le probl\u00e8me en question et d'utiliser ces caract\u00e9ristiques pour effectuer des pr\u00e9dictions ou des classifications.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#pourquoi-sentrainer-avec-nous","title":"Pourquoi s'entra\u00eener avec nous ?","text":"

    La formation de mod\u00e8les d'apprentissage automatique sur Advanced Analytics Workspace (AAW) pr\u00e9sente plusieurs avantages.

    1. Code Logiciel Ouvert\u00a0: L'ETAA est une plate-forme de donn\u00e9es open source h\u00e9berg\u00e9e par Statistique Canada qui offre un acc\u00e8s s\u00e9curis\u00e9 (Prot\u00e9g\u00e9 B) \u00e0 une vari\u00e9t\u00e9 de sources de donn\u00e9es, y compris les donn\u00e9es de recensement, les enqu\u00eates et les dossiers administratifs. Ces donn\u00e9es peuvent \u00eatre utilis\u00e9es pour former des mod\u00e8les d'apprentissage automatique et g\u00e9n\u00e9rer des informations susceptibles d'\u00e9clairer les d\u00e9cisions politiques et d'am\u00e9liorer les processus m\u00e9tier.

    2. Polyvalent\u00a0: L'ETAA est con\u00e7u pour g\u00e9rer des ensembles de donn\u00e9es volumineux et complexes. Il donne acc\u00e8s \u00e0 une gamme d'outils d'analyse avanc\u00e9s, dans le langage de votre choix, notamment Python, R et SAS, qui peuvent \u00eatre utilis\u00e9s pour pr\u00e9traiter les donn\u00e9es, former des mod\u00e8les d'apprentissage automatique et g\u00e9n\u00e9rer des visualisations. \u00c9tant donn\u00e9 que l'ETAA exploite les technologies cloud, les utilisateurs peuvent augmenter leur puissance de calcul selon leurs besoins*. *

    3. S\u00e9curis\u00e9\u00a0: L'ETAA est une plateforme s\u00e9curis\u00e9e (Prot\u00e9g\u00e9e B) qui adh\u00e8re aux normes les plus \u00e9lev\u00e9es en mati\u00e8re de confidentialit\u00e9 et de s\u00e9curit\u00e9 des donn\u00e9es. Les donn\u00e9es peuvent \u00eatre stock\u00e9es et trait\u00e9es sur la plateforme sans risque d'acc\u00e8s non autoris\u00e9 ou de violation de donn\u00e9es.
    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#mlops-et-pipelines-de-donnees","title":"MLOps et pipelines de donn\u00e9es","text":"

    Optimiser les flux de donn\u00e9es

    Les MLOps et les pipelines de donn\u00e9es sont des outils importants utilis\u00e9s dans le domaine de la science des donn\u00e9es pour g\u00e9rer et optimiser les flux de travail de donn\u00e9es.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#mlops","title":"MLOps","text":"

    MLOps fait r\u00e9f\u00e9rence \u00e0 l'ensemble de pratiques et d'outils utilis\u00e9s pour g\u00e9rer l'ensemble du cycle de vie d'un mod\u00e8le d'apprentissage automatique. Cela comprend tout, depuis le d\u00e9veloppement et la formation du mod\u00e8le jusqu'\u00e0 son d\u00e9ploiement en production et sa maintenance au fil du temps. MLOps garantit que les mod\u00e8les d'apprentissage automatique sont fiables, pr\u00e9cis et \u00e9volutifs, et qu'ils peuvent \u00eatre mis \u00e0 jour et am\u00e9lior\u00e9s selon les besoins.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#pipelines-de-donnees","title":"Pipelines de donn\u00e9es","text":"

    Les pipelines de donn\u00e9es sont une s\u00e9rie d'\u00e9tapes qui permettent de d\u00e9placer les donn\u00e9es d'un syst\u00e8me ou d'une application \u00e0 un autre. Cela inclut la collecte, le nettoyage, la transformation et le stockage des donn\u00e9es, ainsi que leur r\u00e9cup\u00e9ration en cas de besoin. Les pipelines de donn\u00e9es sont importants pour garantir que les donn\u00e9es sont exactes, fiables et accessibles \u00e0 ceux qui en ont besoin.

    Automatisation et fiabilit\u00e9

    Les MLOps et les pipelines de donn\u00e9es aident les organisations \u00e0 g\u00e9rer le processus complexe consistant \u00e0 travailler avec de grandes quantit\u00e9s de donn\u00e9es et \u00e0 d\u00e9velopper des mod\u00e8les d'apprentissage automatique. En automatisant ces processus et en garantissant que les donn\u00e9es sont exactes et fiables, les organisations peuvent \u00e9conomiser du temps et des ressources tout en prenant de meilleures d\u00e9cisions bas\u00e9es sur des informations bas\u00e9es sur les donn\u00e9es.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#pourquoi-des-mlops-conteneurises","title":"Pourquoi des MLOps conteneuris\u00e9s\u00a0?","text":"

    Les avantages de l'utilisation d'une approche conteneuris\u00e9e pour la formation de mod\u00e8les d'apprentissage automatique avec flux de travail Argo incluent\u00a0:

    1. Reproductibilit\u00e9\u00a0: La conteneurisation du mod\u00e8le d'apprentissage automatique et de ses d\u00e9pendances garantit que l'environnement reste coh\u00e9rent d'une ex\u00e9cution \u00e0 l'autre, ce qui facilite la reproduction des r\u00e9sultats.

    2. \u00c9volutivit\u00e9\u00a0: Les flux de travail Argo peut orchestrer des t\u00e2ches parall\u00e8les et des flux de travail complexes, ce qui facilite l'\u00e9volution du processus de formation selon les besoins.

    3. Portabilit\u00e9\u00a0: Les conteneurs peuvent \u00eatre ex\u00e9cut\u00e9s sur n'importe quelle plate-forme prenant en charge la conteneurisation, ce qui facilite le d\u00e9placement du processus de formation vers diff\u00e9rents environnements ou fournisseurs de cloud.

    4. Collaboration\u00a0: En transf\u00e9rant le conteneur vers un registre de conteneurs, d'autres utilisateurs peuvent facilement t\u00e9l\u00e9charger et utiliser le conteneur \u00e0 leurs propres fins, ce qui facilite la collaboration sur des projets d'apprentissage automatique.

    Lesflux de travail Argo et la conteneurisation offrent une approche puissante et flexible pour la formation de mod\u00e8les d'apprentissage automatique. En tirant parti de ces outils, les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique peuvent cr\u00e9er, d\u00e9ployer et g\u00e9rer des flux de travail d'apprentissage automatique avec facilit\u00e9 et reproductibilit\u00e9.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#comment-former-des-modeles","title":"Comment former des mod\u00e8les","text":"

    Il existe de nombreuses fa\u00e7ons de former des mod\u00e8les d\u2019apprentissage automatique et ce n\u2019est pas \u00e0 nous de dire \u00e0 qui que ce soit comment proc\u00e9der. Cela \u00e9tant dit, nous avons fourni ci-dessous quelques guides sur la fa\u00e7on de former des mod\u00e8les d'apprentissage automatique \u00e0 l'aide des outils disponibles sur l'ETAA. Le premier tutoriel concerne la formation d'un mod\u00e8le simple directement dans un bloc-note JupyterLab. Le deuxi\u00e8me didacticiel suppose que l'utilisateur est plus avanc\u00e9 et souhaite d\u00e9finir un pipeline MLOps pour la formation de mod\u00e8les \u00e0 l'aide des flux de travail Argo.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#creer-un-serveur-de-bloc-note-sur-letaa","title":"Cr\u00e9er un serveur de bloc-note sur l'ETAA","text":"

    Serveurs bloc-notes

    Que vous envisagiez de travailler dans JupyterLab, R Studio ou quelque chose de plus avanc\u00e9 avec les flux de travail Argo, vous aurez besoin du serveur bloc-notes appropri\u00e9. Suivez les instructions trouv\u00e9es ici pour commencer.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#utiliser-jupyterlab","title":"Utiliser JupyterLab","text":"

    JupyterLab est populaire

    La formation de mod\u00e8les d'apprentissage automatique avec JupyterLab est une approche populaire parmi les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique.

    Vous trouverez ici les \u00e9tapes n\u00e9cessaires pour entra\u00eener un mod\u00e8le d'apprentissage automatique avec JupyterLab sur AAW. 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.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#1-importez-les-bibliotheques-requises","title":"1. Importez les biblioth\u00e8ques requises","text":"

    Une fois qu'une session JupyterLab est en cours d'ex\u00e9cution, vous devez importer les biblioth\u00e8ques requises pour votre mod\u00e8le d'apprentissage automatique. Cela pourrait inclure des biblioth\u00e8ques telles que NumPy, Pandas, Scikit-learn, Tensorflow ou PyTorch. Si vous utilisez R, vous aurez besoin de tidyverse, caret et janitor.

    PythonRSASPySAS libraries.py
    #!/usr/bin/env python\n\n# tensorflow et keras pour la cr\u00e9ation et la formation de mod\u00e8les d'apprentissage profond\nimport tensorflow as tf\nfrom tensorflow import keras\n\n# numpy pour les calculs num\u00e9riques\nimport numpy as np\n\n# pandas pour la manipulation et l'analyse des donn\u00e9es\nimport pandas as pd\n\n# matplotlib pour la visualisation de donn\u00e9es \nimport matplotlib.pyplot as plt\n
    libraries.R
    #!/usr/bin/env Rscript\n\n# tidyverse pour des outils impressionnants d'analyse de donn\u00e9es et de munging\nlibrary(tidyverse)\n\n# janitor pour nettoyer vos donn\u00e9es\nlibrary(janitor)\n\n# caret pour un apprentissage automatique facile\nlibrary(caret)\n
    libraries.py
    #!/usr/bin/env python\n\n# la seule biblioth\u00e8que dont vous aurez besoin pour acc\u00e9der \u00e0 SAS depuis Python\nimport saspy\n
    libraries.sas
    \n

    \u00c0 propos du code

    Les exemples de code que vous voyez dans ce document et dans toute la documentation sont fournis \u00e0 des fins d'illustration pour vous aider \u00e0 d\u00e9marrer vos projets. En fonction de la t\u00e2che ou du projet sp\u00e9cifique, d'autres biblioth\u00e8ques et \u00e9tapes peuvent \u00eatre n\u00e9cessaires.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#2-charger-et-pretraiter-les-donnees","title":"2. Charger et pr\u00e9traiter les donn\u00e9es","text":"

    Ensuite, vous devez charger et pr\u00e9traiter les donn\u00e9es que vous utiliserez pour entra\u00eener votre mod\u00e8le d'apprentissage automatique. Cela pourrait inclure le nettoyage des donn\u00e9es, l\u2019extraction de fonctionnalit\u00e9s et la normalisation. Les \u00e9tapes exactes de pr\u00e9traitement que vous devrez effectuer d\u00e9pendront de l'ensemble de donn\u00e9es sp\u00e9cifique avec lequel vous travaillez, des exigences de votre mod\u00e8le d'apprentissage automatique et du travail \u00e0 effectuer.

    PythonRSASPySAS load_data.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport pandas as pd\nfrom sklearn.preprocessing import StandardScaler\n\n# Charger des donn\u00e9es \u00e0 partir d'un fichier CSV\ndata = pd.read_csv('data.csv')\n\n# Nettoyage des donn\u00e9es\u00a0! On peut faire beaucoup plus, c'est fondamental\ndata = data.dropna()  # Drop rows with missing values\ndata = data.drop_duplicates()  # Drop duplicate rows\n\n# Extraction de caract\u00e9ristiques\nX = data[['feature1', 'feature2', 'feature3']]  # Select relevant features\n\n# Normalisation\nscaler = StandardScaler()  # Create a scaler object\nX_norm = scaler.fit_transform(X)  # Normalize the feature values\n
    load_data.R
    #!/usr/bin/env Rscript\n\n# Importer les packages n\u00e9cessaires\nlibrary(tidyverse)\nlibrary(janitor)\n\n# Charger des donn\u00e9es \u00e0 partir d'un fichier CSV\ndata <- read_csv(\"data.csv\")\n\n# Nettoyer les donn\u00e9es en utilisant janitor\ndata_cleaned <- data %>%\n\n# Supprimer les espaces de d\u00e9but/fin dans les noms de colonnes\nclean_names() %>%\n\n# Supprimer les lignes avec des valeurs manquantes\nremove_empty() %>%\n\n# Convertir la colonne de date au format Date\nmutate(date = as.Date(date, format = \"%m/%d/%Y\")) %>%\n\n# Supprimer les lignes en double\ndistinct() %>%\n\n# R\u00e9organiser les colonnes\nselect(date, column2, column1, column3)\n
    load_data.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport saspy\n\n# D\u00e9marrez une session SAS et v\u00e9rifiez les informations de configuration\nsas = saspy.SASsession(cfgname='default')\n\n# Charger des donn\u00e9es \u00e0 partir d'un fichier CSV\ndata = sas.read_csv(\"./data.csv\")\n
    load_data.sas
    /* Lecture d'un fichier d\u00e9limit\u00e9 par des virgules avec une extension .csv */\n /* */\n /* Puisque la valeur DBMS= est CSV, vous n'avez pas besoin d'utiliser DELIMITER= */\n /* d\u00e9claration. Par d\u00e9faut, on suppose que les noms des variables sont en premier */\n /* ligne, donc l'instruction GETNAMES= n'est pas requise. */\n /* */\n /* Cr\u00e9ez un fichier de test d\u00e9limit\u00e9 par des virgules \u00e0 lire en utilisant PROC IMPORT ci-dessous. */\n\n /* Charger les donn\u00e9es depuis un fichier CSV */\nproc import\n    datafile='data.csv'\n    out=data\n    dbms=csv\n    replace; \nrun;\n\n/* Afficher les donn\u00e9es */\nproc print;\nrun;\n
    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#3-divisez-les-donnees-en-ensembles-de-formation-et-de-test","title":"3. Divisez les donn\u00e9es en ensembles de formation et de test","text":"

    Une fois les donn\u00e9es pr\u00e9trait\u00e9es, vous devez les diviser en ensembles de formation et de test. L'ensemble de formation sera utilis\u00e9 pour entra\u00eener le mod\u00e8le d'apprentissage automatique, tandis que l'ensemble de test sera utilis\u00e9 pour \u00e9valuer ses performances.

    PythonRSASPySAS train_test.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(X_norm,\ndata['target'], test_size=0.2, random_state=42)\n
    train_test.R
    #!/usr/bin/env Rscript\n\n# Importer les packages n\u00e9cessaires\nlibrary(caret)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv(\"my-dataset.csv\")\n\n# D\u00e9finir la graine pour la reproductibilit\u00e9\nset.seed(123)\n\n# Divisez l'ensemble de donn\u00e9es en train et test \u00e0 l'aide de la fonction createDataPartition de Caret\ntrain_index <- createDataPartition(data$target_variable, p = 0.7, list = FALSE)\ntrain_data <- data[train_index, ]\ntest_data <- data[-train_index, ]\n
    train_test.py
    #!/usr/bin/env python\n
    train_test.sas
    \n

    Note

    Nous divisons les donn\u00e9es en ensembles d'entra\u00eenement et de test \u00e0 l'aide de la fonction train_test_split de scikit-learn, qui divise al\u00e9atoirement les donn\u00e9es en deux ensembles en fonction de la taille de test sp\u00e9cifi\u00e9e et de la graine al\u00e9atoire.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#4-definir-et-entrainer-le-modele-dapprentissage-automatique","title":"4. D\u00e9finir et entra\u00eener le mod\u00e8le d'apprentissage automatique","text":"

    Avec la r\u00e9partition des donn\u00e9es, vous pouvez d\u00e9sormais d\u00e9finir et entra\u00eener votre mod\u00e8le d'apprentissage automatique \u00e0 l'aide de l'ensemble de formation. Cela pourrait impliquer la s\u00e9lection de l\u2019algorithme appropri\u00e9, le r\u00e9glage des hyperparam\u00e8tres et la validation crois\u00e9e.

    PythonRSASPySAS train.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import train_test_split\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv(\"my-dataset.csv\")\n\n# Divisez l'ensemble de donn\u00e9es en entra\u00eenement et test\nX_train, X_test, y_train, y_test = train_test_split(data.iloc[:, :-1], data.iloc[:, -1], test_size=0.3, random_state=123)\n\n# Entra\u00eener le mod\u00e8le\nmodel = RandomForestClassifier(n_estimators=100, random_state=123)\nmodel.fit(X_train, y_train)\n\n# Imprimer le score de pr\u00e9cision sur les donn\u00e9es de test\nprint(\"Accuracy on test set: {:.3f}\".format(model.score(X_test, y_test)))\n
    train.R
    #!/usr/bin/env Rscript\n\n# Importer les packages n\u00e9cessaires\nlibrary(caret)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv(\"my-dataset.csv\")\n\n# D\u00e9finir la graine pour la reproductibilit\u00e9\nset.seed(123)\n\n# Divisez l'ensemble de donn\u00e9es en train et test \u00e0 l'aide de la fonction curseur createDataPartition\ntrain_index <- createDataPartition(data$target_variable, p = 0.7, list = FALSE)\ntrain_data <- data[train_index, ]\ntest_data <- data[-train_index, ]\n\n# D\u00e9finir le contr\u00f4le de la formation\ntrain_control <- trainControl(method = \"cv\", number = 5)\n\n# Entra\u00eenez le mod\u00e8le \u00e0 l'aide de la fonction d'entra\u00eenement de Caret (la m\u00e9thode = \"rf\" est pour la for\u00eat al\u00e9atoire)\nmodel <- train(target_variable ~ ., data = train_data, method = \"rf\", trControl = train_control)\n\n# Imprimez l'objet mod\u00e8le pour afficher les r\u00e9sultats\nprint(model)\n
    train.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport saspy\nimport pandas as pd\n\n# \u00c9tablir une connexion \u00e0 une session SAS\nsas = saspy.SASsession()\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv(\"my-dataset.csv\")\n\n# T\u00e9l\u00e9chargez l'ensemble de donn\u00e9es sur SAS\nsas_df = sas.df2sd(data, \"mydata\")\n\n# Divisez l'ensemble de donn\u00e9es en train et test\ntrain, test = sas.surveyselect(data=sas_df,\n                            method=\"SRS\",\n                            seed=123,\n                            samprate=0.7,\n                            outall=True,\n                            strata=\"target_variable\",\n                            partind=True)\n\n# Entra\u00eener le mod\u00e8le \u00e0 l'aide de la proc\u00e9dure HPFOREST\nmodel = sas.hpforest(data=train,\n                    target=\"target_variable\",\n                    input=\"input_variable_1-input_variable_n\",\n                    partition=\"rolevar\",\n                    rolevars={\"test\": \"0\", \"train\": \"1\"},\n                    nominals=[\"input_variable_1-input_variable_n\"],\n                    forestopts={\"ntree\": 100, \"seed\": 123})\n\n# Noter le mod\u00e8le sur les donn\u00e9es de test\npredictions = model.predict(newdata=test, out=pred_out)\n\n# Calculer le score de pr\u00e9cision sur les donn\u00e9es de test\naccuracy = sas.freq(data=predictions, tables=\"target_variable*p_target_variable\", nocum=True, nocol=True)\n\n# Imprimer le score de pr\u00e9cision\nprint(\"Accuracy on test set: {:.3f}\".format(accuracy.Frequency.iloc[0, 1] / accuracy.Frequency.iloc[:, 1].sum()))\n\n# Se d\u00e9connecter de la session SAS\nsas.disconnect()\n

    ``` sas title=\"train.sas\" linenums=\"1\" / Charger l'ensemble de donn\u00e9es / proc import datafile=\"my-dataset.csv\" out=mydata dbms=csv replace; run;

    / Diviser l'ensemble de donn\u00e9es en train et test / proc surveyselect data=mydata method=srs seed=123 out=selected outall samprate=0.7; strata target_variable; run;

    /* Entra\u00eener le mod\u00e8le */\nproc hpforest data=selected;\nclass _all_;\ntarget target_variable / level=nominal;\npartition rolevar=target_variable(test=\"0\" train=\"1\");\ninput _all_;\nforest ntree=100 seed=123;\nrun;\n\n/* Noter le mod\u00e8le sur les donn\u00e9es de test */\nproc hpforest predict testdata=selected out=testout;\nrun;\n\n/* Imprimer le score de pr\u00e9cision sur les donn\u00e9es du test */\nproc freq data=testout;\ntables target_variable*p_target_variable / nocum nocol;\nrun;\n```\n
    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#5-evaluer-le-modele","title":"5. \u00c9valuer le mod\u00e8le","text":"

    Apr\u00e8s avoir entra\u00een\u00e9 le mod\u00e8le, vous devez \u00e9valuer ses performances sur l\u2019ensemble de tests. Cela vous donnera une id\u00e9e des performances du mod\u00e8le sur de nouvelles donn\u00e9es invisibles.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#6-deployer-le-modele","title":"6. D\u00e9ployer le mod\u00e8le","text":"

    Enfin, vous pouvez d\u00e9ployer le mod\u00e8le d'apprentissage automatique form\u00e9 dans un environnement de production.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#utiliser-les-flux-de-travail-argo","title":"Utiliser les flux de travail Argo","text":"

    Meilleures pratiques MLOps

    Les flux de travail Argo sont un excellent outil pour tous ceux qui cherchent \u00e0 mettre en \u0153uvre des pratiques MLOps et \u00e0 rationaliser le processus de formation et de d\u00e9ploiement de mod\u00e8les d'apprentissage automatique ou d'autres t\u00e2ches de science des donn\u00e9es telles que ETL.

    Flux de travail Argo est un moteur de flux de travail open source natif pour conteneurs permettant d'orchestrer des t\u00e2ches parall\u00e8les sur Kubernetes. Les flux de travail Argo sont impl\u00e9ment\u00e9s en tant que Kubernetes CRD (Custom Resource Definition). Il est particuli\u00e8rement adapt\u00e9 aux flux de travail d\u2019apprentissage automatique et de science des donn\u00e9es.

    Les flux de travail Argo vous permettent de

    • D\u00e9finir des flux de travail o\u00f9 chaque \u00e9tape du flux est un conteneur.
    • Mod\u00e9lisez des flux de travail en plusieurs \u00e9tapes sous la forme d'une s\u00e9quence de t\u00e2ches ou capturez les d\u00e9pendances entre les t\u00e2ches \u00e0 l'aide d'un graphe acyclique dirig\u00e9 (DAG).
    • Ex\u00e9cutez facilement des t\u00e2ches de calcul intensives pour l'apprentissage automatique ou le traitement des donn\u00e9es en une fraction du temps \u00e0 l'aide de flux de travail Argo sur Kubernetes.
    • Ex\u00e9cutez des pipelines CI/CD de mani\u00e8re native sur Kubernetes sans configurer de produits de d\u00e9veloppement logiciel complexes.

    ce qui facilite la gestion de l'ensemble du pipeline d'apprentissage automatique de bout en bout. Avec les flux de travail Argo, vous pouvez facilement cr\u00e9er des flux de travail qui int\u00e8grent des t\u00e2ches telles que le pr\u00e9traitement des donn\u00e9es, la formation de mod\u00e8les et le d\u00e9ploiement de mod\u00e8les, le tout dans un environnement Kubernetes.

    Voir la section flux de travail argo pour plus de d\u00e9tails.

    "},{"location":"7-MLOps/Modele-Service-ML.html","title":"Introduction \u00e0 la diffusion de mod\u00e8les","text":"

    Dans le contexte des gouvernements, servir des mod\u00e8les d\u2019apprentissage automatique signifie rendre les mod\u00e8les form\u00e9s disponibles pour \u00eatre utilis\u00e9s par d\u2019autres applications et syst\u00e8mes. Cela pourrait inclure la r\u00e9alisation de pr\u00e9dictions ou de classifications bas\u00e9es sur les donn\u00e9es d'entr\u00e9e, ou la fourniture d'informations et de recommandations bas\u00e9es sur les r\u00e9sultats de l'analyse des donn\u00e9es.

    La mise en \u0153uvre de mod\u00e8les d'apprentissage automatique dans un contexte gouvernemental soul\u00e8ve des probl\u00e8mes importants li\u00e9s \u00e0 la confidentialit\u00e9 des donn\u00e9es. Les agences gouvernementales sont souvent charg\u00e9es de collecter et de g\u00e9rer des donn\u00e9es personnelles sensibles, telles que les dossiers m\u00e9dicaux, les donn\u00e9es financi\u00e8res et les casiers judiciaires. Lorsque vous servez des mod\u00e8les d'apprentissage automatique, il est essentiel de garantir que ces donn\u00e9es sont prot\u00e9g\u00e9es et que leur acc\u00e8s est strictement contr\u00f4l\u00e9.

    Pour r\u00e9pondre \u00e0 ces pr\u00e9occupations, les agences gouvernementales doivent mettre en \u0153uvre des mesures robustes de confidentialit\u00e9 et de s\u00e9curit\u00e9 des donn\u00e9es lorsqu'elles servent des mod\u00e8les d'apprentissage automatique. Cela pourrait inclure le chiffrement des donn\u00e9es au repos et en transit, la mise en \u0153uvre de contr\u00f4les d'acc\u00e8s et d'authentification des utilisateurs, ainsi qu'une surveillance r\u00e9guli\u00e8re des violations de donn\u00e9es et des vuln\u00e9rabilit\u00e9s.

    Outre la confidentialit\u00e9 et la s\u00e9curit\u00e9 des donn\u00e9es, il est \u00e9galement important de prendre en compte les implications \u00e9thiques de la mise en \u0153uvre de mod\u00e8les d'apprentissage automatique dans un contexte gouvernemental. Les mod\u00e8les d\u2019apprentissage automatique peuvent \u00eatre biais\u00e9s ou discriminatoires, conduisant \u00e0 un traitement injuste de certains groupes de personnes. Pour att\u00e9nuer ces risques, les agences gouvernementales doivent \u00e9valuer et surveiller soigneusement leurs mod\u00e8les d'apprentissage automatique et prendre des mesures pour rem\u00e9dier \u00e0 tout pr\u00e9jug\u00e9 ou discrimination qui pourrait survenir.

    Dans l\u2019ensemble, la mise en \u0153uvre de mod\u00e8les d\u2019apprentissage automatique dans un contexte gouvernemental n\u00e9cessite un examen attentif de la confidentialit\u00e9 des donn\u00e9es, de la s\u00e9curit\u00e9 et des pr\u00e9occupations \u00e9thiques. En mettant en \u0153uvre des mesures robustes pour prot\u00e9ger les donn\u00e9es personnelles et pr\u00e9venir les pr\u00e9jug\u00e9s, les agences gouvernementales peuvent tirer parti de la puissance de l'apprentissage automatique pour prendre de meilleures d\u00e9cisions et am\u00e9liorer les r\u00e9sultats pour les citoyens tout en pr\u00e9servant la confiance et la transparence.

    "},{"location":"7-MLOps/Modele-Service-ML.html#pourquoi-servir-avec-nous","title":"Pourquoi servir avec nous ?","text":"

    Servir des mod\u00e8les d'apprentissage automatique avec l'Espace de travail d'analyse avanc\u00e9e (ETAA) pr\u00e9sente plusieurs avantages. Premi\u00e8rement, ETAA est une plate-forme d'analyse de donn\u00e9es open source qui donne acc\u00e8s \u00e0 une vari\u00e9t\u00e9 d'outils d'analyse avanc\u00e9s, notamment Python, R et SAS. Cela facilite le d\u00e9ploiement de mod\u00e8les d'apprentissage automatique et leur int\u00e9gration dans les flux de travail existants.

    Deuxi\u00e8mement, l'ETAA prend en charge plusieurs frameworks MLOps, notamment les workflows Couler, Seldon et Argo. Ces frameworks fournissent une gamme de fonctionnalit\u00e9s, notamment la gestion des versions de mod\u00e8les, la diffusion de mod\u00e8les et la surveillance de mod\u00e8les, qui simplifient le processus de d\u00e9ploiement et de gestion des mod\u00e8les d'apprentissage automatique en production.

    Troisi\u00e8mement, l'ETAA fournit une plate-forme s\u00e9curis\u00e9e et \u00e9volutive pour servir des mod\u00e8les d'apprentissage automatique avec le statut Prot\u00e9g\u00e9 B. Les mod\u00e8les peuvent \u00eatre servis \u00e0 l'aide d'environnements conteneuris\u00e9s, tels que Docker, qui offrent un haut niveau d'isolation et de s\u00e9curit\u00e9. L'ETAA donne \u00e9galement acc\u00e8s aux ressources de cloud computing, permettant aux utilisateurs d'augmenter leur puissance de calcul selon leurs besoins pour g\u00e9rer des volumes \u00e9lev\u00e9s de requ\u00eates.

    Enfin, l'ETAA est une plateforme collaborative qui permet aux utilisateurs de partager du code et des donn\u00e9es avec d'autres chercheurs et analystes. Cela favorise une communaut\u00e9 d'utilisateurs qui peuvent apprendre du travail de chacun et collaborer sur des projets n\u00e9cessitant des capacit\u00e9s d'analyse avanc\u00e9es.

    En r\u00e9sum\u00e9, servir des mod\u00e8les d'apprentissage automatique avec Advanced Analytics Workspace donne acc\u00e8s \u00e0 des outils d'analyse avanc\u00e9s, \u00e0 plusieurs frameworks MLOps, \u00e0 une plate-forme Proteced B s\u00e9curis\u00e9e et \u00e9volutive et \u00e0 une communaut\u00e9 collaborative d'utilisateurs, ce qui en fait une plate-forme id\u00e9ale pour les scientifiques et les analystes de donn\u00e9es qui souhaitent pour d\u00e9ployer et g\u00e9rer des mod\u00e8les d\u2019apprentissage automatique en production.

    "},{"location":"7-MLOps/Modele-Service-ML.html#noyau-seldon","title":"Noyau Seldon","text":"

    Seldon Core est une plate-forme open source permettant de d\u00e9ployer, de mettre \u00e0 l'\u00e9chelle et de surveiller des mod\u00e8les d'apprentissage automatique sur Kubernetes. Il fournit un moyen simple et efficace de d\u00e9ployer des mod\u00e8les d'apprentissage automatique sous forme de microservices dans un environnement de production.

    La diffusion de mod\u00e8les d'apprentissage automatique \u00e0 l'aide de Seldon Core implique les \u00e9tapes suivantes\u00a0:

    1. Conditionnement du mod\u00e8le\u00a0: la premi\u00e8re \u00e9tape consiste \u00e0 empaqueter le mod\u00e8le d'apprentissage automatique form\u00e9 dans une image de conteneur avec toutes les d\u00e9pendances requises. Seldon Core prend en charge divers frameworks d'apprentissage automatique, notamment TensorFlow, PyTorch et Scikit-learn.

    2. D\u00e9ploiement du mod\u00e8le\u00a0: une fois l'image du conteneur cr\u00e9\u00e9e, l'\u00e9tape suivante consiste \u00e0 d\u00e9ployer le mod\u00e8le sur Kubernetes \u00e0 l'aide de Seldon Core. Cela implique de d\u00e9finir le fichier de configuration de d\u00e9ploiement, qui sp\u00e9cifie les ressources requises pour le d\u00e9ploiement, telles que le nombre de r\u00e9plicas et les ressources de calcul.

    3. Service de mod\u00e8le\u00a0: une fois le mod\u00e8le d\u00e9ploy\u00e9, Seldon Core expose un point de terminaison d'API REST qui peut \u00eatre utilis\u00e9 pour effectuer des pr\u00e9dictions. Les clients peuvent envoyer des requ\u00eates au point de terminaison avec des donn\u00e9es d'entr\u00e9e, et le mod\u00e8le renverra la sortie correspondante. Seldon Core prend \u00e9galement en charge divers mod\u00e8les de d\u00e9ploiement, tels que le d\u00e9ploiement Canary et les tests A/B, pour permettre une exp\u00e9rimentation et un test faciles de diff\u00e9rents mod\u00e8les.

    4. Surveillance des mod\u00e8les : Seldon Core fournit diverses capacit\u00e9s de surveillance pour suivre les performances des mod\u00e8les d\u00e9ploy\u00e9s. Cela inclut la surveillance en temps r\u00e9el des m\u00e9triques du mod\u00e8le, telles que la latence et le d\u00e9bit, ainsi que la journalisation des donn\u00e9es de requ\u00eate et de r\u00e9ponse \u00e0 des fins de d\u00e9bogage.

    Seldon Core facilite la mise en \u0153uvre de mod\u00e8les d'apprentissage automatique \u00e0 grande \u00e9chelle, avec la prise en charge de la haute disponibilit\u00e9, de l'\u00e9volutivit\u00e9 et de la tol\u00e9rance aux pannes. Il fournit \u00e9galement une int\u00e9gration avec divers outils natifs de Kubernetes, tels que Istio et Prometheus, pour permettre une surveillance et une observabilit\u00e9 avanc\u00e9es.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html","title":"Mod\u00e8les d'apprentissage automatique","text":"

    Les mod\u00e8les d'apprentissage automatique sont des algorithmes informatiques con\u00e7us pour apprendre automatiquement des mod\u00e8les et des relations \u00e0 partir des donn\u00e9es. Ces mod\u00e8les sont form\u00e9s sur un ensemble de donn\u00e9es, qui est g\u00e9n\u00e9ralement une collection d'exemples ou d'instances, chacun \u00e9tant constitu\u00e9 d'un ensemble de fonctionnalit\u00e9s ou de variables, ainsi que d'une variable ou d'une sortie cible.

    L\u2019objectif d\u2019un mod\u00e8le d\u2019apprentissage automatique est d\u2019identifier des mod\u00e8les et des relations au sein des donn\u00e9es qui peuvent \u00eatre utilis\u00e9s pour faire des pr\u00e9dictions ou prendre des d\u00e9cisions concernant de nouvelles donn\u00e9es invisibles. Cela implique de d\u00e9velopper une repr\u00e9sentation math\u00e9matique de la relation entre les caract\u00e9ristiques d'entr\u00e9e et la variable de sortie, bas\u00e9e sur les mod\u00e8les observ\u00e9s dans les donn\u00e9es d'entra\u00eenement. Une fois le mod\u00e8le entra\u00een\u00e9, il peut \u00eatre utilis\u00e9 pour faire des pr\u00e9dictions ou prendre des d\u00e9cisions sur de nouvelles donn\u00e9es invisibles.

    Il existe plusieurs types de mod\u00e8les d'apprentissage automatique, chacun \u00e9tant con\u00e7u pour r\u00e9soudre diff\u00e9rents types de probl\u00e8mes ou de donn\u00e9es. Certains des types de mod\u00e8les d\u2019apprentissage automatique les plus courants incluent\u00a0:

    1. Mod\u00e8les de r\u00e9gression\u00a0: Les mod\u00e8les de r\u00e9gression sont utilis\u00e9s pour pr\u00e9dire des valeurs num\u00e9riques continues, telles que les cours des actions ou les prix de l'immobilier.

    2. Mod\u00e8les de classification\u00a0: Les mod\u00e8les de classification sont utilis\u00e9s pour pr\u00e9dire des valeurs cat\u00e9gorielles discr\u00e8tes, par exemple si un client ach\u00e8tera un produit ou non.

    3. Mod\u00e8les de grappe : Les mod\u00e8les de grappe sont utilis\u00e9s pour identifier des groupes ou des clusters au sein d'un ensemble de donn\u00e9es en fonction des similitudes entre les instances.

    4. Mod\u00e8les de recommandation\u00a0: Les mod\u00e8les de recommandation sont utilis\u00e9s pour recommander des produits ou des services aux utilisateurs en fonction de leur comportement ou de leurs pr\u00e9f\u00e9rences pass\u00e9es.

    5. R\u00e9seaux de neurones\u00a0: Les r\u00e9seaux de neurones sont un type de mod\u00e8le d'apprentissage automatique con\u00e7u pour imiter la structure et le fonctionnement du cerveau humain. Ils sont couramment utilis\u00e9s dans les applications de reconnaissance d\u2019images, de reconnaissance vocale et de traitement du langage naturel.

    Les mod\u00e8les d'apprentissage automatique peuvent \u00eatre biais\u00e9s

    Les mod\u00e8les d'apprentissage automatique sont un outil puissant pour analyser et faire des pr\u00e9dictions sur les donn\u00e9es, et ils ont un large \u00e9ventail d'applications dans des domaines tels que la finance, la sant\u00e9, le marketing, etc. Cependant, il est important de noter que les mod\u00e8les d\u2019apprentissage automatique ne sont pas parfaits et peuvent parfois commettre des erreurs ou produire des r\u00e9sultats biais\u00e9s. Par cons\u00e9quent, il est important d\u2019\u00e9valuer et de tester soigneusement les mod\u00e8les d\u2019apprentissage automatique avant de les utiliser dans des applications r\u00e9elles.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemples","title":"Exemples","text":""},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#regression-lineaire","title":"R\u00e9gression lin\u00e9aire","text":"

    R\u00e9gression lin\u00e9aire

    \\[ \\hat{Y}_i = \\hat{\\beta}_0 + \\hat{\\beta}_1 X_i + \\hat{\\epsilon}_i \\]

    O\u00f9 \\(\\hat{Y}_i\\) d\u00e9signe le \\(i\\)i\u00e8me estimateur de la vraie valeur \\(Y\\) bas\u00e9 sur la \\(i\\)i\u00e8me \u00e9poque d'entra\u00eenement. Chaque \\(\\hat{\\beta}\\) est un param\u00e8tre \u00e0 apprendre. \\(\\hat{\\epsilon}_i\\) est la quantit\u00e9 de bruit autoris\u00e9e dans le mod\u00e8le et peut varier en fonction du num\u00e9ro d'\u00e9poque d'entra\u00eenement indiqu\u00e9 par \\(i\\). Chaque \\(X_i\\) repr\u00e9sente le \\(i\\)\u00e8me lot de donn\u00e9es d'entra\u00eenement.

    Dans les mod\u00e8les statistiques classiques comme la r\u00e9gression lin\u00e9aire, l\u2019objectif est de trouver une droite qui correspond le mieux aux donn\u00e9es, nous permettant ainsi de faire des pr\u00e9dictions sur de nouveaux points de donn\u00e9es.

    \u00c0 mesure que la complexit\u00e9 du probl\u00e8me augmente, des algorithmes plus sophistiqu\u00e9s sont n\u00e9cessaires, tels que des arbres de d\u00e9cision, des machines \u00e0 vecteurs de support et des for\u00eats al\u00e9atoires. Cependant, ces m\u00e9thodes ont leurs limites et peuvent ne pas \u00eatre en mesure de capturer des mod\u00e8les complexes dans de grands ensembles de donn\u00e9es.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code","title":"Exemple de code","text":"PythonR linear_regression.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.metrics import mean_squared_error\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Entra\u00eener le mod\u00e8le de r\u00e9gression lin\u00e9aire\nlinear_model = LinearRegression()\nlinear_model.fit(X_train, y_train)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred = linear_model.predict(X_test)\n\n# \u00c9valuer les performances du mod\u00e8le\nmse = mean_squared_error(y_test, y_pred)\nrmse = mse ** 0.5\nprint('Root Mean Squared Error:', rmse)\n
    linear_regression.r
    #!/usr/bin/env Rscript\n\n# D\u00e9finir une graine al\u00e9atoire pour la reproductibilit\u00e9\nset.seed(123)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\ntrain_data <- data[train_index,]\ntest_data <- data[-train_index,]\n\n# Entra\u00eener le mod\u00e8le de r\u00e9gression lin\u00e9aire\nlm_model <- lm(target_variable ~ ., data=train_data)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred <- predict(lm_model, newdata=test_data[,-which(names(test_data)=='target_variable')])\n\n# \u00c9valuer les performances du mod\u00e8le\nmse <- mean((y_pred - test_data$target_variable)^2)\nrmse <- sqrt(mse)\nprint(paste('Root Mean Squared Error:', rmse))\n
    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#machine-a-vecteurs-de-support-svm","title":"Machine \u00e0 vecteurs de support (SVM)","text":"

    SVM

    \\[ \\underset{\\mathbf{w},b,\\boldsymbol{\\xi}}{\\operatorname{minimiser}} \\hspace{0.2cm} \\frac{1}{2} ||\\mathbf{w}||^2 + C \\sum_{i=1}^{N} \\xi_i \\] \\[ \\text{o\u00f9} \\hspace{0.2cm} y_i(\\mathbf{w}^T\\mathbf{x}_i + b) \\geq 1-\\xi_i \\quad \\text{et} \\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\u00f9 \\(\\mathbf{w}\\) est le vecteur de poids, \\(b\\) est le terme de biais et \\(\\boldsymbol{\\xi}\\) est le vecteur variable de rel\u00e2chement. L'objectif est de minimiser la norme L2 du vecteur de poids \\(\\mathbf{w}\\), sous la contrainte que tous les exemples d'entra\u00eenement soient class\u00e9s correctement avec une marge d'au moins 1, plus une tol\u00e9rance pour certaines violations de marge contr\u00f4l\u00e9es par le param\u00e8tre de r\u00e9gularisation \\(C\\). La variable cible \\(y_i\\) prend les valeurs de 1 ou -1, repr\u00e9sentant les deux classes du probl\u00e8me de classification binaire, et \\(\\mathbf{x}_i\\) est le vecteur de caract\u00e9ristiques du \\(i\\)\u00e8me exemple de formation.

    Une machine \u00e0 vecteurs de support (SVM) est un algorithme d'apprentissage automatique supervis\u00e9 qui peut \u00eatre utilis\u00e9 pour la classification, la r\u00e9gression et la d\u00e9tection des valeurs aberrantes. Il s\u2019agit d\u2019un algorithme populaire dans le domaine de l\u2019apprentissage automatique, notamment pour r\u00e9soudre des probl\u00e8mes de classification.

    L'id\u00e9e de base derri\u00e8re SVM est de trouver un hyperplan qui s\u00e9pare au mieux les donn\u00e9es d'entr\u00e9e en diff\u00e9rentes classes. Dans un probl\u00e8me de classification \u00e0 deux classes, l'hyperplan est une ligne qui divise les points de donn\u00e9es d'une classe des points de donn\u00e9es de l'autre classe. SVM essaie de trouver l'hyperplan qui maximise la marge entre les deux classes, la marge \u00e9tant la distance entre l'hyperplan et les points de donn\u00e9es les plus proches de chaque classe.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code_1","title":"Exemple de code","text":"PythonR svm.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.svm import SVC\nfrom sklearn.metrics import accuracy_score\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Entra\u00eener le mod\u00e8le SVM\nsvm_model = SVC(kernel='linear', C=1.0, random_state=42)\nsvm_model.fit(X_train, y_train)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred = svm_model.predict(X_test)\n\n# \u00c9valuer les performances du mod\u00e8le\naccuracy = accuracy_score(y_test, y_pred)\nprint('Accuracy:', accuracy)\n
    svm.r
    #!/usr/bin/env Rscript\n\n# Charger les biblioth\u00e8ques requises\nlibrary(e1071)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nset.seed(123)\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\ntrain_data <- data[train_index,]\ntest_data <- data[-train_index,]\n\n# Entra\u00eener le mod\u00e8le SVM\nsvm_model <- svm(target_variable ~ ., data=train_data, kernel='linear', cost=1)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred <- predict(svm_model, newdata=test_data[,-which(names(test_data)=='target_variable')])\n\n# \u00c9valuer les performances du mod\u00e8le\naccuracy <- mean(y_pred == test_data$target_variable)\nprint(paste('Accuracy:', accuracy))\n
    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#foret-aleatoire","title":"For\u00eat al\u00e9atoire","text":"

    For\u00eat al\u00e9atoire

    \\[ \\hat{y} = \\frac{1}{T} \\sum_{t=1}^{T} f_t(\\mathbf{x}), \\]

    o\u00f9 \\(\\hat{y}\\) est la sortie pr\u00e9dite, \\(f_t(\\mathbf{x})\\) est la pr\u00e9diction du \\(t\\)\u00e8me arbre dans la for\u00eat pour l'entr\u00e9e \\(\\mathbf{x}\\) et $T $ est le nombre d'arbres dans la for\u00eat.

    Les for\u00eats al\u00e9atoires sont une m\u00e9thode d'apprentissage d'ensemble qui peut \u00eatre utilis\u00e9e pour des probl\u00e8mes de classification et de r\u00e9gression. Ils sont souvent utilis\u00e9s pour leur capacit\u00e9 \u00e0 g\u00e9rer des ensembles de donn\u00e9es d'am\u00e9lioration continue \u00e0 forte intensit\u00e9 variable et des relations non lin\u00e9aires entre les caract\u00e9ristiques et les cibles.

    Chaque arbre est form\u00e9 sur un sous-ensemble amorc\u00e9 des donn\u00e9es d'entra\u00eenement d'origine, et \u00e0 chaque division, un sous-ensemble al\u00e9atoire de fonctionnalit\u00e9s est pris en compte pour d\u00e9terminer la division. La pr\u00e9diction finale est obtenue en faisant la moyenne des pr\u00e9dictions de tous les arbres de la for\u00eat.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code_2","title":"Exemple de code","text":"PythonR random_forest.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.ensemble import RandomForestRegressor\nfrom sklearn.metrics import mean_squared_error\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Entra\u00eener le mod\u00e8le de for\u00eat al\u00e9atoire\nrf_model = RandomForestRegressor(n_estimators=100, random_state=42)\nrf_model.fit(X_train, y_train)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred = rf_model.predict(X_test)\n\n# \u00c9valuer les performances du mod\u00e8le\nmse = mean_squared_error(y_test, y_pred)\nrmse = mse ** 0.5\nprint('Root Mean Squared Error:', rmse)\n
    random_forest.r
    #!/usr/bin/env Rscript\n\n# Charger les biblioth\u00e8ques requises\nlibrary(randomForest)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nset.seed(123)\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\ntrain_data <- data[train_index,]\ntest_data <- data[-train_index,]\n\n# Entra\u00eener le mod\u00e8le de for\u00eat al\u00e9atoire\nrf_model <- randomForest(target_variable ~ ., data=train_data, ntree=100, importance=TRUE)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred <- predict(rf_model, newdata=test_data[,-which(names(test_data)=='target_variable')])\n\n# \u00c9valuer les performances du mod\u00e8le\nmse <- mean((y_pred - test_data$target_variable)^2)\nrmse <- sqrt(mse)\nprint(paste('Root Mean Squared Error:', rmse))\n
    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#lapprentissage-en-profondeur","title":"L'apprentissage en profondeur","text":"

    L'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\u00f9 \\(\\mathbf{x}\\) est le vecteur d'entr\u00e9e, \\(\\mathbf{W}_i\\) et \\(\\mathbf{b}_i\\) sont respectivement la matrice de poids et le vecteur de biais pour la \\(i\\)\u00e8me couche, et $ f$ est la fonction d'activation.

    Cette formule repr\u00e9sente un r\u00e9seau neuronal \u00e0 action directe avec des couches \\(L\\), o\u00f9 chaque couche applique une transformation lin\u00e9aire \u00e0 la sortie de la couche pr\u00e9c\u00e9dente, suivie d'une fonction d'activation non lin\u00e9aire. La sortie de la couche finale, \\(\\hat{y}\\), repr\u00e9sente la sortie pr\u00e9vue du r\u00e9seau neuronal pour l'entr\u00e9e donn\u00e9e \\(\\mathbf{x}\\).

    L'apprentissage profond est un sous-ensemble de l'apprentissage automatique qui implique la formation de r\u00e9seaux de neurones comportant de nombreuses couches de n\u0153uds interconnect\u00e9s. Cette approche peut g\u00e9rer des ensembles de donn\u00e9es volumineux et complexes et est utilis\u00e9e dans un large \u00e9ventail d'applications, notamment la reconnaissance d'images, le traitement du langage naturel et la reconnaissance vocale. Le processus de formation consiste \u00e0 alimenter le r\u00e9seau neuronal avec un grand ensemble de donn\u00e9es et \u00e0 ajuster les poids des connexions entre les n\u0153uds pour minimiser l'erreur entre les sorties pr\u00e9dites et les sorties r\u00e9elles. Gr\u00e2ce \u00e0 des it\u00e9rations r\u00e9p\u00e9t\u00e9es, le r\u00e9seau neuronal peut apprendre \u00e0 reconna\u00eetre des mod\u00e8les dans les donn\u00e9es et \u00e0 faire des pr\u00e9dictions pr\u00e9cises sur les nouvelles donn\u00e9es.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code_3","title":"Exemple de code","text":"PythonR deep_learning.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.metrics import accuracy_score\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Standardiser les fonctionnalit\u00e9s d'entr\u00e9e\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n\n# D\u00e9finir le mod\u00e8le d'apprentissage profond\nmodel = keras.Sequential([\n    keras.layers.Dense(64, activation='relu', input_shape=[X_train_scaled.shape[1]]),\n    keras.layers.Dropout(0.2),\n    keras.layers.Dense(1, activation='sigmoid')\n])\n\n# Compiler le mod\u00e8le\nmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n# Entra\u00eener le mod\u00e8le\nhistory = model.fit(X_train_scaled, y_train, epochs=50, batch_size=32, validation_split=0.1)\n\n# \u00c9valuer les performances du mod\u00e8le\ny_pred = model.predict_classes(X_test_scaled)\naccuracy = accuracy_score(y_test, y_pred)\nprint('Accuracy:', accuracy)\n
    deep_learning.r
    #!/usr/bin/env Rscript\n\n# Charger les biblioth\u00e8ques requises\nlibrary(keras)\nlibrary(tensorflow)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- iris\nx <- as.matrix(data[, 1:4])\ny <- to_categorical(as.numeric(data[, 5]) - 1)\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nset.seed(123)\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\nx_train <- x[train_index,]\ny_train <- y[train_index,]\nx_test <- x[-train_index,]\ny_test <- y[-train_index,]\n\n# D\u00e9finir l'architecture du r\u00e9seau de neurones\nmodel <- keras_model_sequential() %>%\nlayer_dense(units = 8, input_shape = c(4)) %>%\nlayer_activation('relu') %>%\nlayer_dense(units = 3) %>%\nlayer_activation('softmax')\n\n# Compiler le mod\u00e8le\nmodel %>% compile(\nloss = 'categorical_crossentropy',\noptimizer = 'adam',\nmetrics = c('accuracy')\n)\n\n# Entra\u00eener le mod\u00e8le\nhistory <- model %>% fit(\nx_train, y_train,\nepochs = 50,\nbatch_size = 10,\nvalidation_split = 0.2,\nverbose = 0\n)\n\n# \u00c9valuer les performances du mod\u00e8le\nmetrics <- model %>% evaluate(x_test, y_test)\nprint(paste('Test Loss:', metrics[1]))\nprint(paste('Test Accuracy:', metrics[2]))\n\n# Tracez la pr\u00e9cision de la formation et de la validation au fil du temps\nplot(history$metrics$accuracy, type='l', col='blue', ylim=c(0,1), ylab='Accuracy', xlab='Epoch')\nlines(history$metrics$val_accuracy, type='l', col='red')\nlegend('bottomright', legend=c('Training', 'Validation'), col=c('blue', 'red'), lty=1)\n
    "},{"location":"7-MLOps/Serving.html","title":"Service de mod\u00e8les avec Seldon Core et KFServing","text":"

    \u2692 Cette page est en construction \u2692

    La personne qui \u00e9crit cet article n'en sait pas assez sur cette fonctionnalit\u00e9 pour en parler, mais vous pouvez demander sur notre cha\u00eene Slack.

    "},{"location":"7-MLOps/Serving.html#sans-serveur-avec-knative","title":"Sans serveur avec KNative","text":"

    Kubernetes et KNative permettent \u00e0 vos services d'\u00e9voluer et vers le bas sur demande. Cela vous permet de cr\u00e9er des API pour servir des mod\u00e8les de Machine Learning, sans avoir besoin de g\u00e9rer l\u2019\u00e9quilibrage de charge ou la mise \u00e0 l\u2019\u00e9chelle. La plateforme peut g\u00e9rer toute votre mise \u00e0 l'\u00e9chelle pour vous, afin que vous puissiez vous concentrer sur la logique du programme.

    \u2692 Cette page est en construction \u2692

    La personne qui \u00e9crit cet article n'en sait pas assez \u00e0 ce sujet fonctionnalit\u00e9 pour \u00e9crire \u00e0 ce sujet, mais vous pouvez demander sur notre cha\u00eene Slack.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html","title":"Servir un classificateur d'iris avec Seldon","text":"In\u00a0[\u00a0]: Copied! 
    %%writefile requirements.txt\nscikit-learn\ndill\npandas\nsklearn\nseldon-core\nrequests\nmatplotlib\n
    %%writefile requirements.txt scikit-learn dill pandas sklearn seldon-core requests matplotlib In\u00a0[\u00a0]: Copied! 
    !if [ ! -d \"./venv\" ]; then python -m venv venv; fi\n
    !if [ ! -d \"./venv\" ]; then python -m venv venv; fi In\u00a0[\u00a0]: Copied! 
    !source ./venv/bin/activate\n
    !source ./venv/bin/activate In\u00a0[\u00a0]: Copied! 
    !if [ ! -d \"/home/jovyan/.config/pip\" ]; then mkdir /home/jovyan/.config/pip; fi\n
    !if [ ! -d \"/home/jovyan/.config/pip\" ]; then mkdir /home/jovyan/.config/pip; fi

    Seldon ne fonctionne que dans l'environnement de d\u00e9veloppement ETAA; modifiez pip.conf pour r\u00e9cup\u00e9rer les packages sur internet.

    In\u00a0[\u00a0]: Copied! 
    %%writefile /home/jovyan/.config/pip/pip.conf\n[global]\nindex-url = https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple\n
    %%writefile /home/jovyan/.config/pip/pip.conf [global] index-url = https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple In\u00a0[\u00a0]: Copied! 
    %%capture\n%pip install -r requirements.txt\n
    %%capture %pip install -r requirements.txt

    Nous pouvons ajouter le noyau au lanceur JupyterLab pour une r\u00e9utilisation facile.

    In\u00a0[\u00a0]: Copied! 
    !python -m ipykernel install --user --name=sklearn_iris_jsondata\n
    !python -m ipykernel install --user --name=sklearn_iris_jsondata In\u00a0[\u00a0]: Copied! 
    %%writefile sklearn_iris_jsondata_deployment.yaml\napiVersion: machinelearning.seldon.io/v1alpha2\nkind: SeldonDeployment\nmetadata:\n  name: seldon-deployment-example\n  namespace: bryanpaget\nspec:\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\n
    %%writefile sklearn_iris_jsondata_deployment.yaml apiVersion: machinelearning.seldon.io/v1alpha2 kind: SeldonDeployment metadata: name: seldon-deployment-example namespace: bryanpaget spec: name: sklearn-iris-deployment annotations: sidecar.istio.io/inject: \"false\" predictors: - componentSpecs: - spec: containers: - image: seldonio/sklearn-iris:0.3 imagePullPolicy: IfNotPresent name: sklearn-iris-classifier graph: children: [] endpoint: type: REST name: sklearn-iris-classifier type: MODEL name: sklearn-iris-predictor replicas: 1

    D\u00e9ployez SeldonDeployment.

    In\u00a0[\u00a0]: Copied! 
    !kubectl create -f sklearn_iris_jsondata_deployment.yaml\n
    !kubectl create -f sklearn_iris_jsondata_deployment.yaml In\u00a0[\u00a0]: Copied! 
    !kubectl rollout status deploy \\\n    $(kubectl get deploy -l seldon-deployment-id=seldon-deployment-example \\\n        -o jsonpath='{.items[0].metadata.name}')\n
    !kubectl rollout status deploy \\ $(kubectl get deploy -l seldon-deployment-id=seldon-deployment-example \\ -o jsonpath='{.items[0].metadata.name}')

    Le service est-il disponible ?

    In\u00a0[\u00a0]: Copied! 
    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)\nassert state == \"Available\"\n
    for i in range(60): state = !kubectl get sdep seldon-deployment-example -o jsonpath='{.status.state}' state = state[0] print(state) if state == \"Available\": break time.sleep(1) assert state == \"Available\" In\u00a0[\u00a0]: Copied! 
    import json\nimport pandas as pd\n
    import json import pandas as pd

    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\u00e9s, une pour chacun des trois types de fleurs d'iris. Vous pouvez en savoir plus sur les donn\u00e9es d'iris ici. Envoyons quelques donn\u00e9es au mod\u00e8le.

    In\u00a0[\u00a0]: Copied! 
    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]]}}'\n
    res = !curl -v seldon-deployment-example-sklearn-iris-predictor.bryanpaget.svc.cluster.local:8000/api/v0.1/predictions \\ -H 'Content-Type: application/json' \\ -d '{\"data\": {\"ndarray\": [[5.964, 1.006, 2.081, 1.031]]}}' In\u00a0[\u00a0]: Copied! 
    parsed = json.loads(res[-1])\nprint(json.dumps(parsed, indent=4, sort_keys=True))\n
    parsed = json.loads(res[-1]) print(json.dumps(parsed, indent=4, sort_keys=True))

    Cette fonction de tra\u00e7age r\u00e9v\u00e8le un graphique \u00e0 barres avec l'inf\u00e9rence du classificateur.

    In\u00a0[\u00a0]: Copied! 
    def display_iris_classifier_results(res):\n    \"\"\" Prend les r\u00e9sultats de classification du classificateur d'iris et les trace dans un graphique \u00e0 barres pour une visualisation facile des probabilit\u00e9s de classe.\n\n     Arguments :\n         res (string) : r\u00e9sultats du mod\u00e8le 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\ndisplay_iris_classifier_results(res)\n
    def display_iris_classifier_results(res): \"\"\" Prend les r\u00e9sultats de classification du classificateur d'iris et les trace dans un graphique \u00e0 barres pour une visualisation facile des probabilit\u00e9s de classe. Arguments : res (string) : r\u00e9sultats du mod\u00e8le d'iris servi par Seldon. \"\"\" results = res[-1] results = json.loads(results) names = results[\"data\"][\"names\"] predictions = results[\"data\"][\"ndarray\"][0] model = results[\"meta\"][\"requestPath\"] model = model.popitem() model, version = model[0], model[1] df = pd.DataFrame({\"Class\": names, \"Probability\": predictions}) df.plot( kind=\"bar\", title=model.replace(\"-\", \" \").title(), xlabel=\"Classification\", ylabel=\"Probability\", legend=False ) display_iris_classifier_results(res) In\u00a0[\u00a0]: Copied! 
    !kubectl delete -f sklearn_iris_jsondata_deployment.yaml\n
    !kubectl delete -f sklearn_iris_jsondata_deployment.yaml"},{"location":"7-MLOps/sklearn_iris_jsondata.html#servir-un-classificateur-diris-avec-seldon","title":"Servir un classificateur d'iris avec Seldon\u00b6","text":""},{"location":"7-MLOps/sklearn_iris_jsondata.html#objectif-du-bloc-notes","title":"Objectif du bloc-notes\u00b6","text":"

    L'objectif de ce bloc-notes est d'encapsuler un mod\u00e8le Python \"scikit-learn\" \u00e0 utiliser comme microservice de pr\u00e9diction avec Seldon Core.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#configurer-python","title":"Configurer Python\u00b6","text":"

    \u00c9crivez requirements.txt et configurez notre environnement virtuel Python.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#deployer-le-modele","title":"D\u00e9ployer le mod\u00e8le\u00b6","text":"

    \u00c9crivez un fichier YAML SeldonDeployment pour le mod\u00e8le conteneuris\u00e9.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#modele-de-test","title":"Mod\u00e8le de test\u00b6","text":"

    Avec l'environnement virtuel configur\u00e9 et activ\u00e9, importez les biblioth\u00e8ques Python n\u00e9cessaires.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#resultats","title":"R\u00e9sultats\u00b6","text":"

    Ce sont les r\u00e9sultats en JSON brut.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#nettoyer","title":"Nettoyer\u00b6","text":"

    Nettoyez en supprimant le d\u00e9ploiement.

    "}]} \ No newline at end of file +{"config":{"lang":["fr"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"]},"docs":[{"location":"index.html","title":"Bienvenue dans l'espace de travail d'analyse avanc\u00e9e","text":""},{"location":"index.html#la-documentation-de-lespace-de-travail-danalyse-avancee","title":"La documentation de l'espace de travail d'analyse avanc\u00e9e","text":"

    Bienvenue dans le monde de la science des donn\u00e9es et de l'apprentissage automatique\u00a0!

    Qu'est-ce que l'ETAA?

    Espace de travail d'analyse avanc\u00e9e est une plateforme open source con\u00e7ue pour les data scientists, les intendants des donn\u00e9es, les analystes et les chercheurs familiaris\u00e9s avec les outils open source et le codage. D\u00e9velopp\u00e9 par des data scientists pour des data scientists, ETAA fournit un environnement flexible qui permet aux praticiens avanc\u00e9s de faire leur travail en toute simplicit\u00e9.

    L'ETAA est une solution compl\u00e8te pour la science des donn\u00e9es et l'analyse des donn\u00e9es. Avec l'ETAA, vous pouvez personnaliser les d\u00e9ploiements de serveurs de bloc-notes en fonction de vos besoins sp\u00e9cifiques en science des donn\u00e9es. Nous avons un petit nombre d'images Docker personnalis\u00e9es r\u00e9alis\u00e9es par notre \u00e9quipe.

    Qu'est-ce que Kubeflow\u00a0?

    L'ETAA est bas\u00e9 sur Kubeflow, une solution compl\u00e8te open source pour le d\u00e9ploiement et la gestion de flux de travail ML de bout en bout.

    Que vous d\u00e9butiez ou que vous soyez d\u00e9j\u00e0 \u00e0 fond dans l'analyse des donn\u00e9es, l'espace de travail Advanced Analytics a tout ce dont vous avez besoin pour faire passer votre travail au niveau sup\u00e9rieur. Des outils puissants pour les pipelines de donn\u00e9es au stockage en nuage pour vos ensembles de donn\u00e9es, notre plateforme a tout pour plaire. Besoin de collaborer avec des coll\u00e8gues ou de publier vos r\u00e9sultats ? Aucun probl\u00e8me. Nous offrons des fonctionnalit\u00e9s de collaboration transparentes qui facilitent la collaboration et le partage de votre travail avec d'autres.

    Quelle que soit l'\u00e9tape \u00e0 laquelle vous vous trouvez dans votre parcours en science des donn\u00e9es, l'espace de travail d'analyse avanc\u00e9e dispose des ressources dont vous avez besoin pour r\u00e9ussir.

    "},{"location":"index.html#premiers-pas-avec-letaa","title":"Premiers pas avec l'ETAA","text":""},{"location":"index.html#le-portail-etaa","title":"Le portail ETAA","text":"

    La page d'accueil du portail ETAA est disponible uniquement pour les utilisateurs internes. Cependant, les utilisateurs externes disposant d'un compte cloud auquel le sponsor commercial a accord\u00e9 l'acc\u00e8s peuvent acc\u00e9der \u00e0 la plate-forme via l'URL de la plate-forme d'analyse.

    Page d'accueil du portail ETAA

    • Page d'accueil du portail pour les employ\u00e9s de Statistique Canada
    • Page d'accueil du portail pour les utilisateurs externes
    "},{"location":"index.html#compte-kubeflow","title":"Compte Kubeflow\ud83d\udc49 Cliquez ici pour configurer votre compte Kubeflow! \ud83d\udc48","text":"

    Attention Utilisateurs Externes!

    Les utilisateurs externes \u00e0 Statistique Canada auront besoin d'un compte cloud auquel l'entreprise commanditaire aura acc\u00e8s.

    A l'attention des employ\u00e9s de Statistique Canada!

    Les utilisateurs internes de Statistique Canada peuvent commencer imm\u00e9diatement sans aucune proc\u00e9dure d'inscription suppl\u00e9mentaire, il suffit de se rendre sur https://kubeflow.ETAA.cloud.statcan.ca/.

    Kubeflow est une plate-forme open source puissante et flexible qui permet une exploitation dynamique du calcul dans le cloud, les utilisateurs ayant la possibilit\u00e9 de contr\u00f4ler les ressources de calcul, de m\u00e9moire et de stockage utilis\u00e9es.

    Kubeflow simplifie les t\u00e2ches suivantes\u00a0:

    • Cr\u00e9ation d'environnements personnalisables pour travailler avec des donn\u00e9es avec un provisionnement de ressources contr\u00f4l\u00e9 par l'utilisateur (CPU, GPU, RAM et stockage personnalis\u00e9s).
    • Gestion des serveurs d'ordinateurs portables, y compris Ubuntu Desktop (via noVNC), R Studio, JupyterLab avec Python, R, Julia et SAS pour les employ\u00e9s de Statistique Canada.

    Tableau de bord Kubeflow

    • Kubeflow Dashboard Utilisez ce lien une fois que vous avez votre compte cloud\u00a0!

    La prise en main de l'espace de travail d'analyse avanc\u00e9e (ETAA) est simple et rapide. Tout d'abord, vous voudrez vous connecter \u00e0 Kubeflow pour cr\u00e9er votre premier serveur de bloc-notes ex\u00e9cutant JupyterLab, RStudio ou Ubuntu Desktop. Nous vous encourageons \u00e0 rejoindre notre cha\u00eene Slack pour entrer en contact avec d'autres data scientists et analystes, poser des questions et partager vos exp\u00e9riences avec la plateforme ETAA.

    "},{"location":"index.html#slack","title":"SlackUtilisez votre adresse de courriel @statcan.gc.ca afin que vous soyez automatiquement approuv\u00e9.","text":"
    • Cliquez ici pour vous connecter \u00e0 notre espace de travail d'assistance Slack
    • Utilisez la cha\u00eene G\u00e9n\u00e9ral\u00a0!

    Chez Statistique Canada, nous comprenons que se lancer dans un nouveau projet peut \u00eatre accablant, et vous aurez probablement de nombreuses questions li\u00e9es \u00e0 la plateforme en cours de route. C'est pourquoi nous avons cr\u00e9\u00e9 un canal Slack d\u00e9di\u00e9 pour vous fournir l'assistance dont vous avez besoin. Notre \u00e9quipe d'experts est l\u00e0 pour r\u00e9pondre \u00e0 vos questions, r\u00e9pondre \u00e0 vos pr\u00e9occupations et vous guider \u00e0 chaque \u00e9tape du processus.

    Pour rejoindre notre canal Slack, cliquez simplement sur le lien fourni et suivez les instructions. Vous serez invit\u00e9 \u00e0 cr\u00e9er un compte dans le coin sup\u00e9rieur droit de la page. Si vous avez une adresse de courriel \u00ab\u00a0@statcan.gc.ca\u00a0\u00bb, utilisez-la lors de votre inscription, car cela garantira que vous \u00eates automatiquement approuv\u00e9 et que vous pouvez commencer \u00e0 vous engager imm\u00e9diatement avec notre communaut\u00e9.

    Une fois que vous avez cr\u00e9\u00e9 votre compte, vous aurez acc\u00e8s \u00e0 une multitude de ressources et d'informations, ainsi que la possibilit\u00e9 de vous connecter avec d'autres utilisateurs qui travaillent sur des projets similaires. Notre cha\u00eene Slack est l'endroit id\u00e9al pour poser des questions, partager des id\u00e9es et collaborer avec vos pairs en temps r\u00e9el. Que vous commenciez tout juste \u00e0 d\u00e9marrer un nouveau projet ou que vous recherchiez des conseils d'experts sur un probl\u00e8me complexe, notre \u00e9quipe est l\u00e0 pour vous aider.

    Alors n'h\u00e9sitez pas\u00a0: rejoignez notre canal Slack d\u00e8s aujourd'hui et commencez \u00e0 obtenir les r\u00e9ponses dont vous avez besoin pour r\u00e9ussir. Nous sommes impatients de vous accueillir dans notre communaut\u00e9\u00a0!

    Cliquez sur le lien, puis choisissez \"Cr\u00e9er un compte\" dans le coin sup\u00e9rieur droit.

    "},{"location":"index.html#mise-en-route","title":"\ud83e\udded Mise en route","text":"

    Pour acc\u00e9der aux services ETAA, vous devez vous connecter \u00e0 Kubeflow avec votre compte cloud invit\u00e9 de Statistique Canada. Une fois connect\u00e9, s\u00e9lectionnez Serveurs de bloc-notes et cliquez sur le bouton \"Nouveau serveur\" pour commencer.

    1. Connectez-vous \u00e0 Kubeflow avec votre compte cloud invit\u00e9 de Statistique Canada. Vous serez invit\u00e9 \u00e0 authentifier le compte.
    2. S\u00e9lectionnez Serveurs de bloc-notes.
    3. Cliquez sur le bouton \"\u2795 Nouveau serveur\".
    "},{"location":"index.html#outils-offerts","title":"\ud83e\uddf0 Outils Offerts","text":"

    ETAA est une plate-forme flexible pour l'analyse de donn\u00e9es et l'apprentissage automatique. Il propose une gamme de langages, notamment Python, R et Julia. ETAA prend \u00e9galement en charge les environnements de d\u00e9veloppement tels que VS Code, R Studio et bloc-notesJupyter. De plus, des bureaux virtuels Linux sont disponibles pour les utilisateurs qui ont besoin d'outils suppl\u00e9mentaires tels que OpenM++ et QGIS.

    Voici une liste d'outils que nous proposons\u00a0:

    • \ud83d\udcdc Languages :
      • \ud83d\udc0d Python
      • \ud83d\udcc8 R
      • \ud83d\udc69\u200d\ud83d\udd2c Julia
    • \ud83e\uddee Environnements de d\u00e9veloppement :
      • Code VS
      • Studio R
      • Cahiers Jupyter
    • \ud83d\udc27 Bureaux virtuels Linux pour des outils suppl\u00e9mentaires (\ud83e\uddeb OpenM++, \ud83c\udf0f QGIS etc.)

    Le partage de code, de disques et d'espaces de travail (ex : deux personnes partageant la m\u00eame machine virtuelle) est d\u00e9crit plus en d\u00e9tail dans la section Collaboration. Le partage de donn\u00e9es via des buckets est d\u00e9crit plus en d\u00e9tail dans Azure Blob Storage section.

    "},{"location":"index.html#aide","title":"\ud83d\udca1 Aide","text":"
    • Disque (\u00e9galement appel\u00e9 Volumes sur l'\u00e9cran de cr\u00e9ation de serveur bloc-notes)
    • Conteneurs (Stockage Blob)
    • Lacs de donn\u00e9es (\u00e0 venir)
    • \ud83d\udcd7 Documentation du portail ETAA
      • https://statcan.github.io/aaw/
    • \ud83d\udcd8 Documentation Kubeflow
      • https://www.kubeflow.org/docs/
    • \ud83e\udd1d Canal d'assistance Slack
      • https://statcan-etaa.slack.com
    "},{"location":"index.html#demos","title":"\ud83d\udc31 D\u00e9mos","text":"

    Si vous avez besoin d'une session de d\u00e9monstration d'int\u00e9gration rapide, avez besoin d'aide ou avez des questions, veuillez nous contacter via notre \ud83e\udd1d Canal d'assistance Slack.

    "},{"location":"index.html#contribuant","title":"Contribuant","text":"

    Si vous avez des bogues \u00e0 signaler ou des fonctionnalit\u00e9s \u00e0 demander, veuillez le faire via https://github.com/Statcan/daaas.

    "},{"location":"Aide.html","title":"Vous avez des questions ou des commentaires?","text":"

    Joignez-vous \u00e0 nous sur le canal Slack de l'espace de travail en analytique avanc\u00e9e! Vous trouverez de nombreux utilisateurs de la plateforme qui pourront peut-\u00eatre r\u00e9pondre \u00e0 vos questions. Quelques ing\u00e9nieurs sont aussi habituellement pr\u00e9sents. Vous pouvez poser des questions et soumettre vos commentaires, dans la langue de votre choix.

    • Slack (fr)

    Nous publierons \u00e9galement des avis de mise \u00e0 jour et d'interruption sur le canal Slack.

    "},{"location":"Aide.html#github","title":"GitHub","text":"

    Vous voulez en savoir plus \u00e0 propos de notre plateforme? Trouvez tous les d\u00e9tailles sur notre page GitHub!

    • Page GitHub de l'Espace d'analyse avanc\u00e9e
    "},{"location":"Collaboration.html","title":"Collaboration en mati\u00e8re d'espace de travail en analytique avanc\u00e9e","text":"

    Il existe de nombreuses fa\u00e7ons de collaborer sur la plateforme, et ce qui vous convient le mieux d\u00e9pend des \u00e9l\u00e9ments que vous partagez et du nombre de personnes avec qui vous souhaitez partager des \u00e9l\u00e9ments. Nous pouvons r\u00e9partir les \u00e9l\u00e9ments partageables en donn\u00e9es et en code. Nous pouvons aussi r\u00e9partir l'ensemble des groupes avec lesquels vous partagez des \u00e9l\u00e9ments en priv\u00e9, \u00e9quipe et StatCan. Cela conduit au tableau d'options suivant :

    Priv\u00e9 \u00c9quipe StatCan Code GitLab/GitHub ou dossier personnel GitLab/GitHub ou dossier d'\u00e9quipe GitLab/GitHub Donn\u00e9es Dossier ou compartiment personnel Dossier ou compartiment d'\u00e9quipe Compartiment partag\u00e9 Quelle est la diff\u00e9rence entre un compartiment et un dossier?

    Les compartiments s'apparentent au stockage r\u00e9seau. Voir la section sur le stockage pour obtenir des pr\u00e9cisions suppl\u00e9mentaires sur les diff\u00e9rences entre ces deux concepts.

    Les acc\u00e8s priv\u00e9 et \u00e9quipe sont configur\u00e9s au moyen des espaces de nommage. Nous commen\u00e7ons donc par parler de Kubeflow et des espaces de nommage Kubeflow.

    Ensuite, les donn\u00e9es et le code sont mieux pris en charge au moyen d'outils l\u00e9g\u00e8rement diff\u00e9rents. C'est pourquoi nous allons les aborder en deux temps. Pour les donn\u00e9es, nous parlons de compartiments et MinIO. Pour le code, nous parlons de Git, GitLab et GitHub.

    C'est sur quoi repose la structure de cette page :

    \u2013 Collaboration en \u00e9quipe (applicable au code et aux donn\u00e9es) \u2013 Partage du code \u2013 Partage des donn\u00e9es

    "},{"location":"Collaboration.html#collaboration-en-equipe","title":"Collaboration en \u00e9quipe","text":""},{"location":"Collaboration.html#que-fait-kubeflow","title":"Que fait Kubeflow?","text":"

    Kubeflow ex\u00e9cute vos espaces de travail. Vous pouvez avoir des serveurs de blocs-notes (appel\u00e9s serveurs Jupyter) et vous pouvez y cr\u00e9er des analyses en R et en Python en utilisant des \u00e9l\u00e9ments visuels interactifs. Vous pouvez enregistrer, t\u00e9l\u00e9verser et t\u00e9l\u00e9charger des donn\u00e9es. Votre \u00e9quipe peut travailler \u00e0 vos c\u00f4t\u00e9s.

    "},{"location":"Collaboration.html#demande-dun-espace-de-nommage","title":"Demande d'un espace de nommage","text":"

    Par d\u00e9faut, chaque personne obtient son propre espace de nommage, pr\u00e9nom-nom. Si vous souhaitez cr\u00e9er un espace de nommage pour une \u00e9quipe, pr\u00e9sentez la demande dans le portail : Cliquez sur le \u22ee de la section Kubeflow du portail.

    L'espace de nommage ne doit comprendre aucun caract\u00e8re sp\u00e9cial autre que le trait d'union.

    Le nom doit seulement comprendre des lettres minuscules (de \u00ab a \u00bb \u00e0 \u00ab z \u00bb) et des traits d'union. Sinon, il sera impossible de cr\u00e9er l'espace de nommage.

    Vous recevrez un avis par courriel vous indiquant que l'espace de nommage est cr\u00e9\u00e9. Une fois que l'espace de nommage partag\u00e9 est cr\u00e9\u00e9, vous pouvez y acc\u00e9der comme tous les autres espaces de nommage dont vous disposez par l'entremise de l'interface utilisateur Kubeflow, comme il est indiqu\u00e9 ci-apr\u00e8s. Vous pourrez ensuite g\u00e9rer la liste des collaborateurs sous l'onglet de gestion des contributeurs de Kubeflow, o\u00f9 vous pourrez ajouter vos coll\u00e8gues \u00e0 l'espace de nommage partag\u00e9.

    Pour changer d'espace de nommage, allez en haut de votre fen\u00eatre, juste \u00e0 droite du logo de Kubeflow.

    "},{"location":"Collaboration.html#code-partage","title":"Code partag\u00e9","text":"

    Les \u00e9quipes ont deux options (mais vous pouvez combiner les deux) :

    "},{"location":"Collaboration.html#partager-un-espace-de-travail-dans-kubeflow","title":"Partager un espace de travail dans Kubeflow","text":"

    Le partage dans Kubeflow pr\u00e9sente l'avantage suivant : il est \u00e0 structure libre et il fonctionne mieux pour les fichiers .ipynb (blocs-notes Jupyter). Cette m\u00e9thode vous permet \u00e9galement de partager un environnement de calcul, de sorte que vous pouvez partager des ressources tr\u00e8s facilement. Lorsque vous partagez un espace de travail, vous partagez :

    \u2013 un compartiment priv\u00e9 et partag\u00e9 (/team-name et /shared/team-name); \u2013 tous les serveurs de blocs-notes dans l'espace de nommage Kubeflow.

    "},{"location":"Collaboration.html#partager-avec-git-au-moyen-de-gitlab-ou-de-github","title":"Partager avec Git, au moyen de GitLab ou de GitHub","text":"

    Le partage au moyen de Git pr\u00e9sente l'avantage suivant : il permet de travailler avec des utilisateurs de tous les espaces de nommage. De plus, le fait de conserver le code dans Git est un excellent moyen de g\u00e9rer les grands projets de logiciels.

    N'oubliez pas d'obtenir une licence d'utilisation!

    Si votre code est public, suivez les directives de l'\u00e9quipe de l'innovation et utilisez une licence appropri\u00e9e si vous r\u00e9alisez des t\u00e2ches pour le compte de Statistique Canada.

    "},{"location":"Collaboration.html#recommandation-combinez-les-deux","title":"Recommandation : combinez les deux.","text":"

    Il est sage de toujours utiliser Git. L'utilisation de Git de concert avec des espaces de travail partag\u00e9s est un bon moyen de combiner le partage ponctuel (par l'entremise de fichiers) tout en assurant l'organisation et le suivi de votre code.

    "},{"location":"Collaboration.html#stockage-partage","title":"Stockage partag\u00e9","text":""},{"location":"Collaboration.html#partage-avec-votre-equipe","title":"Partage avec votre \u00e9quipe","text":"

    Une fois que vous avez un espace de nommage partag\u00e9, deux m\u00e9thodes de stockage partag\u00e9 s'offrent \u00e0 vous :

    Option de stockage Avantages Serveurs/espaces de travail Jupyter partag\u00e9s Mieux adapt\u00e9s aux petits fichiers, aux blocs-notes et aux petites exp\u00e9riences. Compartiments partag\u00e9s (voir Stockage) Mieux adapt\u00e9s \u00e0 une utilisation dans les pipelines et les interfaces API et aux fichiers volumineux.

    Pour en savoir plus sur la technologie sous-jacente, consultez la section sur le stockage.

    "},{"location":"Collaboration.html#partage-avec-statcan","title":"Partage avec StatCan","text":"

    En plus des compartiments priv\u00e9s et des compartiments priv\u00e9s partag\u00e9s en \u00e9quipe, vous pouvez \u00e9galement placer vos fichiers dans un espace de stockage partag\u00e9. Toutes les options de stockage en compartiments (minimal, sup\u00e9rieur, \u00e9l\u00e9phantesque) offrent un compartiment priv\u00e9 et un dossier \u00e0 l'int\u00e9rieur du compartiment partag\u00e9. Par exemple, consultez le lien ci-dessous :

    • shared/blair-drummond/

    Tous les utilisateurs connect\u00e9s peuvent visualiser et consulter ces fichiers librement.

    "},{"location":"Collaboration.html#partage-avec-le-monde","title":"Partage avec le monde","text":"

    Renseignez-vous \u00e0 ce sujet sur notre canal Slack. Il existe de nombreuses m\u00e9thodes de partage avec le monde du point de vue informatique. Cependant, comme il est important de respecter les processus appropri\u00e9s, on n'utilise pas le libre-service, comme dans les autres cas. Cela dit, c'est possible.

    "},{"location":"message-de-bienvenue.html","title":"Message de bienvenue","text":""},{"location":"message-de-bienvenue.html#bienvenue-a-lespace-danalyse-avance-eaa","title":"\ud83e\uddd9\ud83d\udd2e Bienvenue \u00e0 l\u2019Espace d'analyse avanc\u00e9 (EAA)","text":"

    Veuillez trouver ci-dessous des informations, des vid\u00e9os et des liens suppl\u00e9mentaires pour mieux comprendre comment d\u00e9marrer avec l\u2019Espace d'analyse avanc\u00e9 (EAA).

    L\u2019Espace d'analyse avanc\u00e9 (EAA) est notre plateforme open source pour la science des donn\u00e9es et l'apprentissage automatique (ML) destin\u00e9e aux praticiens avanc\u00e9s, qui peuvent ainsi accomplir leur travail dans un environnement sans restriction, con\u00e7u par des scientifiques des donn\u00e9es pour des scientifiques des donn\u00e9es. Avec EAA, vous pouvez personnaliser vos d\u00e9ploiements d'ordinateurs portables pour r\u00e9pondre \u00e0 vos besoins en mati\u00e8re de science des donn\u00e9es. Nous disposons \u00e9galement d'un petit nombre d'images r\u00e9alis\u00e9es par notre \u00e9quipe experte en science des donn\u00e9es.

    EAA est bas\u00e9 sur le projet Kubeflow qui est une solution compl\u00e8te open source pour le d\u00e9ploiement et la gestion de flux de travail ML de bout en bout. Kubeflow est con\u00e7u pour rendre les d\u00e9ploiements de flux de travail ML sur Kubernetes simples, portables et \u00e9volutifs.

    \ud83d\udd14 Important! Les utilisateurs externes \u00e0 Statistique Canada devront disposer d'un compte cloud dont l'acc\u00e8s est accord\u00e9 par le commanditaire de l'entreprise.

    \ud83d\udd14 Important! Les utilisateurs internes \u00e0 Statistique Canada peuvent commencer tout de suite sans proc\u00e9dure d'inscription suppl\u00e9mentaire, il suffit de se rendre \u00e0 l'adresse https://kubeflow.aaw.cloud.statcan.ca/.

    "},{"location":"message-de-bienvenue.html#liens-utiles","title":"\ud83d\udd17 Liens utiles","text":""},{"location":"message-de-bienvenue.html#services-eaa","title":"\ud83d\udece\ufe0f Services EAA","text":"
    • \ud83c\udf00 Page d'accueil du portail EEA
      • Interne seulement https://www.statcan.gc.ca/services-analyse-donnees/etaa
      • Interne/externe https://www.statcan.gc.ca/services-analyse-donnees/etaa
    • \ud83e\udd16 Tableau de bord Kubeflow
      • https://kubeflow.aaw.cloud.statcan.ca/
    "},{"location":"message-de-bienvenue.html#aide","title":"\ud83d\udca1 Aide","text":"
    • \ud83d\udcd7 Documentation du portail EAA
      • https://statcan.github.io/aaw/
    • \ud83d\udcd8 Documentation sur Kubeflow
      • https://www.kubeflow.org/docs/
    • \ud83e\udd1d Canal de support Slack
      • https://statcan-aaw.slack.com
    "},{"location":"message-de-bienvenue.html#mise-en-route","title":"\ud83e\udded Mise en route","text":"

    Afin d'acc\u00e9der aux services de l'EAA, vous devrez:

    1. Vous connecter \u00e0 Kubeflow avec votre compte cloud invit\u00e9 StatCan. Vous serez invit\u00e9 \u00e0 authentifier le compte.
    2. S\u00e9lectionnez Serveurs de bloc-notes.
    3. Cliquez sur le bouton \" \u2795 Nouveau serveur \".
    "},{"location":"message-de-bienvenue.html#outils-offerts","title":"\ud83e\uddf0 Outils offerts","text":"

    AAW est une plateforme flexible pour l'analyse de donn\u00e9es et l'apprentissage automatique, avec:

    • \ud83d\udcdc Langues
      • \ud83d\udc0d Python
      • \ud83d\udcc8 R
      • \ud83d\udc69\ud83d\udd2c Julia
      • SAS (Prochainement!)
    • \ud83e\uddee Environnements de d\u00e9veloppement
      • VS Code
      • R Studio
      • Jupyter Notebooks
    • \ud83d\udc27 Bureaux virtuels Linux pour des outils suppl\u00e9mentaires (\ud83e\uddeb OpenM++, \ud83c\udf0f QGIS, etc.)
    "},{"location":"message-de-bienvenue.html#demonstrations","title":"\ud83d\udc31 D\u00e9monstrations","text":"

    Si vous souhaitez une session d'embarquement/d\u00e9mo rapide ou si vous avez besoin d'aide ou avez des questions, n'h\u00e9sitez pas \u00e0 nous contacter via notre canal de support \ud83e\udd1d Slack.

    "},{"location":"message-de-bienvenue.html#faq","title":"FAQ","text":"
    • \ud83d\udea7 Bient\u00f4t disponible !

    Merci !

    "},{"location":"1-Experiences/Apercu.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Apercu.html#experimentation-de-la-science-des-donnees","title":"Exp\u00e9rimentation de la science des donn\u00e9es","text":"

    Traitez les donn\u00e9es \u00e0 l'aide de R, Python ou Julia avec Kubeflow, une plateforme d'apprentissage automatique qui fournit une infrastructure simple, unifi\u00e9e et \u00e9volutive pour les charges de travail d'apprentissage automatique.

    Avec Kubeflow, vous pouvez traiter les donn\u00e9es de mani\u00e8re \u00e9volutive et efficace en utilisant le langage de programmation de votre choix. Une fois Kubeflow configur\u00e9, utilisez bloc-notes Jupyter pour cr\u00e9er et partager des documents contenant du code en direct, des \u00e9quations ou des visualisations.

    Vous pouvez \u00e9galement ex\u00e9cuter Ubuntu en tant que bureau virtuel avec Kubeflow, vous donnant acc\u00e8s \u00e0 un environnement de d\u00e9veloppement puissant qui peut \u00eatre personnalis\u00e9 selon vos besoins. Avec R Shiny, un cadre d'application Web pour R, vous pouvez facilement cr\u00e9er et publier des tableaux de bord statiques et interactifs pour communiquer les r\u00e9sultats de votre analyse aux parties prenantes.

    Kubeflow fournit \u00e9galement une int\u00e9gration avec des plates-formes externes en tant que service, telles que Google Cloud Platform (GCP) et Amazon Web Services (AWS), vous permettant de d\u00e9placer facilement des donn\u00e9es et des charges de travail entre diff\u00e9rents services cloud. De plus, gr\u00e2ce aux fonctionnalit\u00e9s de collaboration de Kubeflow, vous pouvez travailler sur vos projets avec votre \u00e9quipe en temps r\u00e9el, en partageant votre analyse, votre code et vos r\u00e9sultats de mani\u00e8re transparente.

    L'exp\u00e9rimentation en science des donn\u00e9es fait r\u00e9f\u00e9rence au processus de conception, de r\u00e9alisation et d'analyse d'exp\u00e9riences afin de tester des hypoth\u00e8ses et d'obtenir des informations \u00e0 partir des donn\u00e9es. Ce processus implique g\u00e9n\u00e9ralement plusieurs \u00e9tapes\u00a0:

    1. Formuler une hypoth\u00e8se : Avant de mener une exp\u00e9rience, il est important d\u2019avoir une id\u00e9e claire de ce que vous essayez de tester ou d\u2019apprendre. Cela peut impliquer de formuler une hypoth\u00e8se sur une relation entre des variables ou d\u2019essayer de r\u00e9pondre \u00e0 une question de recherche sp\u00e9cifique.

    2. Conception de l'exp\u00e9rience : Une fois que vous avez une hypoth\u00e8se, vous devez concevoir une exp\u00e9rience qui vous permettra de la tester. Cela peut impliquer de s\u00e9lectionner un \u00e9chantillon de donn\u00e9es, de choisir les variables \u00e0 manipuler ou \u00e0 mesurer et de d\u00e9cider des conditions exp\u00e9rimentales.

    3. Collecte et nettoyage des donn\u00e9es : Une fois l'exp\u00e9rience con\u00e7ue, vous devez collecter les donn\u00e9es n\u00e9cessaires pour tester votre hypoth\u00e8se. Cela peut impliquer de collecter des donn\u00e9es \u00e0 partir de sources existantes ou de mener vos propres exp\u00e9riences. Une fois les donn\u00e9es collect\u00e9es, vous devez les nettoyer pour supprimer toute erreur ou anomalie.

    4. Analyser les donn\u00e9es : Une fois les donn\u00e9es propres, vous pouvez commencer \u00e0 les analyser pour tester votre hypoth\u00e8se. Cela peut impliquer l'ex\u00e9cution de tests statistiques ou d'algorithmes d'apprentissage automatique, la visualisation des donn\u00e9es pour identifier des mod\u00e8les ou des tendances, ou l'utilisation d'autres techniques analytiques pour obtenir des informations.

    5. Tirer des conclusions\u00a0: sur la base des r\u00e9sultats de votre analyse, vous pouvez tirer des conclusions quant \u00e0 savoir si votre hypoth\u00e8se est support\u00e9e ou non. Vous pourrez peut-\u00eatre \u00e9galement identifier des domaines n\u00e9cessitant des recherches ou des exp\u00e9rimentations plus approfondies.

    L'analyse des donn\u00e9es est un \u00e9l\u00e9ment cl\u00e9 de l'exp\u00e9rimentation en science des donn\u00e9es et implique l'utilisation de diverses techniques et outils pour donner un sens \u00e0 de grandes quantit\u00e9s de donn\u00e9es. Cela peut impliquer une analyse exploratoire des donn\u00e9es, dans laquelle vous utilisez des visualisations et des statistiques r\u00e9capitulatives pour acqu\u00e9rir une premi\u00e8re compr\u00e9hension des donn\u00e9es, ou des techniques plus avanc\u00e9es telles que l'apprentissage automatique ou la mod\u00e9lisation statistique. L'analyse des donn\u00e9es peut \u00eatre utilis\u00e9e pour r\u00e9pondre \u00e0 un large \u00e9ventail de questions, depuis de simples questions descriptives sur les donn\u00e9es jusqu'\u00e0 des questions pr\u00e9dictives ou prescriptives plus complexes.

    En r\u00e9sum\u00e9, l\u2019exp\u00e9rimentation et l\u2019analyse des donn\u00e9es sont des \u00e9l\u00e9ments importants du domaine plus large de la science des donn\u00e9es et impliquent l\u2019utilisation de donn\u00e9es pour tester des hypoth\u00e8ses, obtenir des informations et prendre des d\u00e9cisions \u00e9clair\u00e9es.

    "},{"location":"1-Experiences/Bureau-virtuel.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Bureau-virtuel.html#bureau-virtuel-ubuntu","title":"Bureau virtuel Ubuntu","text":"

    Vous pouvez ex\u00e9cuter un Bureau Ubuntu complet, avec des applications typiques, directement dans votre navigateur, en utilisant Kubeflow!

    Le bureau virtuel Ubuntu est un outil puissant pour les scientifiques de donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique qui doivent ex\u00e9cuter des charges de travail gourmandes en ressources dans le nuage informatique. Ubuntu est une distribution Linux populaire largement utilis\u00e9e dans les communaut\u00e9s de science des donn\u00e9es et d'apprentissage automatique en raison de sa forte prise en charge des outils de logiciels libres tels que R et Python. Avec Ubuntu Virtual Desktop, vous pouvez rapidement d\u00e9marrer une machine virtuelle avec Ubuntu pr\u00e9install\u00e9 et y acc\u00e9der depuis n'importe o\u00f9 avec une connexion Internet. Cela signifie que vous pouvez effectuer des t\u00e2ches d'analyse de donn\u00e9es et d'apprentissage automatique depuis votre ordinateur portable, votre tablette ou votre t\u00e9l\u00e9phone sans avoir \u00e0 vous soucier des limitations mat\u00e9rielles.

    "},{"location":"1-Experiences/Bureau-virtuel.html#quest-ce-que-le-bureau-a-distance","title":"Qu'est-ce que le Bureau \u00e0 distance\u00a0?","text":"

    Le bureau \u00e0 distance\u00a0offre une exp\u00e9rience de bureau Ubuntu avec interface graphique dans le navigateur ainsi que l'acc\u00e8s rapide aux outils de support. Le syst\u00e8me d'exploitation est Ubuntu 22.04 avec le XFCE pour environnement de bureau.

    "},{"location":"1-Experiences/Bureau-virtuel.html#geomatique","title":"G\u00e9omatique","text":"

    Notre version de bureau \u00e0 distance est construite sur une image R Geospatiale.

    "},{"location":"1-Experiences/Bureau-virtuel.html#personnalisation","title":"Personnalisation","text":"

    pip, conda, npm et yarn sont disponibles pour installer divers paquets.

    "},{"location":"1-Experiences/Bureau-virtuel.html#installation","title":"Installation","text":""},{"location":"1-Experiences/Bureau-virtuel.html#acceder-au-bureau-a-distance","title":"Acc\u00e9der au bureau \u00e0 distance","text":"

    Pour lancer le Bureau \u00e0 distance ou l'un de ses outils de support, cr\u00e9ez un serveur bloc-notes dans Kubeflow et s\u00e9lectionnez l'option de bureau \u00e0 distance, qui est l'image Ubuntu.

    Une fois cr\u00e9\u00e9, cliquez sur \u00ab\u00a0Connecter\u00a0\u00bb pour \u00eatre redirig\u00e9 vers le serveur de bureau \u00e0 distance

    Remote Desktop vous am\u00e8ne \u00e0 l'interface graphique du bureau via une session noVNC. Cliquer sur le > sur le c\u00f4t\u00e9 gauche de l'\u00e9cran pour d\u00e9velopper un panneau avec des options telles que le plein \u00e9cran et presse-papiers.

    "},{"location":"1-Experiences/Bureau-virtuel.html#acceder-au-presse-papiers","title":"Acc\u00e9der au Presse-papiers","text":"

    Cela se fait via le deuxi\u00e8me bouton en partant du haut du panneau \u00e0 gauche. Il fait appara\u00eetre une zone de texte que nous pouvons modifier pour changer le contenu du presse-papiers ou copiez des \u00e9l\u00e9ments du presse-papiers du bureau distant.

    Par exemple, supposons que nous souhaitions ex\u00e9cuter la commande head -c 20 /dev/urandom | somme md5 et copiez-collez le r\u00e9sultat dans un fichier texte sur notre ordinateur utilis\u00e9 pour se connecter au bureau \u00e0 distance.

    Nous ouvrons d\u2019abord le presse-papiers \u00e0 partir du panneau de gauche et collons cette commande dans la zone de texte :

    Pour fermer la fen\u00eatre du presse-papiers sur le bureau distant, cliquez simplement sur le bouton presse-papiers \u00e0 nouveau.

    Nous faisons ensuite un clic droit sur une fen\u00eatre de terminal pour coller cette commande et appuyons sur Entr\u00e9e pour ex\u00e9cuter la commande. \u00c0 ce stade, nous s\u00e9lectionnons le r\u00e9sultat MD5, faisons un clic droit et cliquons copie:

    Si nous ouvrons \u00e0 nouveau le presse-papiers depuis le panneau de gauche, il aura d\u00e9sormais le nouveau contenu:

    La fen\u00eatre du presse-papiers sera m\u00eame mise \u00e0 jour sur place si nous la laissons ouverte tout le temps et nous s\u00e9lectionnons simplement le nouveau mat\u00e9riel sur le bureau distant et appuyons \u00e0 nouveau sur copier. Nous pouvons simplement copiez ce que nous avons dans cette zone de texte et collez-le dans n'importe quel autre logiciel en cours d'ex\u00e9cution sur l'ordinateur utilis\u00e9 pour se connecter.

    "},{"location":"1-Experiences/Bureau-virtuel.html#outils-dans-le-navigateur","title":"Outils dans le navigateur","text":""},{"location":"1-Experiences/Bureau-virtuel.html#vscode","title":"VSCode","text":"

    Visual Studio Code est un \u00e9diteur de code source l\u00e9ger mais puissant. Il inclut la prise en charge int\u00e9gr\u00e9e de JavaScript, TypeScript et Node.js et dispose d'un riche \u00e9cosyst\u00e8me d'extensions pour plusieurs langages (tels que C++, C#, Java, Python,PHP, Go).

    "},{"location":"1-Experiences/Bureau-virtuel.html#notes-de-bas-de-page","title":"Notes de bas de page","text":"

    Le Bureau \u00e0 distance est bas\u00e9 sur ml-tooling/ml-workspace.

    "},{"location":"1-Experiences/Environnements-virtuels.html","title":"Environnements virtuels","text":"

    Lorsque vous effectuez des exp\u00e9riences de science des donn\u00e9es, il est recommand\u00e9 d'utiliser des environnements virtuels Python et/ou conda pour g\u00e9rer les d\u00e9pendances de votre projet. Il est courant de cr\u00e9er un environnement d\u00e9di\u00e9 pour chaque projet ou, dans certains cas, des environnements distincts pour diff\u00e9rentes fonctionnalit\u00e9s ou aspects de votre travail (par exemple, un environnement pour les projets g\u00e9n\u00e9raux et un environnement suppl\u00e9mentaire adapt\u00e9 aux t\u00e2ches d'apprentissage en profondeur acc\u00e9l\u00e9r\u00e9es par GPU).

    Si vous basculez fr\u00e9quemment entre les environnements et souhaitez un moyen plus pratique d'y acc\u00e9der dans JupyterLab, vous pouvez suivre ces instructions\u00a0:

    "},{"location":"1-Experiences/Environnements-virtuels.html#creation-et-ajout-denvironnements-au-lanceur-jupyterlab","title":"Cr\u00e9ation et ajout d'environnements au lanceur JupyterLab","text":""},{"location":"1-Experiences/Environnements-virtuels.html#etape-1-creer-lenvironnement","title":"\u00c9tape\u00a01\u00a0:\u00a0Cr\u00e9er l'environnement","text":"

    Ouvrez une session de terminal et ex\u00e9cutez le code suivant pour cr\u00e9er un nouvel environnement virtuel. Vous pouvez utiliser conda ou python venv en fonction de vos pr\u00e9f\u00e9rences et des exigences du projet. Chacun a ses propres avantages :

    "},{"location":"1-Experiences/Environnements-virtuels.html#utilisation-de-conda","title":"Utilisation de conda\u00a0:","text":"
    conda create -n torch\n
    "},{"location":"1-Experiences/Environnements-virtuels.html#avantages-de-conda","title":"Avantages de conda\u00a0:","text":"
    • G\u00e8re \u00e0 la fois les packages et les environnements Python.
    • Simplifie la gestion des packages, y compris les biblioth\u00e8ques et d\u00e9pendances non Python.
    "},{"location":"1-Experiences/Environnements-virtuels.html#utilisation-de-venv","title":"Utilisation de venv\u00a0:","text":"
    python -m torch venv\n
    "},{"location":"1-Experiences/Environnements-virtuels.html#avantages-de-venv","title":"Avantages de venv\u00a0:","text":"
    • Fait partie de la biblioth\u00e8que standard Python (aucune installation s\u00e9par\u00e9e requise).
    • Fournit un environnement virtuel l\u00e9ger et centr\u00e9 sur Python.
    "},{"location":"1-Experiences/Environnements-virtuels.html#etape-2-ajouter-lenvironnement-au-lanceur","title":"\u00c9tape 2\u00a0: Ajouter l'environnement au lanceur","text":"

    Apr\u00e8s avoir cr\u00e9\u00e9 l'environnement, ajoutez-le au lanceur JupyterLab avec la commande suivante\u00a0:

    python -m ipykernel install --user --name \"torch\" --display-name \"PyTorch\"\n
    • --name \"torch\" sp\u00e9cifie le nom du noyau (remplacez \"torch\" si n\u00e9cessaire).
    • --display-name \"PyTorch\" d\u00e9finit le nom d'affichage du noyau dans le lanceur JupyterLab (personnalisez si n\u00e9cessaire).
    "},{"location":"1-Experiences/Environnements-virtuels.html#etape-3-actualiser-jupyterlab","title":"\u00c9tape 3\u00a0: Actualiser JupyterLab","text":"

    Pour voir les modifications dans le lanceur JupyterLab, actualisez votre navigateur en cliquant sur le bouton d'actualisation ou en utilisant le raccourci clavier F5.

    Ces \u00e9tapes vous permettent de g\u00e9rer de mani\u00e8re transparente vos environnements Python et d'y acc\u00e9der facilement depuis le lanceur JupyterLab, favorisant ainsi un flux de travail plus organis\u00e9 et plus efficace pour vos exp\u00e9riences de science des donn\u00e9es.

    "},{"location":"1-Experiences/Jupyter.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Jupyter.html#jupyter-experience-conviviale-de-r-et-python","title":"Jupyter: Exp\u00e9rience conviviale de R et Python","text":"

    Jupyter vous propose des bloc-notes pour \u00e9crire votre code et r\u00e9aliser des visualisations. Vous pouvez rapidement it\u00e9rer, visualiser et partager vos analyses. Parce qu'il fonctionne sur un serveur (que vous avez configur\u00e9 dans la section Kubeflow), vous pouvez effectuer de tr\u00e8s grandes analyses sur du mat\u00e9riel centralis\u00e9, en ajoutant autant de puissance que n\u00e9cessaire! Et comme il est sur le nuage, vous pouvez \u00e9galement le partager avec vos coll\u00e8gues.

    "},{"location":"1-Experiences/Jupyter.html#explorez-vos-donnees","title":"Explorez vos donn\u00e9es","text":"

    Jupyter offre un certain nombre de fonctionnalit\u00e9s (et nous pouvons en ajouter d'autres)

    • \u00c9l\u00e9ments visuels int\u00e9gr\u00e9s dans votre bloc-notes
    • Volume de donn\u00e9es pour le stockage de vos donn\u00e9es
    • Possibilit\u00e9 de partager votre espace de travail avec vos coll\u00e8gues

    "},{"location":"1-Experiences/Jupyter.html#explorez-vos-donnees-avec-une-api","title":"Explorez vos donn\u00e9es avec une API","text":"

    Utilisez Datasette , une interface de programmation (API) JSON instantan\u00e9e pour vos bases de donn\u00e9es SQLite. Ex\u00e9cutez des requ\u00eates SQL de mani\u00e8re plus interactive !

    "},{"location":"1-Experiences/Jupyter.html#environnement-de-developpement-dans-le-navigateur","title":"Environnement de d\u00e9veloppement dans le navigateur","text":"

    Cr\u00e9ez pour explorer, et aussi pour \u00e9crire du code

    • Linting et d\u00e9bogage
    • Int\u00e9gration Git
    • Terminal int\u00e9gr\u00e9
    • Th\u00e8me clair/fonc\u00e9 (changer les param\u00e8tres en haut)

    Plus de renseignements sur Jupyter ici

    "},{"location":"1-Experiences/Jupyter.html#installation","title":"Installation","text":""},{"location":"1-Experiences/Jupyter.html#commencez-avec-les-exemples","title":"Commencez avec les exemples","text":"

    Lorsque vous avez d\u00e9marr\u00e9 votre serveur, il a \u00e9t\u00e9 charg\u00e9 de mod\u00e8les de bloc-notes. Parmi les bons blocs-notes pour commencer, il y a R/01-R-Notebook-Demo.ipynb et ceux dans scikitlearn. Les bloc-notes pytorch et tensorflow sont excellents si vous connaissez l'apprentissage automatique. mapreduce-pipeline et ai-pipeline sont plus avanc\u00e9s.

    Certains bloc-notes ne fonctionnent que dans certaines versions de serveur

    Par exemple, gdal ne fonctionne que dans l'image g\u00e9omatique. Donc, si vous utilisez une autre image, un bloc-notes utilisant gdal pourrait ne pas fonctionner.

    "},{"location":"1-Experiences/Jupyter.html#ajout-de-logiciels","title":"Ajout de logiciels","text":"

    Vous n'avez pas sudo dans Jupyter, mais vous pouvez utiliser

    conda install --use-local your_package_name\n

    ou

    pip install --user your_package_name\n

    N'oubliez pas de red\u00e9marrer votre noyau Jupyter par la suite, pour acc\u00e9der \u00e0 de nouvelles trousses.

    Assurez-vous de red\u00e9marrer le noyau Jupyter apr\u00e8s l'installation d'un nouveau logiciel

    Si vous installez un logiciel dans un terminal, mais que votre noyau Jupyter \u00e9tait d\u00e9j\u00e0 en cours d'ex\u00e9cution, il ne sera pas mis \u00e0 jour.

    Y a-t-il quelque chose que vous ne pouvez pas installer?

    Si vous avez besoin d'installer quelque chose, communiquez avec nous ou ouvrir une question GitHub. Nous pouvons l'ajouter au logiciel par d\u00e9faut.

    "},{"location":"1-Experiences/Jupyter.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases ...","text":""},{"location":"1-Experiences/Jupyter.html#entrer-et-sortir-des-donnees-de-jupyter","title":"Entrer et sortir des donn\u00e9es de Jupyter","text":"

    Vous pouvez t\u00e9l\u00e9charger et charger des donn\u00e9es vers ou depuis JupyterHub directement dans le menu. Il y a un bouton de chargement en haut, et vous pouvez cliquer avec le bouton droit de la souris sur la plupart des fichiers ou dossiers pour les t\u00e9l\u00e9charger.

    "},{"location":"1-Experiences/Jupyter.html#stockage-partage-en-compartiment","title":"Stockage partag\u00e9 en compartiment","text":"

    Il existe \u00e9galement un dossier buckets mont\u00e9 dans votre r\u00e9pertoire personnel, qui contient les fichiers dans Stockage Blob Azure.

    Reportez-vous \u00e0 la section Stockage pour plus de d\u00e9tails.

    "},{"location":"1-Experiences/Jupyter.html#lanalyse-des-donnees","title":"L'analyse des donn\u00e9es","text":"

    L'analyse des donn\u00e9es est un art sous-estim\u00e9.

    L'analyse des donn\u00e9es est le processus d'examen et d'interpr\u00e9tation de grandes quantit\u00e9s de donn\u00e9es pour extraire des informations utiles et tirer des conclusions significatives. Cela peut \u00eatre fait \u00e0 l'aide de diverses techniques et outils, tels que l'analyse statistique, l'apprentissage automatique et la visualisation. L'objectif de l'analyse des donn\u00e9es est de d\u00e9couvrir des mod\u00e8les, des tendances et des relations dans les donn\u00e9es, qui peuvent ensuite \u00eatre utilis\u00e9s pour \u00e9clairer les d\u00e9cisions et r\u00e9soudre les probl\u00e8mes. L'analyse de donn\u00e9es est utilis\u00e9e dans un large \u00e9ventail de domaines, des affaires et de la finance aux soins de sant\u00e9 et \u00e0 la science, pour aider les organisations \u00e0 prendre des d\u00e9cisions plus \u00e9clair\u00e9es sur la base de preuves et d'informations bas\u00e9es sur des donn\u00e9es.

    "},{"location":"1-Experiences/Jupyter.html#jupyterlab","title":"JupyterLab","text":"

    Traiter les donn\u00e9es \u00e0 l'aide de R, Python ou Julia dans JupyterLab

    Le traitement des donn\u00e9es \u00e0 l'aide de R, Python ou Julia est simplifi\u00e9 gr\u00e2ce \u00e0 l'espace de travail d'analyse avanc\u00e9e. Que vous d\u00e9butiez dans l'analyse de donn\u00e9es ou que vous soyez un data scientist exp\u00e9riment\u00e9, notre plateforme prend en charge une gamme de langages de programmation pour r\u00e9pondre \u00e0 vos besoins. Vous pouvez installer et ex\u00e9cuter des packages pour R ou Python pour effectuer des t\u00e2ches de traitement de donn\u00e9es telles que le nettoyage, la transformation et la mod\u00e9lisation des donn\u00e9es. Si vous pr\u00e9f\u00e9rez Julia, notre plateforme offre \u00e9galement un support pour ce langage de programmation.

    "},{"location":"1-Experiences/Kubeflow.html","title":"Aper\u00e7u","text":""},{"location":"1-Experiences/Kubeflow.html#que-fait-kubeflow","title":"Que fait Kubeflow?","text":"

    Kubeflow ex\u00e9cute vos espaces de travail. Vous pouvez avoir des serveurs de bloc-notes (appel\u00e9s serveurs Jupyter), et vous pouvez y cr\u00e9er des analyses en R et Python avec des visuels interactifs. Vous pouvez enregistrer et charger des donn\u00e9es, t\u00e9l\u00e9charger des donn\u00e9es, et cr\u00e9er des espaces de travail partag\u00e9s pour votre \u00e9quipe.

    Commen\u00e7ons sans plus tarder!

    "},{"location":"1-Experiences/Kubeflow.html#installation","title":"Installation","text":""},{"location":"1-Experiences/Kubeflow.html#connectez-vous-a-kubeflow","title":"Connectez-vous \u00e0 Kubeflow","text":"

    Connectez-vous au portail Azure \u00e0 l'aide de vos identifiants cloud

    Vous devez vous connecter au portail Azure ** en utilisant vos informations d'identification StatCan **.first.lastname@cloud.statcan.ca ou ** en utilisant vos informations d'identification StatCan ** first.lastname@statcan.gc.ca. Vous pouvez le faire en utilisant Portail Azure.

    • Se connecter \u00e0 Kubeflow
    • Acc\u00e9dez \u00e0 l'onglet Serveurs bloc-notes
    • Assurez-vous que l'espace de noms de votre projet est s\u00e9lectionn\u00e9 dans le menu d\u00e9roulant des espaces de noms et que l'exemple dans la capture d'\u00e9cran est \"aaw-team\".

    • Puis clique + Nouveau serveur
    "},{"location":"1-Experiences/Kubeflow.html#configuration-de-votre-serveur","title":"Configuration de votre serveur","text":"
    • Vous obtiendrez un mod\u00e8le pour cr\u00e9er votre serveur de bloc-notes. Remarque : le nom de votre serveur doit \u00eatre en lettres minuscules avec des tirets. Pas d'espaces, et non souligne.
    "},{"location":"1-Experiences/Kubeflow.html#image","title":"Image","text":"

    Vous devrez choisir une image. Il existe JupyterLab, RStudio, bureau \u00e0 distance Ubuntu et SAS disponibles. L'image SAS est disponible uniquement pour les employ\u00e9s de StatCan (en raison des limitations de licence), les autres sont disponibles pour tout le monde. S\u00e9lectionnez le menu d\u00e9roulant pour s\u00e9lectionner des options suppl\u00e9mentaires parmi celles-ci (par exemple les images CPU, PyTorch et TensorFlow pour JupyterLab).

    V\u00e9rifiez le nom des images et choisissez-en une qui correspond \u00e0 ce que vous souhaitez faire. Je ne sais pas lequel choisir ? D\u00e9couvrez vos options ici.

    "},{"location":"1-Experiences/Kubeflow.html#image-personnalisee","title":"Image personnalis\u00e9e","text":"

    Un utilisateur peut utiliser une image personnalis\u00e9e, auquel cas il doit conna\u00eetre la forme exacte de l'image et son nom.

    Les images personnalis\u00e9es de l'utilisateur sont fournies via le d\u00e9p\u00f4t aaw-contrib-containers qui, une fois pouss\u00e9es vers la branche principale, poussera \u00e9galement l'image vers notre ACR. Une fois cette action termin\u00e9e avec succ\u00e8s, vous pouvez utiliser l'image personnalis\u00e9e.

    Lors de la cr\u00e9ation d'un bloc-notes, cliquez sur \u00ab Options avanc\u00e9es \u00bb, cochez la case pour l'image personnalis\u00e9e et saisissez l'image en saisissant k8scc01covidacr.azurecr.io/[your-image-name-here]:[sha].

    Une fois le bloc-note cr\u00e9\u00e9, si le statut n'est pas pr\u00eat au bout de quelques minutes, cliquez sur son nom pour voir la page de d\u00e9tails. Ensuite l'onglet \u00ab \u00c9v\u00e9nements \u00bb vous permet de savoir exactement ce qui se passe. Si n\u00e9cessaire, contactez le canal d\u2019aide sur Slack si le probl\u00e8me persiste.

    "},{"location":"1-Experiences/Kubeflow.html#cpu-et-memoire","title":"CPU et m\u00e9moire","text":"

    • Au moment de la r\u00e9daction (23 d\u00e9cembre, 2021), il existe deux types d'ordinateurs dans la grappe

      • CPU: D16s v3 (16 CPU , 64 G m\u00e9moire; 15 CPU et 48 G m\u00e9moire sont disponible pour l'utilisateur, 1 CPU et 16 G m\u00e9moire sont r\u00e9serv\u00e9s pour l'utilisation du syst\u00e8me)
      • GPU: NC6s_v3 (6 CPU , 112 G m\u00e9moire, 1 GPU; 96 G de m\u00e9moire disponible pour l'utilisateur, 16 G sont r\u00e9serv\u00e9s pour l'utilisation du syst\u00e8me)

    Lors de la cr\u00e9ation d'un serveur de bloc-notes, le syst\u00e8me vous limitera aux sp\u00e9cifications maximales ci-dessus. Pour les serveurs de bloc-notes CPU, vous pouvez sp\u00e9cifier la quantit\u00e9 exacte de CPU et de m\u00e9moire dont vous avez besoin. Cela vous permet de r\u00e9pondre \u00e0 vos besoins de calcul tout en minimisant les co\u00fbts. Pour un serveur portable GPU, vous obtiendrez toujours le serveur complet (6 c\u0153urs CPU, 96 Gio de m\u00e9moire accessible et 1 GPU).

    Dans les options avanc\u00e9es, vous pouvez s\u00e9lectionner une limite sup\u00e9rieure au nombre de c\u0153urs de processeur et de RAM demand\u00e9s. Le montant demand\u00e9 est le montant garanti disponible pour votre serveur bloc-notes et vous paierez toujours au moins ce montant. Si la limite est sup\u00e9rieure \u00e0 la quantit\u00e9 demand\u00e9e, si des c\u0153urs de RAM et de processeur suppl\u00e9mentaires sont disponibles sur ce serveur partag\u00e9 dans le cluster, votre serveur de bloc-notes peut les utiliser selon vos besoins. Un cas d\u2019utilisation est celui des t\u00e2ches qui ne n\u00e9cessitent g\u00e9n\u00e9ralement qu\u2019un seul c\u0153ur de processeur mais qui peuvent b\u00e9n\u00e9ficier du multithreading pour acc\u00e9l\u00e9rer certaines op\u00e9rations. En demandant un c\u0153ur de processeur mais une limite plus \u00e9lev\u00e9e, vous pouvez payer beaucoup moins pour le serveur boc-notes tout en lui permettant d'utiliser des c\u0153urs de processeur de rechange inutilis\u00e9s si n\u00e9cessaire pour acc\u00e9l\u00e9rer les calculs.

    "},{"location":"1-Experiences/Kubeflow.html#gpus","title":"GPUs","text":"

    Si vous voulez un serveur GPU, s\u00e9lectionnez \u00ab 1 \u00bb comme nombre de GPU et \u00ab NVIDIA \u00bb comme fournisseur de GPU (le bouton de cr\u00e9ation sera gris\u00e9 jusqu'\u00e0 ce que le fournisseur de GPU soit s\u00e9lectionn\u00e9 si vous avez un GPU sp\u00e9cifi\u00e9). Les serveurs multi-GPU sont actuellement pris en charge sur le syst\u00e8me ETAA uniquement sur une base sp\u00e9ciale sur demande, veuillez contacter les mainteneurs d'ETAA si vous souhaitez un serveur multi-GPU.

    Comme mentionn\u00e9 pr\u00e9c\u00e9demment, si vous s\u00e9lectionnez un serveur GPU, vous obtiendrez automatiquement 6 CPU c\u0153urs et 112 Go de m\u00e9moire.

    Utilisez les machines GPU de mani\u00e8re responsable

    Les machines GPU sont nettement plus ch\u00e8res que les machines CPU, alors utilisez-les de mani\u00e8re responsable.

    "},{"location":"1-Experiences/Kubeflow.html#volume-despace-de-travail","title":"Volume d'espace de travail","text":"

    Vous aurez besoin d'un volume d'espace de travail, sur lequel le dossier personnel sera mont\u00e9. Ces diff\u00e9rentes options de configuration sont disponibles\u00a0:

    • Vous pouvez soit r\u00e9utiliser un volume d'espace de travail existant auparavant, soit en cr\u00e9er un nouveau.
    • Vous pouvez sp\u00e9cifier la taille du volume de l'espace de travail, de 4\u00a0Gio \u00e0 32\u00a0Gio.

    V\u00e9rifiez les anciens volumes en regardant l'option Existant

    Lorsque vous cr\u00e9ez votre serveur vous avez la possibilit\u00e9 de r\u00e9utiliser un ancien volume ou en cr\u00e9er un nouveau. Vous souhaitez probablement r\u00e9utiliser votre ancien volume.

    "},{"location":"1-Experiences/Kubeflow.html#volumes-de-donnees","title":"Volumes de donn\u00e9es","text":"

    Vous pouvez \u00e9galement cr\u00e9er des volumes de donn\u00e9es pouvant \u00eatre utilis\u00e9s pour stocker des donn\u00e9es suppl\u00e9mentaires. Plusieurs volumes de donn\u00e9es peuvent \u00eatre cr\u00e9\u00e9s. Cliquez sur le bouton Ajouter un nouveau volume pour cr\u00e9er un nouveau volume et pr\u00e9ciser sa configuration. Cliquez sur le bouton Attacher un volume existant pour monter un volume existant vers le serveur de bloc-notes. Il existe les param\u00e8tres de configuration suivants pour les volumes de donn\u00e9es\u00a0:

    • Nom\u00a0: Nom du volume.
    • Taille en GiB\u00a0: De 4\u00a0Gio \u00e0 512\u00a0Gio.
    • Chemin de montage\u00a0: Chemin o\u00f9 le volume de donn\u00e9es est accessible sur le serveur bloc-notes, par par d\u00e9faut /home/jovyan/vol-1, /home/jovyan/vol-2, etc. (compteur incr\u00e9mentiel par donn\u00e9es volume mont\u00e9).

    Lors du montage d'un volume de donn\u00e9es existant, l'option de nom devient une liste d\u00e9roulante du volumes de donn\u00e9es existants. Uniquement un volume non actuellement mont\u00e9 sur un serveur de bloc-notes existant peut \u00eatre utilis\u00e9. L'option du chemin de montage reste configurable par l'utilisateur avec les m\u00eames valeurs par d\u00e9faut que cr\u00e9er un nouveau volume.

    L'ic\u00f4ne de la poubelle \u00e0 droite peut \u00eatre utilis\u00e9e pour supprimer un volume de donn\u00e9es existant ou cr\u00e9\u00e9 accidentellement.

    "},{"location":"1-Experiences/Kubeflow.html#configuration","title":"Configuration","text":"

    Si des configurations sont disponibles, elles sont pr\u00e9sent\u00e9es ici sous forme de cases \u00e0 cocher. Actuellement, aucune configuration n'existe.

    "},{"location":"1-Experiences/Kubeflow.html#parametres-divers","title":"Param\u00e8tres divers","text":"

    Les \u00e9l\u00e9ments suivants peuvent \u00eatre personnalis\u00e9s ici\u00a0:

    • Activer la m\u00e9moire partag\u00e9e\u00a0: ceci est requis si vous utilisez PyTorch avec plusieurs donn\u00e9es chargeurs, qui autrement g\u00e9n\u00e9reront une erreur. Si vous utilisez PyTorch, assurez-vous de ceci est activ\u00e9, sinon cela n'a pas d'importance sauf si vous avez une autre application cela n\u00e9cessite une m\u00e9moire partag\u00e9e.
    • Langue du syst\u00e8me\u00a0: Vous pouvez sp\u00e9cifier ici l'anglais ou le fran\u00e7ais.

    "},{"location":"1-Experiences/Kubeflow.html#et-creer","title":"Et... Cr\u00e9er!!!","text":"
    • Si vous \u00eates satisfait des param\u00e8tres, vous pouvez maintenant cr\u00e9er le serveur ! Cela pourrait prenez quelques minutes pour d\u00e9marrer en fonction des ressources que vous avez demand\u00e9es. (GPU prendre plus de temps.)

    Votre serveur est en cours d'ex\u00e9cution

    Si tout se passe bien, votre serveur devrait fonctionner !!! Vous aurez maintenant le possibilit\u00e9 de se connecter, et essayer Jupyter!

    "},{"location":"1-Experiences/Kubeflow.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":""},{"location":"1-Experiences/Kubeflow.html#partagez-votre-espace-de-travail","title":"Partagez votre espace de travail","text":"

    Dans Kubeflow, chaque utilisateur dispose d'un espace de noms qui contient son travail (ses serveurs blocs-note, pipelines, disques, etc.). Votre espace de nom vous appartient, mais peut \u00eatre partag\u00e9 si vous souhaitez collaborer avec d'autres. Pour plus de d\u00e9tails sur collaboration sur la plateforme, voir Collaboration.

    "},{"location":"1-Experiences/MLflow.html","title":"Aper\u00e7u","text":"

    !!! danger \"MLflow a \u00e9t\u00e9 retir\u00e9 du projet AAW. Si vous en avez besoin, contactez l'\u00e9quipe de d\u00e9veloppement\"

    MLflow s'agit d'une plateforme libre pour la gestion du cycle de vie de l'apprentissage automatique. C'est un \"registre de mod\u00e8les\" pour stocker vos mod\u00e8les d'apprentissage automatique et les m\u00e9triques associ\u00e9es. Vous pouvez utiliser l'interface web pour examiner vos mod\u00e8les, et vous pouvez utiliser son API REST pour enregistrer vos mod\u00e8les depuis Python, en utilisant le [paquet mlflow pip] (https://pypi.org/project/mlflow/).

    "},{"location":"1-Experiences/RStudio.html","title":"Aper\u00e7u","text":"

    RStudio est un environnement de d\u00e9veloppement int\u00e9gr\u00e9 (IDE) pour R. Il comprend un console, \u00e9diteur et outils de tra\u00e7age, d'historique, de d\u00e9bogage et d'espace de travail gestion.

    "},{"location":"1-Experiences/RStudio.html#didacticiel-video","title":"Didacticiel vid\u00e9o","text":""},{"location":"1-Experiences/RStudio.html#installation","title":"Installation","text":"

    Vous pouvez utiliser l'image rstudio pour obtenir un environnement RStudio ! Lorsque vous cr\u00e9ez votre bloc-notes, choisissez RStudio dans la liste des images disponibles.

    Vous pouvez installer les packages R ou python avec conda ou install.packages().

    "},{"location":"1-Experiences/RStudio.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":""},{"location":"1-Experiences/RStudio.html#r-shiny","title":"R-Shiny","text":"

    Vous pouvez aussi utiliser \u00ab\u00a0Shiny\u00a0\u00bb\u00a0! Shiny est un package R open source qui fournit un cadre web pour cr\u00e9er des applications Web \u00e0 l'aide de R. Shiny vous aide \u00e0 transformer votre analyses en applications Web interactives.

    "},{"location":"1-Experiences/RStudio.html#r-studio","title":"R\u00a0Studio","text":"

    Traiter les donn\u00e9es \u00e0 l'aide de R ou Python dans R Studio

    R Studio est un puissant environnement de d\u00e9veloppement int\u00e9gr\u00e9 (IDE) qui prend en charge les langages de programmation R et Python, ce qui en fait un choix id\u00e9al pour les analystes de donn\u00e9es et les scientifiques. Avec R Studio, vous pouvez effectuer un large \u00e9ventail de t\u00e2ches de traitement de donn\u00e9es, du nettoyage et de la transformation des donn\u00e9es \u00e0 l'analyse statistique et \u00e0 l'apprentissage automatique. Le logiciel fournit une interface conviviale et une vari\u00e9t\u00e9 d'outils et de biblioth\u00e8ques qui simplifient les t\u00e2ches complexes d'analyse de donn\u00e9es. De plus, R Studio facilite le partage de votre travail avec d'autres en cr\u00e9ant des rapports et des visualisations dynamiques et interactifs qui peuvent \u00eatre publi\u00e9s en ligne ou partag\u00e9s sous forme de documents autonomes. Dans l'ensemble, R Studio est un outil polyvalent et puissant, essentiel pour toute personne travaillant avec des donn\u00e9es en R ou Python.

    R Studio vous offre un environnement de d\u00e9veloppement int\u00e9gr\u00e9 pour R et Python. Utilisez l'image r-studio-cpu pour obtenir un environnement R Studio.

    "},{"location":"1-Experiences/Selectionner-une-image.html","title":"S\u00e9lection d'une image pour votre serveur bloc-notes","text":"

    En fonction de votre projet ou du cas d'utilisation du serveur bloc-notes, certaines images peuvent \u00eatre plus adapt\u00e9 que d'autres. Ce qui suit passera en revue les caract\u00e9ristiques principales de chacun pour vous aider \u00e0 choisir l\u2019image la plus appropri\u00e9e pour vous.

    Lors de la s\u00e9lection d'une image, vous disposez de 3 options principales\u00a0:

    • Carnet Jupyter (CPU, TensorFlow, PyTorch)
    • RStudio
    • Bureau \u00e0 distance
    "},{"location":"1-Experiences/Selectionner-une-image.html#bloc-notes-jupyter","title":"Bloc-notes Jupyter","text":"

    Les bloc-notes Jupyter sont utilis\u00e9s pour cr\u00e9er et partager documents interactifs contenant un m\u00e9lange de code en direct, de visualisations et de texte. Ceux-ci peuvent \u00eatre \u00e9crits en Python, Julia ou R.

    Les utilisations courantes incluent\u00a0:

    transformation de donn\u00e9es, simulation num\u00e9rique, statistique mod\u00e9lisation, apprentissage automatique et bien plus encore.

    Les bloc-notes Jupyter sont d'excellents tremplins pour l'analyse, y compris les apprentissage automatique. L'image jupyterlab-cpu donne une bonne exp\u00e9rience de base pour python, y compris des paquets courants tels que numpy, pandas et scikit-learn. Si vous souhaitez sp\u00e9cifiquement utiliser TensorFlow ou PyTorch, nous ont \u00e9galement jupyterlab-tensorflow et jupyterlab-pytorch qui viennent avec ceux outils pr\u00e9install\u00e9s.

    Pour l'image jupyterlab-pytorch, les paquets PyTorch (torch, torchvision, et torchaudio) sont install\u00e9s dans l'environnement conda torch. Vous devez activez cet environnement pour utiliser PyTorch.

    Pour jupyterlab-cpu, jupyterlab-tensorflow et jupyterlab-pytorch images, dans le shell par d\u00e9faut, la commande conda activate peut ne pas fonctionner. C'est en raison de l'environnement qui n'est pas initialis\u00e9 correctement. Dans ce cas, lancez bash, vous devriez voir le logo AAW et quelques instructions appara\u00eetre. Apr\u00e8s \u00e7a conda activate devrait fonctionner correctement. Si vous voyez le logo AAW au d\u00e9marrage signifie que l'environnement est correctement initialis\u00e9 et que conda activate devrait fonctionner correctement. Un correctif pour ce bug est en pr\u00e9paration, une fois celui-ci corrig\u00e9, ce paragraphe sera supprim\u00e9.

    Chaque image est pr\u00e9charg\u00e9e avec VS Code dans le navigateur si vous pr\u00e9f\u00e9rez une exp\u00e9rience IDE compl\u00e8te.

    "},{"location":"1-Experiences/Selectionner-une-image.html#rstudio","title":"RStudio","text":"

    RStudio vous offre un environnement de d\u00e9veloppement int\u00e9gr\u00e9 sp\u00e9cifiquement pour R. Si vous codez en R, il s'agit g\u00e9n\u00e9ralement du Serveur Bloc-notes \u00e0 utiliser. Utilisez l'image rstudio pour obtenir un environnement RStudio.

    "},{"location":"1-Experiences/Selectionner-une-image.html#bureau-a-distance","title":"Bureau \u00e0 distance","text":"

    Pour une exp\u00e9rience de bureau Ubuntu compl\u00e8te, utilisez l'image du bureau \u00e0 distance. Elle est pr\u00e9charg\u00e9e avec les outils Python, R et Geomatics, mais dans une exp\u00e9rience de bureau typique qui comprend \u00e9galement Firefox, VS Code et les outils Open Office. Le syst\u00e8me d'exploitation est Ubuntu 22.04 avec l'environnement de bureau XFCE.

    "},{"location":"1-Experiences/bloc-notes/DTale_FR.html","title":"D-Tale: un outil d'exploration de donn\u00e9es transparente pour Python","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -U dtale\n
    %%capture ! pip install -U dtale In\u00a0[\u00a0]: Copied! 
    import dtale\nimport pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\n\n# R\u00e9cup\u00e9ration de l'ensemble de donn\u00e9es Pok\u00e9mon\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\n# Lecture d'un ensemble de donn\u00e9es \u00e0 l'aide de Pandas\npokemon_df = pd.read_csv(file_name)\n\n# Affichage d'un ensemble de donn\u00e9es avec D-Tale\ndtale.show(pokemon_df)\n
    import dtale import pandas as pd from ydata_profiling.utils.cache import cache_file # R\u00e9cup\u00e9ration de l'ensemble de donn\u00e9es Pok\u00e9mon file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) # Lecture d'un ensemble de donn\u00e9es \u00e0 l'aide de Pandas pokemon_df = pd.read_csv(file_name) # Affichage d'un ensemble de donn\u00e9es avec D-Tale dtale.show(pokemon_df)

    D-Tale vient \u00e0 la rescousse en fournissant une interface conviviale pour les t\u00e2ches essentielles d'exploration de donn\u00e9es, \u00e9liminant ainsi le besoin de code r\u00e9p\u00e9titif et permettant de gagner un temps pr\u00e9cieux dans le processus.

    "},{"location":"1-Experiences/bloc-notes/DTale_FR.html#d-tale-un-outil-dexploration-de-donnees-transparente-pour-python","title":"D-Tale: un outil d'exploration de donn\u00e9es transparente pour Python\u00b6","text":"

    D-Tale, n\u00e9 d'une conversion SAS vers Python, transforme le processus d'exploration des donn\u00e9es en un jeu d'enfant. \u00c0 l'origine un wrapper de script Perl pour la fonction d'analyse de SAS, il a \u00e9volu\u00e9 vers un client Web l\u00e9ger parfaitement int\u00e9gr\u00e9 aux structures de donn\u00e9es Pandas.

    Construit sur un back-end Flask et un front-end React, D-Tale offre une m\u00e9thode simple pour visualiser et analyser les structures de donn\u00e9es Pandas. Son int\u00e9gration transparente avec les bloc-notes Jupyter et les terminaux Python/IPython en fait un outil polyvalent. Actuellement, il prend en charge divers objets Pandas, notamment DataFrame, Series, MultiIndex, DatetimeIndex et RangeIndex.

    D-Tale est une solution qui simplifie l'exploration des donn\u00e9es. Agissant comme un client Web l\u00e9ger sur les structures de donn\u00e9es Pandas, D-Tale offre une interface utilisateur intuitive pour effectuer diverses t\u00e2ches d'exploration de donn\u00e9es sans avoir besoin d'\u00e9crire de code.

    "},{"location":"1-Experiences/bloc-notes/DTale_FR.html#installation","title":"Installation:\u00b6","text":""},{"location":"1-Experiences/bloc-notes/DTale_FR.html#utilisation","title":"Utilisation:\u00b6","text":""},{"location":"1-Experiences/bloc-notes/DrawData_FR.html","title":"Draw Data: cr\u00e9er facilement des ensembles de donn\u00e9es synth\u00e9tiques","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -U drawdata\n
    %%capture ! pip install -U drawdata In\u00a0[\u00a0]: Copied! 
    from drawdata import draw_scatter\n\ndraw_scatter()\n
    from drawdata import draw_scatter draw_scatter() In\u00a0[\u00a0]: Copied! 
    import pandas as pd\n\n# Lecture du presse-papier dans un DataFrame\ndf = pd.read_clipboard(sep=\",\")\ndf\n
    import pandas as pd # Lecture du presse-papier dans un DataFrame df = pd.read_clipboard(sep=\",\") df In\u00a0[\u00a0]: Copied! 
    import plotly.express as px\nimport plotly\n\nplotly.offline.init_notebook_mode(connected=True)\n\n# Creating an interactive scatter plot\nfig = px.scatter(df, x='x', y='y', color='z')\nfig.update_layout(\n    autosize=False,\n    width=800,\n    height=800,\n)\nfig.show()\n
    import plotly.express as px import plotly plotly.offline.init_notebook_mode(connected=True) # Creating an interactive scatter plot fig = px.scatter(df, x='x', y='y', color='z') fig.update_layout( autosize=False, width=800, height=800, ) fig.show()

    Ce guide complet vous permet de dessiner, d'analyser et de visualiser de mani\u00e8re transparente votre ensemble de donn\u00e9es synth\u00e9tiques, rendant ainsi le processus d'enseignement des concepts d'apprentissage automatique plus intuitif et engageant.

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#draw-data-creer-facilement-des-ensembles-de-donnees-synthetiques","title":"Draw Data: cr\u00e9er facilement des ensembles de donn\u00e9es synth\u00e9tiques\u00b6","text":"

    Avez-vous d\u00e9j\u00e0 souhait\u00e9 pouvoir g\u00e9n\u00e9rer sans effort un ensemble de donn\u00e9es en dessinant visuellement des points sur un plan cart\u00e9sien? D\u00e9couvrez Draw Data, une application Python pratique con\u00e7ue pour les bloc-notes Jupyter. Cet outil vous permet de cr\u00e9er des ensembles de donn\u00e9es jouets ou synth\u00e9tiques en dessinant simplement vos id\u00e9es directement sur le graphique. Cela s\u2019av\u00e8re particuli\u00e8rement utile lors de l\u2019enseignement d\u2019algorithmes d\u2019apprentissage automatique.

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#installation","title":"Installation:\u00b6","text":""},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#commencer","title":"Commencer:\u00b6","text":"

    Pour dessiner un ensemble de donn\u00e9es, ex\u00e9cutez la cellule suivante. Vous pouvez esquisser jusqu'\u00e0 quatre classes de points. Ensuite, cliquez sur \u00ab Copier CSV \u00bb et vos points de donn\u00e9es, pr\u00e9sent\u00e9s sous forme de valeurs x, y, z s\u00e9par\u00e9es par des virgules, seront copi\u00e9s dans le presse-papiers. Pour importer les donn\u00e9es dans un Pandas DataFrame, utilisez le code suivant:

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#affichage-du-tableau-de-donnees","title":"Affichage du tableau de donn\u00e9es:\u00b6","text":"

    Une fois que vous avez termin\u00e9 votre dessin, copiez les donn\u00e9es dans le presse-papiers. L'\u00e9tape suivante consiste \u00e0 utiliser Pandas pour lire le presse-papiers et remplir un DataFrame. Voici un aper\u00e7u des premi\u00e8res entr\u00e9es:

    "},{"location":"1-Experiences/bloc-notes/DrawData_FR.html#tracer-les-donnees-dessinees","title":"Tracer les donn\u00e9es dessin\u00e9es:\u00b6","text":"

    Visualiser les points dessin\u00e9s devient un jeu d'enfant avec Plotly, qui fournit un graphique interactif. L'extrait de code suivant accomplit cela:

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html","title":"Mito Sheet: feuilles de calcul de type Excel dans JupyterLab","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -U mitosheet\n! python -m jupyter nbextension install --py --user mitosheet\n! python -m jupyter nbextension enable --py --user mitosheet\n
    %%capture ! pip install -U mitosheet ! python -m jupyter nbextension install --py --user mitosheet ! python -m jupyter nbextension enable --py --user mitosheet In\u00a0[\u00a0]: Copied! 
    import mitosheet\nmitosheet.sheet(analysis_to_replay=\"id-nxpaeypddd\")\n
    import mitosheet mitosheet.sheet(analysis_to_replay=\"id-nxpaeypddd\") In\u00a0[\u00a0]: Copied! 
    import mitosheet\nimport pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\n\n# Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\n# Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame\npokemon_df = pd.read_csv(file_name)\n\n# Lancement de Mito Sheet avec le jeu de donn\u00e9es Pok\u00e9mon\nmitosheet.sheet(pokemon_df, analysis_to_replay=\"id-flhnxtovqt\")\n
    import mitosheet import pandas as pd from ydata_profiling.utils.cache import cache_file # Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) # Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame pokemon_df = pd.read_csv(file_name) # Lancement de Mito Sheet avec le jeu de donn\u00e9es Pok\u00e9mon mitosheet.sheet(pokemon_df, analysis_to_replay=\"id-flhnxtovqt\")

    Mito Sheet vous permet d'exploiter votre ma\u00eetrise d'Excel dans l'environnement JupyterLab. Analysez en toute transparence des ensembles de donn\u00e9es, effectuez des calculs et visualisez les r\u00e9sultats, le tout dans l'interface famili\u00e8re que vous connaissez et aimez. Profitez de la puissance de Mito Sheet pour une exp\u00e9rience d\u2019analyse de donn\u00e9es plus int\u00e9gr\u00e9e et plus efficace.

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#mito-sheet-feuilles-de-calcul-de-type-excel-dans-jupyterlab","title":"Mito Sheet: feuilles de calcul de type Excel dans JupyterLab\u00b6","text":"

    Mito Sheet propose un tableur parfaitement int\u00e9gr\u00e9 \u00e0 JupyterLab, apportant une exp\u00e9rience famili\u00e8re de type Excel \u00e0 votre flux de travail d'analyse de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour installer Mito Sheet, ex\u00e9cutez la cellule suivante dans votre environnement JupyterLab:

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#commencer","title":"Commencer:\u00b6","text":"

    Commencez votre parcours Mito Sheet en ex\u00e9cutant l\u2019extrait de code suivant:

    "},{"location":"1-Experiences/bloc-notes/MitoSheet_FR.html#travailler-avec-des-donnees-excel","title":"Travailler avec des donn\u00e9es Excel:\u00b6","text":"

    Pour ceux qui sont habitu\u00e9s \u00e0 Excel, la transition vers Mito Sheet se fait en toute transparence. Importons un ensemble de donn\u00e9es de type Excel \u00e0 titre d'illustration. Nous utiliserons un ensemble de donn\u00e9es Pok\u00e9mon populaire disponible en ligne:

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html","title":"PyGWalker:\u00a0simplifier l'analyse exploratoire des donn\u00e9es avec Python","text":"In\u00a0[2]: Copied! 
    %%capture\n! pip install -U pygwalker ydata-profiling ipywidgets\n
    %%capture ! pip install -U pygwalker ydata-profiling ipywidgets In\u00a0[\u00a0]: Copied! 
    import pandas as pd\nimport pygwalker as pyg\nfrom ydata_profiling.utils.cache import cache_file\n\n# Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\n# Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame\npokemon_df = pd.read_csv(file_name)\n\n# Lancement de PyGWalker pour l'exploration visuelle\npyg.walk(pokemon_df)\n
    import pandas as pd import pygwalker as pyg from ydata_profiling.utils.cache import cache_file # Mise en cache de l'ensemble de donn\u00e9es Pok\u00e9mon \u00e0 partir d'une source distante file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) # Lecture de l'ensemble de donn\u00e9es dans un Pandas DataFrame pokemon_df = pd.read_csv(file_name) # Lancement de PyGWalker pour l'exploration visuelle pyg.walk(pokemon_df)

    Avec PyGWalker, transformez sans effort vos donn\u00e9es en applications de visualisation interactive en utilisant une seule ligne de code. Que vous soyez habitu\u00e9 \u00e0 Excel ou Power BI, PyGWalker offre une solution transparente et efficace pour explorer et comprendre vos ensembles de donn\u00e9es dans l'environnement Jupyter Notebook.

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#pygwalker-simplifier-lanalyse-exploratoire-des-donnees-avec-python","title":"PyGWalker:\u00a0simplifier l'analyse exploratoire des donn\u00e9es avec Python\u00b6","text":"

    Pr\u00e9sentation de PyGWalker, une biblioth\u00e8que Python con\u00e7ue pour rationaliser vos t\u00e2ches d'analyse exploratoire de donn\u00e9es (EDA) et de visualisation dans bloc-notes Jupyter. Con\u00e7u pour les statisticiens nationaux familiers avec Excel et Power BI, PyGWalker transforme votre dataframe pandas (et dataframe polaires) en une interface utilisateur intuitive de style Tableau, am\u00e9liorant ainsi votre exp\u00e9rience d'exploration de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#quest-ce-que-pygwalker","title":"Qu'est-ce que PyGWalker?\u00b6","text":"

    PyGWalker, affectueusement prononc\u00e9 comme \u00ab Pig Walker \u00bb, est l'abr\u00e9viation de \u00ab liaison Python de Graphic Walker \u00bb. Il s'int\u00e8gre parfaitement aux bloc-notes Jupyter, fournissant ainsi un pont vers Graphic Walker, une alternative open source \u00e0 Tableau. Cette biblioth\u00e8que permet aux data scientists d'analyser et de visualiser les donn\u00e9es sans effort gr\u00e2ce \u00e0 des op\u00e9rations simples de glisser-d\u00e9poser.

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#principales-caracteristiques","title":"Principales caract\u00e9ristiques:\u00b6","text":"
    • Interface de style Tableau: profitez d'une interface utilisateur famili\u00e8re de style Tableau pour l'exploration visuelle sans quitter l'environnement Jupyter.
    • Fonctionnalit\u00e9 glisser-d\u00e9poser: simplifiez votre flux de travail gr\u00e2ce \u00e0 des op\u00e9rations intuitives de glisser-d\u00e9poser, facilitant ainsi l'exploration des donn\u00e9es.
    • Interface utilisateur conversationnelle: participez \u00e0 l'exploration de donn\u00e9es conversationnelles via une interface conviviale.
    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour d\u00e9marrer avec PyGWalker, installez la biblioth\u00e8que ainsi que les autres d\u00e9pendances n\u00e9cessaires \u00e0 l'aide de la commande suivante:

    "},{"location":"1-Experiences/bloc-notes/PyGWalker_FR.html#exemple-dutilisation","title":"Exemple d'utilisation:\u00b6","text":"

    Passons maintenant \u00e0 un exemple pratique utilisant un ensemble de donn\u00e9es. Dans ce cas, nous exploiterons un ensemble de donn\u00e9es Pok\u00e9mon disponible en ligne:

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html","title":"ReRun : Visualisez tout rapidement et efficacement !","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -U rerun-sdk\n
    %%capture ! pip install -U rerun-sdk In\u00a0[\u00a0]: Copied! 
    import rerun as rr\n\nrec = rr.memory_recording()\nrec.show(width=1024, height=768)\n
    import rerun as rr rec = rr.memory_recording() rec.show(width=1024, height=768) In\u00a0[\u00a0]: Copied! 
    import rerun as rr\nimport numpy as np\n\nrec = rr.memory_recording()\n\nSIZE = 10\n\npos_grid = np.meshgrid(*[np.linspace(-10, 10, SIZE)]*3)\npositions = np.vstack([d.reshape(-1) for d in pos_grid]).T\n\ncol_grid = np.meshgrid(*[np.linspace(0, 255, SIZE)]*3)\ncolors = np.vstack([c.reshape(-1) for c in col_grid]).astype(np.uint8).T\n\nrr.log(\n    \"my_points\",\n    rr.Points3D(positions, colors=colors, radii=0.5)\n)\n\nrec.show(width=1024, height=768)\n
    import rerun as rr import numpy as np rec = rr.memory_recording() SIZE = 10 pos_grid = np.meshgrid(*[np.linspace(-10, 10, SIZE)]*3) positions = np.vstack([d.reshape(-1) for d in pos_grid]).T col_grid = np.meshgrid(*[np.linspace(0, 255, SIZE)]*3) colors = np.vstack([c.reshape(-1) for c in col_grid]).astype(np.uint8).T rr.log( \"my_points\", rr.Points3D(positions, colors=colors, radii=0.5) ) rec.show(width=1024, height=768) In\u00a0[\u00a0]: Copied! 
    from __future__ import annotations\n\nimport argparse\nfrom math import tau\n\nimport numpy as np\n\nimport rerun as rr  # pip install rerun-sdk\nfrom rerun.utilities import bounce_lerp, build_color_spiral\n\nrec = rr.memory_recording()\n\nrr.set_time_seconds(\"stable_time\", 0)\n\nNUM_POINTS = 100\n\n# points and colors are both np.array((NUM_POINTS, 3))\npoints1, colors1 = build_color_spiral(NUM_POINTS)\npoints2, colors2 = build_color_spiral(NUM_POINTS, angular_offset=tau * 0.5)\nrr.log(\"helix/structure/left\", rr.Points3D(points1, colors=colors1, radii=0.08))\nrr.log(\"helix/structure/right\", rr.Points3D(points2, colors=colors2, radii=0.08))\n\nrr.log(\"helix/structure/scaffolding\", rr.LineStrips3D(np.stack((points1, points2), axis=1), colors=[128, 128, 128]))\n\ntime_offsets = np.random.rand(NUM_POINTS)\nfor i in range(400):\n    time = i * 0.01\n    rr.set_time_seconds(\"stable_time\", time)\n\n    times = np.repeat(time, NUM_POINTS) + time_offsets\n    beads = [bounce_lerp(points1[n], points2[n], times[n]) for n in range(NUM_POINTS)]\n    colors = [[int(bounce_lerp(80, 230, times[n] * 2))] for n in range(NUM_POINTS)]\n    rr.log(\n        \"helix/structure/scaffolding/beads\", rr.Points3D(beads, radii=0.06, colors=np.repeat(colors, 3, axis=-1))\n    )\n\n    rr.log(\n        \"helix/structure\",\n        rr.Transform3D(rotation=rr.RotationAxisAngle(axis=[0, 0, 1], radians=time / 4.0 * tau)),\n    )\n\nrec.show(width=1024, height=768)\n
    from __future__ import annotations import argparse from math import tau import numpy as np import rerun as rr # pip install rerun-sdk from rerun.utilities import bounce_lerp, build_color_spiral rec = rr.memory_recording() rr.set_time_seconds(\"stable_time\", 0) NUM_POINTS = 100 # points and colors are both np.array((NUM_POINTS, 3)) points1, colors1 = build_color_spiral(NUM_POINTS) points2, colors2 = build_color_spiral(NUM_POINTS, angular_offset=tau * 0.5) rr.log(\"helix/structure/left\", rr.Points3D(points1, colors=colors1, radii=0.08)) rr.log(\"helix/structure/right\", rr.Points3D(points2, colors=colors2, radii=0.08)) rr.log(\"helix/structure/scaffolding\", rr.LineStrips3D(np.stack((points1, points2), axis=1), colors=[128, 128, 128])) time_offsets = np.random.rand(NUM_POINTS) for i in range(400): time = i * 0.01 rr.set_time_seconds(\"stable_time\", time) times = np.repeat(time, NUM_POINTS) + time_offsets beads = [bounce_lerp(points1[n], points2[n], times[n]) for n in range(NUM_POINTS)] colors = [[int(bounce_lerp(80, 230, times[n] * 2))] for n in range(NUM_POINTS)] rr.log( \"helix/structure/scaffolding/beads\", rr.Points3D(beads, radii=0.06, colors=np.repeat(colors, 3, axis=-1)) ) rr.log( \"helix/structure\", rr.Transform3D(rotation=rr.RotationAxisAngle(axis=[0, 0, 1], radians=time / 4.0 * tau)), ) rec.show(width=1024, height=768) In\u00a0[\u00a0]: Copied! 
    from __future__ import annotations\n\nimport argparse\nimport random\nfrom math import cos, sin, tau\n\nimport numpy as np\nimport rerun as rr  # pip install rerun-sdk\n\nrec = rr.memory_recording()\n\ndef clamp(n, smallest, largest):  # type: ignore[no-untyped-def]\n    return max(smallest, min(n, largest))\n\n\ndef log_bar_chart() -> None:\n    rr.set_time_sequence(\"frame_nr\", 0)\n    # Log a gauss bell as a bar chart\n    mean = 0\n    std = 1\n    variance = np.square(std)\n    x = np.arange(-5, 5, 0.1)\n    y = np.exp(-np.square(x - mean) / 2 * variance) / (np.sqrt(2 * np.pi * variance))\n    rr.log(\"bar_chart\", rr.BarChart(y))\n\n\ndef log_parabola() -> None:\n    # Log a parabola as a time series\n    for t in range(0, 1000, 10):\n        rr.set_time_sequence(\"frame_nr\", t)\n\n        f_of_t = (t * 0.01 - 5) ** 3 + 1\n        radius = clamp(abs(f_of_t) * 0.1, 0.5, 10.0)\n        color = [255, 255, 0]\n        if f_of_t < -10.0:\n            color = [255, 0, 0]\n        elif f_of_t > 10.0:\n            color = [0, 255, 0]\n\n        rr.log(\n            \"curves/parabola\",\n            rr.TimeSeriesScalar(\n                f_of_t,\n                label=\"f(t) = (0.01t - 3)\u00b3 + 1\",\n                radius=radius,\n                color=color,\n            ),\n        )\n\n\ndef log_trig() -> None:\n    # Log a time series\n    for t in range(0, int(tau * 2 * 100.0)):\n        rr.set_time_sequence(\"frame_nr\", t)\n\n        sin_of_t = sin(float(t) / 100.0)\n        rr.log(\"trig/sin\", rr.TimeSeriesScalar(sin_of_t, label=\"sin(0.01t)\", color=[255, 0, 0]))\n\n        cos_of_t = cos(float(t) / 100.0)\n        rr.log(\"trig/cos\", rr.TimeSeriesScalar(cos_of_t, label=\"cos(0.01t)\", color=[0, 255, 0]))\n\n\ndef log_classification() -> None:\n    # Log a time series\n    for t in range(0, 1000, 2):\n        rr.set_time_sequence(\"frame_nr\", t)\n\n        f_of_t = (2 * 0.01 * t) + 2\n        color = [255, 255, 0]\n        rr.log(\"classification/line\", rr.TimeSeriesScalar(f_of_t, color=color, radius=3.0))\n\n        g_of_t = f_of_t + random.uniform(-5.0, 5.0)\n        if g_of_t < f_of_t - 1.5:\n            color = [255, 0, 0]\n        elif g_of_t > f_of_t + 1.5:\n            color = [0, 255, 0]\n        else:\n            color = [255, 255, 255]\n        radius = abs(g_of_t - f_of_t)\n        rr.log(\"classification/samples\", rr.TimeSeriesScalar(g_of_t, color=color, scattered=True, radius=radius))\n\n\nlog_bar_chart()\nlog_parabola()\nlog_trig()\nlog_classification()\n\nrec.show(width=1024, height=768)\n
    from __future__ import annotations import argparse import random from math import cos, sin, tau import numpy as np import rerun as rr # pip install rerun-sdk rec = rr.memory_recording() def clamp(n, smallest, largest): # type: ignore[no-untyped-def] return max(smallest, min(n, largest)) def log_bar_chart() -> None: rr.set_time_sequence(\"frame_nr\", 0) # Log a gauss bell as a bar chart mean = 0 std = 1 variance = np.square(std) x = np.arange(-5, 5, 0.1) y = np.exp(-np.square(x - mean) / 2 * variance) / (np.sqrt(2 * np.pi * variance)) rr.log(\"bar_chart\", rr.BarChart(y)) def log_parabola() -> None: # Log a parabola as a time series for t in range(0, 1000, 10): rr.set_time_sequence(\"frame_nr\", t) f_of_t = (t * 0.01 - 5) ** 3 + 1 radius = clamp(abs(f_of_t) * 0.1, 0.5, 10.0) color = [255, 255, 0] if f_of_t < -10.0: color = [255, 0, 0] elif f_of_t > 10.0: color = [0, 255, 0] rr.log( \"curves/parabola\", rr.TimeSeriesScalar( f_of_t, label=\"f(t) = (0.01t - 3)\u00b3 + 1\", radius=radius, color=color, ), ) def log_trig() -> None: # Log a time series for t in range(0, int(tau * 2 * 100.0)): rr.set_time_sequence(\"frame_nr\", t) sin_of_t = sin(float(t) / 100.0) rr.log(\"trig/sin\", rr.TimeSeriesScalar(sin_of_t, label=\"sin(0.01t)\", color=[255, 0, 0])) cos_of_t = cos(float(t) / 100.0) rr.log(\"trig/cos\", rr.TimeSeriesScalar(cos_of_t, label=\"cos(0.01t)\", color=[0, 255, 0])) def log_classification() -> None: # Log a time series for t in range(0, 1000, 2): rr.set_time_sequence(\"frame_nr\", t) f_of_t = (2 * 0.01 * t) + 2 color = [255, 255, 0] rr.log(\"classification/line\", rr.TimeSeriesScalar(f_of_t, color=color, radius=3.0)) g_of_t = f_of_t + random.uniform(-5.0, 5.0) if g_of_t < f_of_t - 1.5: color = [255, 0, 0] elif g_of_t > f_of_t + 1.5: color = [0, 255, 0] else: color = [255, 255, 255] radius = abs(g_of_t - f_of_t) rr.log(\"classification/samples\", rr.TimeSeriesScalar(g_of_t, color=color, scattered=True, radius=radius)) log_bar_chart() log_parabola() log_trig() log_classification() rec.show(width=1024, height=768)"},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#rerun-visualisez-tout-rapidement-et-efficacement","title":"ReRun : Visualisez tout rapidement et efficacement !\u00b6","text":"

    Bienvenue dans le monde de ReRun, votre SDK incontournable pour visualiser des donn\u00e9es multimodales qui \u00e9voluent dynamiquement avec le temps. Les ing\u00e9nieurs et chercheurs dans des domaines tels que la vision par ordinateur et la robotique utilisent ReRun pour v\u00e9rifier, d\u00e9boguer et pr\u00e9senter leurs projets avec une efficacit\u00e9 in\u00e9gal\u00e9e.

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#points-forts","title":"Points Forts\u00b6","text":"

    • Mod\u00e8le Open-Core : ReRun fonctionne sur un mod\u00e8le open-core, garantissant que tout dans ce r\u00e9f\u00e9rentiel reste open source et gratuit. \u00c0 l'avenir, ReRun introduira un produit commercial construit sur la base solide du projet de base gratuit.

    • Adapt\u00e9 aux individus et aux \u00e9quipes : Le projet open source r\u00e9pond aux besoins des d\u00e9veloppeurs individuels, tandis que le futur produit commercial abordera sp\u00e9cifiquement les exigences des \u00e9quipes impliqu\u00e9es dans la construction et l'ex\u00e9cution de produits de vision par ordinateur et de robotique.

    • Polyvalent et multiplateforme : ReRun est un SDK et un moteur con\u00e7u pour visualiser et interagir avec des flux de donn\u00e9es multimodaux. Il est simple \u00e0 int\u00e9grer et \u00e0 d\u00e9marrer, utilisable \u00e0 partir de Python, Rust et C++, et construit en Rust pour une compatibilit\u00e9 multiplateforme et une rapidit\u00e9 optimale.

    • Open Source : ReRun s'engage envers les principes open source, avec une double licence MIT et Apache 2.

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#installation","title":"Installation\u00b6","text":"

    Pour lib\u00e9rer la puissance de ReRun, installez-le dans votre environnement JupyterLab avec une commande simple :

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#commencer","title":"Commencer\u00b6","text":"

    Pour une exp\u00e9rience ReRun optimale, il est recommand\u00e9 d'utiliser une session de bureau Linux, Mac ou Windows au lieu de JupyterLab. Acc\u00e9dez \u00e0 la visionneuse ReRun compl\u00e8te en ex\u00e9cutant rr.spawn() dans le script suivant \u00e0 partir de votre \u00e9mulateur de terminal\u00a0:

    importer la r\u00e9ex\u00e9cution en tant que rr\n\nrr.spawn()\n

    Cependant, si JupyterLab est votre environnement pr\u00e9f\u00e9r\u00e9, ReRun y fonctionne de mani\u00e8re transparente. Reportez-vous \u00e0 la documentation officielle pour plus de d\u00e9tails sur l'ex\u00e9cution de ReRun dans JupyterLab. L'exemple JupyterLab le plus simple consiste \u00e0 ouvrir ReRun \u00e0 l'aide des m\u00e9thodes memory_recording() et show()\u00a0:

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#visualisation-3d-le-cube","title":"Visualisation 3D : Le Cube\u00b6","text":"

    D\u00e9couvrez la simplicit\u00e9 de la visualisation 3D avec ReRun en g\u00e9n\u00e9rant et en tra\u00e7ant des points dans l'espace :

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#visualisation-3d-avancee-ladn","title":"Visualisation 3D avanc\u00e9e : L'ADN\u00b6","text":"

    Explorez un exemple fascinant de visualisation synth\u00e9tique de donn\u00e9es 3D en forme de double h\u00e9lice :

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#donnees-de-series-chronologiques-des-traces-qui-impressionnent","title":"Donn\u00e9es de s\u00e9ries chronologiques\u00a0: des trac\u00e9s qui impressionnent\u00b6","text":"

    ReRun brille vraiment lors de la visualisation de donn\u00e9es de s\u00e9ries chronologiques multimodales. L'exemple suivant d\u00e9montre les prouesses de ReRun dans l'affichage de divers trac\u00e9s correspondant \u00e0 diff\u00e9rentes lectures sur les m\u00eames donn\u00e9es de s\u00e9rie chronologique\u00a0:

    "},{"location":"1-Experiences/bloc-notes/ReRun_FR.html#plongez-plus-profondement","title":"Plongez plus profond\u00e9ment\u00b6","text":"

    Pour une compr\u00e9hension approfondie de ReRun et de ses fonctionnalit\u00e9s, reportez-vous au d\u00e9marrage rapide officiel de ReRun Python.

    D\u00e9sormais, arm\u00e9 de ReRun, embarquez pour un voyage de visualisation et d\u2019exploration de donn\u00e9es sans pr\u00e9c\u00e9dent. Bon codage\u00a0!

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html","title":"SweetViz: rationaliser l'EDA avec des visualisations \u00e9l\u00e9gantes","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -U sweetviz ydata-profiling\n
    %%capture ! pip install -U sweetviz ydata-profiling In\u00a0[\u00a0]: Copied! 
    import sweetviz as sv\nimport pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\n\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\n\nmy_report = sv.analyze(pokemon_df)\nmy_report.show_notebook()\n
    import sweetviz as sv import pandas as pd from ydata_profiling.utils.cache import cache_file file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) my_report = sv.analyze(pokemon_df) my_report.show_notebook() 
                                                 |                                                                \u2026
    In\u00a0[\u00a0]: Copied! 
    from sklearn.model_selection import train_test_split\n\nX = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']]\ny = pokemon_df[['Type 1', 'Type 2']]\n\nX_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.33, random_state=42)\n\ntrain_df = X_train\ntest_df = X_test\n\ncomparison_report = sv.compare(train_df, test_df, target_feat='Attack')\ncomparison_report.show_notebook()\n
    from sklearn.model_selection import train_test_split X = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']] y = pokemon_df[['Type 1', 'Type 2']] X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42) train_df = X_train test_df = X_test comparison_report = sv.compare(train_df, test_df, target_feat='Attack') comparison_report.show_notebook()

    Renforcez votre parcours d'exploration de donn\u00e9es avec SweetViz, en cr\u00e9ant des rapports visuellement attrayants et informatifs avec un minimum d'effort. Que vous soyez un data scientist, un \u00e9tudiant ou un chercheur, SweetViz propose une approche conviviale pour obtenir un aper\u00e7u rapide de vos ensembles de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#sweetviz-rationaliser-leda-avec-des-visualisations-elegantes","title":"SweetViz: rationaliser l'EDA avec des visualisations \u00e9l\u00e9gantes\u00b6","text":"

    SweetViz, une biblioth\u00e8que Python open source, simplifie le processus d'analyse exploratoire des donn\u00e9es (EDA) avec seulement deux lignes de code, g\u00e9n\u00e9rant des visualisations \u00e9poustouflantes et haute densit\u00e9. Le r\u00e9sultat est une application HTML enti\u00e8rement autonome, ce qui en fait un outil pratique pour un aper\u00e7u rapide des caract\u00e9ristiques des donn\u00e9es et des comparaisons entre les ensembles de donn\u00e9es.

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#principales-caracteristiques","title":"Principales caract\u00e9ristiques:\u00b6","text":"
    • Analyse cible: Visualisez comment une valeur cible (par exemple, \u00ab\u00a0Surv\u00e9cu\u00a0\u00bb dans l'ensemble de donn\u00e9es Titanic) est en corr\u00e9lation avec d'autres caract\u00e9ristiques, ce qui facilite la compr\u00e9hension des caract\u00e9ristiques de la cible.
    • Visualisez et comparez: Comparez sans effort des ensembles de donn\u00e9es distincts, tels que les donn\u00e9es d'entra\u00eenement et de test, et explorez les caract\u00e9ristiques intra-ensemble (par exemple, homme contre femme).
    • Associations de types mixtes: SweetViz int\u00e8gre de mani\u00e8re transparente des associations pour les types de donn\u00e9es num\u00e9riques (corr\u00e9lation de Pearson), cat\u00e9gorielles (coefficient d'incertitude) et cat\u00e9gorielles-num\u00e9riques (rapport de corr\u00e9lation), fournissant des informations compl\u00e8tes pour divers types de donn\u00e9es.
    • Inf\u00e9rence de type: D\u00e9tecte automatiquement les fonctionnalit\u00e9s num\u00e9riques, cat\u00e9gorielles et textuelles, avec la possibilit\u00e9 de remplacements manuels si n\u00e9cessaire.
    • Informations r\u00e9capitulatives: Obtenez des informations sur le type, les valeurs uniques, les valeurs manquantes, les lignes en double et les valeurs les plus fr\u00e9quentes dans l'ensemble de donn\u00e9es.
    • Analyse num\u00e9rique: Explorez les fonctionnalit\u00e9s num\u00e9riques avec des statistiques telles que min/max/plage, quartiles, moyenne, mode, \u00e9cart type, somme, \u00e9cart absolu m\u00e9dian, coefficient de variation, aplatissement et asym\u00e9trie.
    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour d\u00e9marrer avec SweetViz, installez la biblioth\u00e8que ainsi que les autres d\u00e9pendances n\u00e9cessaires \u00e0 l'aide de la commande suivante:

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#exemple-de-base","title":"Exemple de base:\u00b6","text":"

    Effectuer une EDA de base avec SweetViz ne n\u00e9cessite que deux lignes de code. Dans l'exemple ci-dessous, nous analysons un ensemble de donn\u00e9es Pok\u00e9mon et g\u00e9n\u00e9rons un rapport d\u00e9taill\u00e9:

    "},{"location":"1-Experiences/bloc-notes/SweetViz_FR.html#comparaison-de-deux-dataframes","title":"Comparaison de deux dataframes:\u00b6","text":"

    SweetViz \u00e9tend ses capacit\u00e9s pour comparer deux ensembles de donn\u00e9es, tels que des ensembles de formation et de test. Dans cet exemple plus complexe, nous examinons les diff\u00e9rences dans la fonctionnalit\u00e9 \u00ab\u00a0Attaque\u00a0\u00bb:

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html","title":"Visual Python:\u00a0simplifier l'analyse des donn\u00e9es pour les apprenants Python","text":"In\u00a0[1]: Copied! 
    %%capture\n! pip install -U jupyterlab-visualpython plotly wordcloud\n
    %%capture ! pip install -U jupyterlab-visualpython plotly wordcloud In\u00a0[2]: Copied! 
    import pandas as pd\nfrom ydata_profiling.utils.cache import cache_file\nfrom wordcloud import WordCloud\nfrom collections import Counter\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\ncounts = Counter(pokemon_df[[\"Type 1\"]].to_string().split())\ntags = counts.most_common(200)\n\nwc = WordCloud(max_font_size=200, background_color='white', width=1000, height=800)\ncloud = wc.generate_from_frequencies(dict(tags))\n\nplt.figure(figsize=(8, 20))\nplt.imshow(cloud)\nplt.tight_layout(pad=0)\nplt.axis('off')\nplt.show()\n
    import pandas as pd from ydata_profiling.utils.cache import cache_file from wordcloud import WordCloud from collections import Counter import matplotlib.pyplot as plt %matplotlib inline file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) counts = Counter(pokemon_df[[\"Type 1\"]].to_string().split()) tags = counts.most_common(200) wc = WordCloud(max_font_size=200, background_color='white', width=1000, height=800) cloud = wc.generate_from_frequencies(dict(tags)) plt.figure(figsize=(8, 20)) plt.imshow(cloud) plt.tight_layout(pad=0) plt.axis('off') plt.show() 
    Matplotlib is building the font cache; this may take a moment.\n
    In\u00a0[3]: Copied! 
    import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport plotly.express as px\nfrom plotly.offline import init_notebook_mode\nimport pyarrow as pa\n\ninit_notebook_mode(connected=True)\n%matplotlib inline\n\nvp_df = pokemon_df[['HP', 'Attack', 'Defense', 'Speed']].copy()\nvp_df.head()\n
    import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import plotly.express as px from plotly.offline import init_notebook_mode import pyarrow as pa init_notebook_mode(connected=True) %matplotlib inline vp_df = pokemon_df[['HP', 'Attack', 'Defense', 'Speed']].copy() vp_df.head() 
    \n---------------------------------------------------------------------------\nModuleNotFoundError                       Traceback (most recent call last)\nCell In[3], line 7\n      5 import plotly.express as px\n      6 from plotly.offline import init_notebook_mode\n----> 7 import pyarrow as pa\n      9 init_notebook_mode(connected=True)\n     10 get_ipython().run_line_magic('matplotlib', 'inline')\n\nModuleNotFoundError: No module named 'pyarrow'
    In\u00a0[\u00a0]: Copied! 
    from IPython.display import display, Markdown\ndisplay(pd.DataFrame({\n    'N Total':vp_df.shape[0],\n    'N Valid':vp_df.count(numeric_only=True),\n    'N Missing':vp_df.loc[:,vp_df.apply(pd.api.types.is_numeric_dtype)].isnull().sum(),\n    'Mean':vp_df.mean(numeric_only=True),\n    'Median':vp_df.median(numeric_only=True),\n    'Mode':vp_df.mode(numeric_only=True).iloc[0],\n    'Sum':vp_df.sum(numeric_only=True),\n    'Minimun':vp_df.min(numeric_only=True),\n    'Maximum':vp_df.max(numeric_only=True),\n    'Range':vp_df.max(numeric_only=True) - vp_df.min(numeric_only=True),\n    'Std. deviation':vp_df.std(numeric_only=True),\n    'S.E. mean':vp_df.std(numeric_only=True)/np.sqrt(vp_df.count(numeric_only=True)),\n    'Skewness':vp_df.skew(numeric_only=True),\n    'Kurtosis':vp_df.kurtosis(numeric_only=True),\n    'Percentile: 25':vp_df.quantile(q=0.25, numeric_only=True),\n    'Percentile: 50':vp_df.quantile(q=0.50, numeric_only=True),\n    'Percentile: 75':vp_df.quantile(q=0.75, numeric_only=True),\n}).round(3).T)\n
    from IPython.display import display, Markdown display(pd.DataFrame({ 'N Total':vp_df.shape[0], 'N Valid':vp_df.count(numeric_only=True), 'N Missing':vp_df.loc[:,vp_df.apply(pd.api.types.is_numeric_dtype)].isnull().sum(), 'Mean':vp_df.mean(numeric_only=True), 'Median':vp_df.median(numeric_only=True), 'Mode':vp_df.mode(numeric_only=True).iloc[0], 'Sum':vp_df.sum(numeric_only=True), 'Minimun':vp_df.min(numeric_only=True), 'Maximum':vp_df.max(numeric_only=True), 'Range':vp_df.max(numeric_only=True) - vp_df.min(numeric_only=True), 'Std. deviation':vp_df.std(numeric_only=True), 'S.E. mean':vp_df.std(numeric_only=True)/np.sqrt(vp_df.count(numeric_only=True)), 'Skewness':vp_df.skew(numeric_only=True), 'Kurtosis':vp_df.kurtosis(numeric_only=True), 'Percentile: 25':vp_df.quantile(q=0.25, numeric_only=True), 'Percentile: 50':vp_df.quantile(q=0.50, numeric_only=True), 'Percentile: 75':vp_df.quantile(q=0.75, numeric_only=True), }).round(3).T) In\u00a0[\u00a0]: Copied! 
    for col in vp_df.columns:\n    if pd.api.types.is_numeric_dtype(vp_df[col]) and  vp_df[col].value_counts().size > 10:\n        _bins = 10\n    else: _bins = None\n        \n    _dfr = pd.DataFrame({\n              'Frequency':vp_df[col].value_counts(bins=_bins, sort=False),\n              'Percent':100*(vp_df[col].value_counts(bins=_bins, sort=False) / vp_df[col].size),\n              'Valid percent':100*(vp_df[col].value_counts(bins=_bins, sort=False)/vp_df[col].count())\n}).round(2)\n    _dfr['Cumulative percent'] = _dfr['Valid percent'].cumsum()\n    _dfr.loc['N Valid',:] =  _dfr.iloc[:,:3].sum()\n    _dfr.loc['N Missing','Frequency'] =  vp_df[col].isnull().sum()\n    _dfr.loc['N Total','Frequency'] =  vp_df[col].size\n    display(Markdown(f\"### {col}\"))\n    display(_dfr)\n
    for col in vp_df.columns: if pd.api.types.is_numeric_dtype(vp_df[col]) and vp_df[col].value_counts().size > 10: _bins = 10 else: _bins = None _dfr = pd.DataFrame({ 'Frequency':vp_df[col].value_counts(bins=_bins, sort=False), 'Percent':100*(vp_df[col].value_counts(bins=_bins, sort=False) / vp_df[col].size), 'Valid percent':100*(vp_df[col].value_counts(bins=_bins, sort=False)/vp_df[col].count()) }).round(2) _dfr['Cumulative percent'] = _dfr['Valid percent'].cumsum() _dfr.loc['N Valid',:] = _dfr.iloc[:,:3].sum() _dfr.loc['N Missing','Frequency'] = vp_df[col].isnull().sum() _dfr.loc['N Total','Frequency'] = vp_df[col].size display(Markdown(f\"### {col}\")) display(_dfr) In\u00a0[\u00a0]: Copied! 
    import seaborn as sns\nimport warnings\nwith warnings.catch_warnings():\n    warnings.simplefilter(action='ignore', category=Warning)\n\n    display(Markdown(\"### Histogramme\"))\n    idx = 1\n    for col in vp_df.columns:\n        plt.subplot(2,2, idx)\n        if pd.api.types.is_numeric_dtype(vp_df[col]) and  vp_df[col].value_counts().size > 10:\n            sns.histplot(data=vp_df, x=col, kde=True)\n        else:\n            sns.countplot(data=vp_df, x=col)\n        \n        if idx < 4:\n            idx += 1\n        else:\n            idx = 1\n            plt.tight_layout()\n            plt.show()\n        \n    display(Markdown(\"### Matrice de dispersion\"))\n    pd.plotting.scatter_matrix(vp_df, marker='o', hist_kwds={'bins': 30}, s=30, alpha=.8)\n    plt.show()\n\n    display(Markdown(\"### Bo\u00eete \u00e0 moustaches\"))\n    sns.boxplot(vp_df)\n    plt.show()\n
    import seaborn as sns import warnings with warnings.catch_warnings(): warnings.simplefilter(action='ignore', category=Warning) display(Markdown(\"### Histogramme\")) idx = 1 for col in vp_df.columns: plt.subplot(2,2, idx) if pd.api.types.is_numeric_dtype(vp_df[col]) and vp_df[col].value_counts().size > 10: sns.histplot(data=vp_df, x=col, kde=True) else: sns.countplot(data=vp_df, x=col) if idx < 4: idx += 1 else: idx = 1 plt.tight_layout() plt.show() display(Markdown(\"### Matrice de dispersion\")) pd.plotting.scatter_matrix(vp_df, marker='o', hist_kwds={'bins': 30}, s=30, alpha=.8) plt.show() display(Markdown(\"### Bo\u00eete \u00e0 moustaches\")) sns.boxplot(vp_df) plt.show() In\u00a0[\u00a0]: Copied! 
    sns.scatterplot(data=pokemon_df, x='HP', y='Defense', hue='Attack', color='#d6d6d6')\nplt.legend(loc='upper right')\nplt.title('Pokemon')\nplt.xlabel('HP')\nplt.ylabel('Defense')\nplt.show()\n
    sns.scatterplot(data=pokemon_df, x='HP', y='Defense', hue='Attack', color='#d6d6d6') plt.legend(loc='upper right') plt.title('Pokemon') plt.xlabel('HP') plt.ylabel('Defense') plt.show()

    Renforcez votre parcours d'apprentissage Python avec Visual Python, en r\u00e9duisant les obstacles \u00e0 l'analyse et \u00e0 la visualisation des donn\u00e9es, en particulier pour ceux qui sont habitu\u00e9s \u00e0 Excel, Power BI et SAS dans le domaine des organisations statistiques nationales du gouvernement.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#visual-python-simplifier-lanalyse-des-donnees-pour-les-apprenants-python","title":"Visual Python:\u00a0simplifier l'analyse des donn\u00e9es pour les apprenants Python\u00b6","text":"

    Visual Python appara\u00eet comme un g\u00e9n\u00e9rateur de code Python intuitif bas\u00e9 sur une interface graphique, parfaitement int\u00e9gr\u00e9 \u00e0 Jupyter Lab, Jupyter Notebook et Google Colab. De plus, les utilisateurs peuvent opter pour le Visual Python Desktop autonome. Ce projet open source a \u00e9t\u00e9 lanc\u00e9 pour aider les \u00e9tudiants \u00e0 naviguer dans les cours Python pour la science des donn\u00e9es, en offrant une approche rationalis\u00e9e du codage.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#avantages-cles","title":"Avantages cl\u00e9s:\u00b6","text":"
    • Gestion des donn\u00e9es avec un codage minimal: Visual Python facilite la gestion de grands ensembles de donn\u00e9es avec un minimum de comp\u00e9tences en codage, ce qui en fait un outil id\u00e9al pour les d\u00e9butants.
    • Surmonter les barri\u00e8res d'apprentissage: Con\u00e7u pour les \u00e9tudiants, les analystes commerciaux et les chercheurs, Visual Python aide \u00e0 surmonter les barri\u00e8res d'apprentissage associ\u00e9es \u00e0 la programmation Python.
    • Gestion des extraits de code: Enregistrez et r\u00e9utilisez sans effort les extraits de code fr\u00e9quemment utilis\u00e9s.
    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#installation","title":"Installation:\u00b6","text":"

    Pour exploiter la puissance de Visual Python, installez les packages requis \u00e0 l'aide de la commande suivante:

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#exemple-avec-lensemble-de-donnees-pokemon","title":"Exemple avec l'ensemble de donn\u00e9es Pok\u00e9mon:\u00b6","text":"

    Explorons les capacit\u00e9s de Visual Python \u00e0 l'aide de l'ensemble de donn\u00e9es Pok\u00e9mon. Cet exemple montre comment Visual Python g\u00e9n\u00e8re du code pour un nuage de mots, fournissant une repr\u00e9sentation visuelle sans avoir besoin de m\u00e9moriser la syntaxe complexe de matplotlib.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#statistiques-descriptives-et-visualisation","title":"Statistiques descriptives et visualisation:\u00b6","text":"

    Visual Python \u00e9tend ses capacit\u00e9s aux statistiques descriptives et \u00e0 la visualisation de donn\u00e9es. L'extrait de code ci-dessous montre comment Visual Python simplifie le processus, en g\u00e9n\u00e9rant des graphiques et des statistiques avec un minimum d'effort.

    "},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#statistiques-descriptives","title":"Statistiques descriptives\u00b6","text":""},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#tableau-des-frequences","title":"Tableau des fr\u00e9quences\u00b6","text":""},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#graphiques","title":"Graphiques\u00b6","text":""},{"location":"1-Experiences/bloc-notes/VisualPython_FR.html#visualisation-seaborn-avec-visual-python","title":"Visualisation Seaborn avec Visual Python:\u00b6","text":"

    Visual Python simplifie la cr\u00e9ation de cartes Seaborn. Pas besoin de fouiller dans la documentation; Visual Python fonctionne comme un syst\u00e8me de mod\u00e8les, g\u00e9n\u00e9rant du code pouvant \u00eatre facilement modifi\u00e9.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html","title":"Profilage YData: rationalisation de l'analyse des donn\u00e9es","text":"In\u00a0[\u00a0]: Copied! 
    %%capture\n! pip install -U ydata-profiling ipywidgets scikit-learn\n
    %%capture ! pip install -U ydata-profiling ipywidgets scikit-learn In\u00a0[\u00a0]: Copied! 
    import numpy as np\nimport pandas as pd\n\nfrom ydata_profiling import ProfileReport\nfrom ydata_profiling.utils.cache import cache_file\n\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\n\nprofile_report = ProfileReport(\n    pokemon_df,\n    sort=None,\n    html={\n        \"style\": {\"full_width\": True}\n    }, \n    progress_bar=False,\n    correlations={\n        \"auto\": {\"calculate\": True},\n        \"pearson\": {\"calculate\": False},\n        \"spearman\": {\"calculate\": False},\n        \"kendall\": {\"calculate\": False},\n        \"phi_k\": {\"calculate\": True},\n        \"cramers\": {\"calculate\": True},\n    },\n    explorative=True,\n    title=\"Profiling Report\"\n)\n\nprofile_report.to_file(\"../output/pokemon.html\")\n\nprofile_report\n
    import numpy as np import pandas as pd from ydata_profiling import ProfileReport from ydata_profiling.utils.cache import cache_file file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) profile_report = ProfileReport( pokemon_df, sort=None, html={ \"style\": {\"full_width\": True} }, progress_bar=False, correlations={ \"auto\": {\"calculate\": True}, \"pearson\": {\"calculate\": False}, \"spearman\": {\"calculate\": False}, \"kendall\": {\"calculate\": False}, \"phi_k\": {\"calculate\": True}, \"cramers\": {\"calculate\": True}, }, explorative=True, title=\"Profiling Report\" ) profile_report.to_file(\"../output/pokemon.html\") profile_report In\u00a0[\u00a0]: Copied! 
    import numpy as np\nfrom sklearn.model_selection import train_test_split\n\nfrom ydata_profiling import ProfileReport\n\n\nfile_name = cache_file(\n    \"pokemon.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\"\n)\n\npokemon_df = pd.read_csv(file_name)\n\nX = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']]\ny = pokemon_df[['Type 1', 'Type 2']]\n\nX_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.33, random_state=42)\n\ntrain_df = X_train\ntrain_report = ProfileReport(train_df, title=\"Train\")\n\ntest_df = X_test\ntest_report = ProfileReport(test_df, title=\"Test\")\n\ncomparison_report = train_report.compare(test_report)\ncomparison_report.to_file(\"../output/comparison.html\")\n\ncomparison_report\n
    import numpy as np from sklearn.model_selection import train_test_split from ydata_profiling import ProfileReport file_name = cache_file( \"pokemon.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/pokemon.csv\" ) pokemon_df = pd.read_csv(file_name) X = pokemon_df[['Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed']] y = pokemon_df[['Type 1', 'Type 2']] X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42) train_df = X_train train_report = ProfileReport(train_df, title=\"Train\") test_df = X_test test_report = ProfileReport(test_df, title=\"Test\") comparison_report = train_report.compare(test_report) comparison_report.to_file(\"../output/comparison.html\") comparison_report In\u00a0[\u00a0]: Copied! 
    import numpy as np\nimport pandas as pd\nfrom ydata_profiling import ProfileReport\nfrom ydata_profiling.utils.cache import cache_file\n\nfile_name = cache_file(\n    \"msft.csv\",\n    \"https://raw.githubusercontent.com/bryanpaget/html/main/msft.csv\"\n)\n\nmsft_df = pd.read_csv(file_name)\nmsft_df[\"Date\"] = pd.to_datetime(msft_df[\"Date\"])\n\n# Enable tsmode to True to automatically identify time-series variables\n# Provide the column name that provides the chronological order of your time-series\nprofile = ProfileReport(msft_df, tsmode=True, sortby=\"Date\", title=\"Time-Series EDA\")\n\nprofile.to_file(\"../output/msft-report-timeseries.html\")\n\nprofile\n
    import numpy as np import pandas as pd from ydata_profiling import ProfileReport from ydata_profiling.utils.cache import cache_file file_name = cache_file( \"msft.csv\", \"https://raw.githubusercontent.com/bryanpaget/html/main/msft.csv\" ) msft_df = pd.read_csv(file_name) msft_df[\"Date\"] = pd.to_datetime(msft_df[\"Date\"]) # Enable tsmode to True to automatically identify time-series variables # Provide the column name that provides the chronological order of your time-series profile = ProfileReport(msft_df, tsmode=True, sortby=\"Date\", title=\"Time-Series EDA\") profile.to_file(\"../output/msft-report-timeseries.html\") profile

    Explorez les capacit\u00e9s de YData Profiling et transformez votre flux de travail d'analyse de donn\u00e9es en une exp\u00e9rience transparente et compl\u00e8te, align\u00e9e sur la familiarit\u00e9 d'Excel, Power BI et SAS.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#profilage-ydata-rationalisation-de-lanalyse-des-donnees","title":"Profilage YData: rationalisation de l'analyse des donn\u00e9es\u00b6","text":"

    YData Profiling se pr\u00e9sente comme un outil puissant con\u00e7u pour simplifier et am\u00e9liorer l'exp\u00e9rience d'exploration des donn\u00e9es, r\u00e9pondant sp\u00e9cifiquement aux besoins des statisticiens et des data scientists. En mettant l'accent sur la fourniture d'une solution d'analyse exploratoire des donn\u00e9es (EDA) en une seule ligne, YData Profiling fournit une analyse \u00e9tendue de votre DataFrame, semblable \u00e0 la commodit\u00e9 offerte par la fonction df.describe() de pandas. Cette analyse peut \u00eatre export\u00e9e de mani\u00e8re transparente dans diff\u00e9rents formats tels que HTML et JSON.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#demarrage-rapide","title":"D\u00e9marrage rapide:\u00b6","text":"

    D\u00e9marrer avec YData Profiling est simple. Commencez par installer la biblioth\u00e8que \u00e0 l'aide de l'une des commandes suivantes:

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#principales-caracteristiques","title":"Principales caract\u00e9ristiques:\u00b6","text":"
    • Inf\u00e9rence de type: D\u00e9tecte automatiquement les types de donn\u00e9es des colonnes, notamment cat\u00e9goriques, num\u00e9riques, date, etc.
    • Avertissements: R\u00e9sume les probl\u00e8mes potentiels de qualit\u00e9 des donn\u00e9es tels que les donn\u00e9es manquantes, les inexactitudes, l'asym\u00e9trie, etc.
    • Analyse univari\u00e9e: Fournit des statistiques descriptives et des visualisations informatives telles que des histogrammes de distribution.
    • Analyse multivari\u00e9e: Comprend des corr\u00e9lations, une analyse d\u00e9taill\u00e9e des donn\u00e9es manquantes, des lignes en double et une prise en charge visuelle des interactions par paires.
    • Analyse des s\u00e9ries chronologiques: Offre des informations statistiques relatives aux donn\u00e9es d\u00e9pendantes du temps, ainsi que des informations sur l'autocorr\u00e9lation et la saisonnalit\u00e9.
    • Analyse de texte et de fichiers: Comprend la d\u00e9tection de cat\u00e9gories de texte et l'analyse de fichiers/images pour une exploration compl\u00e8te.
    • Comparaison d'ensembles de donn\u00e9es: Permet d'obtenir un rapport rapide et complet sur la comparaison d'ensembles de donn\u00e9es avec une seule ligne de code.
    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#exemple-de-code","title":"Exemple de code:\u00b6","text":"

    Pour une d\u00e9monstration pratique, consid\u00e9rons l'exemple suivant g\u00e9n\u00e9rant un rapport standard pour un ensemble de donn\u00e9es Pok\u00e9mon:

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#generation-dun-rapport-standard","title":"G\u00e9n\u00e9ration d'un rapport standard\u00b6","text":"

    Cette cellule contient un script pour r\u00e9cup\u00e9rer un ensemble de donn\u00e9es Pok\u00e9mon et afficher le \u00ab ProfileReport \u00bb par d\u00e9faut \u00e0 partir de \u00ab ydata_profiling \u00bb. Le rapport comprend des calculs de corr\u00e9lation suppl\u00e9mentaires (voir ligne 23 ci-dessous). La ligne 34 profile_report.to_file(\"pokemon.html\") enregistre le rapport dans un fichier HTML que vous pouvez ouvrir dans un nouvel onglet de navigateur.

    Cliquez ici pour voir le r\u00e9sultat.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#comparaison-densembles-de-donnees","title":"Comparaison d'ensembles de donn\u00e9es\u00b6","text":"

    Nous pouvons \u00e9galement g\u00e9n\u00e9rer des rapports comparant deux ensembles de donn\u00e9es. Cet exemple ci-dessous compare les ensembles de donn\u00e9es d'entra\u00eenement et de test Pok\u00e9mon. train_test_split de scikit-learn est utilis\u00e9 pour cr\u00e9er les ensembles de donn\u00e9es d'entra\u00eenement et de test.

    Cliquez ici pour voir le r\u00e9sultat.

    "},{"location":"1-Experiences/bloc-notes/YData-Profiling_FR.html#analyse-des-donnees-de-series-chronologiques","title":"Analyse des donn\u00e9es de s\u00e9ries chronologiques:\u00b6","text":"

    Pour les ensembles de donn\u00e9es de s\u00e9ries chronologiques, YData Profiling introduit un mode de s\u00e9rie chronologique sp\u00e9cialis\u00e9, comme l'illustre l'analyse du cours de l'action Microsoft:

    Cliquez ici pour voir le r\u00e9sultat.

    "},{"location":"2-Publication/Dash.html","title":"Aper\u00e7u","text":"

    Dash est un excellent outil utilis\u00e9 par beaucoup pour l'analyse et l'exploration de donn\u00e9es, la visualisation, la mod\u00e9lisation, le contr\u00f4le des instruments et la cr\u00e9ation de rapports.

    L'exemple suivant illustre une application Dash hautement r\u00e9active et personnalis\u00e9e avec peu de code.

    Ex\u00e9cution de votre serveur bloc-note et acc\u00e8s au port

    Lorsque vous ex\u00e9cutez un outil de votre bloc-note Jupyter qui publie un site Web sur un port, vous ne pourrez pas simplement y acc\u00e9der depuis http://localhost:5000/ car normalement sugg\u00e9r\u00e9 dans la sortie lors de l'ex\u00e9cution de l'application Web.

    Pour acc\u00e9der au serveur Web, vous devrez utiliser l'URL de base. Dans ton cahier ex\u00e9cution terminale\u00a0:

    echo https://kubeflow.covid.cloud.statcan.ca${JUPYTER_SERVER_URL:19}proxy/5000/\n
    "},{"location":"2-Publication/Dash.html#visualisation-des-donnees-avec-dash","title":"Visualisation des donn\u00e9es avec Dash","text":"

    Dash simplifie la cr\u00e9ation d'une interface graphique interactive autour de votre code d'analyse de donn\u00e9es. Ceci est un exemple de mise en page avec figure et curseur de Dash.

    "},{"location":"2-Publication/Dash.html#plotly-dash","title":"Plotly Dash","text":"

    Publier avec des logiciels fabriqu\u00e9s au Canada.

    Plotly Dash est une biblioth\u00e8que Python populaire qui vous permet de cr\u00e9er facilement des visualisations et des tableaux de bord Web interactifs. D\u00e9velopp\u00e9 par la soci\u00e9t\u00e9 montr\u00e9alaise Plotly, Dash a acquis la r\u00e9putation d'\u00eatre un outil puissant et flexible pour cr\u00e9er des graphiques de science des donn\u00e9es personnalis\u00e9s. Avec Dash, vous pouvez tout cr\u00e9er, des simples graphiques lin\u00e9aires aux tableaux de bord complexes de plusieurs pages avec des widgets et des commandes interactifs. Parce qu'il repose sur des technologies open source telles que Flask, React et Plotly.js, Dash est hautement personnalisable et peut \u00eatre facilement int\u00e9gr\u00e9 \u00e0 d'autres outils et workflows de science des donn\u00e9es. Que vous soyez data scientist, analyste ou d\u00e9veloppeur, Dash peut vous aider \u00e0 cr\u00e9er des visualisations attrayantes et informatives qui donnent vie \u00e0 vos donn\u00e9es.

    "},{"location":"2-Publication/Dash.html#commencer","title":"Commencer","text":"

    Ouvrez une fen\u00eatre de terminal dans votre bloc-note Jupyter et ex\u00e9cutez les commandes suivantes\u00a0:

    #\u00a0installations requises si elles ne sont pas d\u00e9j\u00e0 install\u00e9es\npip3 install dash==1.16.3\npip3 install pandas\n

    Cr\u00e9ez un fichier appel\u00e9 app.py avec le contenu suivant\u00a0:

    # app.py\n\n#!/usr/bin/env python3\n\nimport dash\nimport dash_core_components as dcc\nimport dash_html_components as html\nfrom dash.dependencies import Input, Output\nimport plotly.express as px\n\nimport pandas as pd\n\ndf = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminderDataFiveYear.csv')\n\nexternal_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n\napp = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n\napp.layout = html.Div([\n    dcc.Graph(id='graph-with-slider'),\n    dcc.Slider(\n        id='year-slider',\n        min=df['year'].min(),\n        max=df['year'].max(),\n        value=df['year'].min(),\n        marks={str(year): str(year) for year in df['year'].unique()},\n        step=None\n    )\n])\n\n@app.callback(\n    Output('graph-with-slider', 'figure'),\n    [Input('year-slider', 'value')])\ndef update_figure(selected_year):\n    filtered_df = df[df.year == selected_year]\n\n    fig = px.scatter(filtered_df, x=\"gdpPercap\", y=\"lifeExp\",\n                     size=\"pop\", color=\"continent\", hover_name=\"country\",\n                     log_x=True, size_max=55)\n\n    fig.update_layout(transition_duration=500)\n\n    return fig\n\nif __name__ == '__main__':\n    app.run_server(debug=True)\n
    "},{"location":"2-Publication/Dash.html#executez-votre-application","title":"Ex\u00e9cutez votre application","text":"
    python app.py\n\n# ou vous pouvez utiliser\u00a0:\n\nexport FLASK_APP=app.py\nflask run\n
    "},{"location":"2-Publication/Datasette.html","title":"Aper\u00e7u","text":"

    Datasette est une API JSON instantan\u00e9e pour vos bases de donn\u00e9es SQLite qui permet d'explorer la BD et d'ex\u00e9cuter des requ\u00eates SQL de mani\u00e8re plus interactive.

    Vous pouvez trouver une liste d'exemples de datasettes ici.

    \u00c9cosyst\u00e8me de Datasette

    Il existe toutes sortes d'outils pour convertir des donn\u00e9es depuis et vers sqlite. ici. Par exemple, vous pouvez charger des fichiers de forme dans sqlite, ou cr\u00e9er des graphes Vega \u00e0 partir d'une base de donn\u00e9es sqlite. SQLite fonctionne bien avec R, Python, et plusieurs autres outils.

    "},{"location":"2-Publication/Datasette.html#exemple-datasette","title":"Exemple Datasette","text":"

    Voici quelques captures d'\u00e9cran du Datasette global-power-plants, vous pouvez pr\u00e9visualiser et explorer les donn\u00e9es dans le navigateur, que ce soit par des clics ou des requ\u00eates SQL.

    Vous pouvez m\u00eame explorer des cartes au sein de l'outil!

    "},{"location":"2-Publication/Datasette.html#commencer","title":"Commencer","text":""},{"location":"2-Publication/Datasette.html#installation-de-datasette","title":"Installation de Datasette","text":"

    Dans votre bloc-notes Jupyter, ouvrez une fen\u00eatre de terminal et ex\u00e9cutez la commande pip3 install datasette.

    "},{"location":"2-Publication/Datasette.html#demarrage-de-datasette","title":"D\u00e9marrage de Datasette","text":"

    Pour afficher votre propre base de donn\u00e9es dans votre bloc-notes Jupyter, cr\u00e9ez un fichier appel\u00e9 start.sh dans le r\u00e9pertoire de votre projet et copiez-y le code ci-dessous. Rendez le fichier ex\u00e9cutable en utilisant chmod +x start.sh. Ex\u00e9cutez le fichier avec ./start.sh. Acc\u00e9dez au serveur Web \u00e0 l'aide de l'URL de base avec le num\u00e9ro de port que vous utilisez dans le fichier ci-dessous.

    start.sh

    #!/bin/bash\n\n# This script just starts Datasette with the correct URL, so\n# that you can use it within kubeflow.\n\n# Get an example database\nwget https://github.com/StatCan/aaw-contrib-r-notebooks/raw/master/database-connections/latin_phrases.db\n\n# If you have your own database, you can change this line!\nDATABASE=latin_phrases.db\n\nexport BASE_URL=\"https://kubeflow.covid.cloud.statcan.ca${JUPYTER_SERVER_URL:19}proxy/8001/\"\necho \"Base url: ${BASE_URL}\"\ndatasette $DATABASE --cors --config max_returned_rows:100000 --config sql_time_limit_ms:5500 --config base_url:${BASE_URL}\n

    Regardez ce tutoriel

    Un utilisateur de la plateforme a utilis\u00e9 Datasette avec un tableau de bord. Voir la vid\u00e9o pour une d\u00e9monstration.

    Ex\u00e9cuter le serveur de votre bloc-notes et acc\u00e9der au port

    Lorsque vous ex\u00e9cutez un outil depuis votre bloc-notes Jupyter qui affiche un site web sur un port, vous ne serez pas en mesure d'y acc\u00e9der simplement \u00e0 partir de http://localhost:5000/ comme normalement sugg\u00e9r\u00e9 dans la sortie lors de l'ex\u00e9cution de l'application web.

    Pour acc\u00e9der au serveur web, vous devrez utiliser l'URL de base. Dans le terminal du bloc-note, ex\u00e9cutez:

    echo https://kubeflow.covid.cloud.statcan.ca${JUPYTER_SERVER_URL:19}proxy/5000/\n
    "},{"location":"2-Publication/Overview.html","title":"Overview","text":""},{"location":"2-Publication/Overview.html#publication-statistique","title":"Publication statistique","text":"

    De beaux graphiques sont importants dans la publication statistique car ils rendent les donn\u00e9es plus accessibles et compr\u00e9hensibles pour un public plus large.

    La publication est un aspect essentiel de la science des donn\u00e9es et des statistiques. Il permet aux chercheurs de partager leurs d\u00e9couvertes avec la communaut\u00e9 scientifique au sens large, permettant ainsi \u00e0 d\u2019autres de s\u2019appuyer sur leurs travaux et de faire avancer le domaine. En partageant ouvertement leurs donn\u00e9es et leurs m\u00e9thodes, les chercheurs peuvent recevoir des commentaires sur leurs travaux et garantir que leurs r\u00e9sultats sont pr\u00e9cis et fiables.

    La publication permet aux chercheurs d\u2019\u00e9tablir leur r\u00e9putation et d\u2019obtenir la reconnaissance de leurs travaux, ce qui peut contribuer \u00e0 obtenir des financements et de futures opportunit\u00e9s de recherche. En outre, la publication des r\u00e9sultats de la recherche peut avoir des implications importantes sur les politiques publiques et la prise de d\u00e9cision, dans la mesure o\u00f9 les d\u00e9cideurs s\u2019appuient souvent sur des preuves scientifiques pour prendre des d\u00e9cisions \u00e9clair\u00e9es. Dans l\u2019ensemble, la publication fait partie int\u00e9grante du processus scientifique et joue un r\u00f4le essentiel dans l\u2019avancement des connaissances et la r\u00e9solution de probl\u00e8mes du monde r\u00e9el.

    La publication statistique consiste \u00e0 communiquer des informations statistiques \u00e0 un public plus large en utilisant diverses formes de m\u00e9dias, tels que des tableaux, des graphiques et des infographies. Avoir de beaux graphiques est important dans la publication statistique car cela rend les donn\u00e9es plus accessibles et compr\u00e9hensibles pour un public plus large. Des visualisations bien con\u00e7ues peuvent aider \u00e0 communiquer des concepts et des mod\u00e8les statistiques complexes de mani\u00e8re claire et convaincante, permettant au public de saisir rapidement les principales informations et conclusions.

    De superbes graphiques peuvent am\u00e9liorer l\u2019impact global des publications statistiques, les rendant plus attrayantes et m\u00e9morables. Cela peut \u00eatre particuli\u00e8rement important lors de la communication d'informations importantes aux d\u00e9cideurs, aux parties prenantes ou au grand public, o\u00f9 la capacit\u00e9 de communiquer clairement et efficacement des informations bas\u00e9es sur les donn\u00e9es peut \u00eatre essentielle pour r\u00e9ussir.

    En r\u00e9sum\u00e9, la science des donn\u00e9es et la publication statistique sont essentielles pour transformer des donn\u00e9es complexes en informations significatives, et disposer de superbes graphiques est un aspect crucial pour communiquer efficacement ces informations \u00e0 un public plus large.

    "},{"location":"2-Publication/PowerBI.html","title":"Aper\u00e7u","text":""},{"location":"2-Publication/PowerBI.html#chargement-des-donnees-dans-power-bi","title":"Chargement des donn\u00e9es dans Power BI","text":"

    Nous ne proposons pas de serveur Power BI, mais vous pouvez extraire vos donn\u00e9es dans Power BI \u00e0 partir de notre syst\u00e8me de stockage et les utiliser comme une trame de donn\u00e9es pandas.

    "},{"location":"2-Publication/PowerBI.html#installation","title":"Installation","text":""},{"location":"2-Publication/PowerBI.html#ce-dont-vous-aurez-besoin","title":"Ce dont vous aurez besoin","text":"
    1. Un ordinateur avec Power BI et Python 3.6
    2. Vos ACCESS_KEY et SECRET_KEY MinIO (voir Stockage)
    "},{"location":"2-Publication/PowerBI.html#configurez-power-bi","title":"Configurez Power BI","text":"

    Ouvrez votre syst\u00e8me Power BI et ouvrez d\u00e9marrage rapide de Power BI dans votre \u00e9diteur de texte pr\u00e9f\u00e9r\u00e9.

    Assurez-vous que pandas, boto3 et numpy sont install\u00e9s et que vous utilisez le bon environnement virtuel Conda (le cas \u00e9ch\u00e9ant).

    Ensuite, assurez-vous que Power BI utilise le bon environnement Python. Vous pouvez modifier cet \u00e9l\u00e9ment \u00e0 partir du menu des options. Le chemin d'acc\u00e8s exact est indiqu\u00e9 dans le guide de d\u00e9marrage rapide.

    "},{"location":"2-Publication/PowerBI.html#modifiez-votre-script-python","title":"Modifiez votre script Python","text":"

    Ensuite, modifiez votre script Python pour utiliser vos ACCESS_KEY et SECRET_KEY MinIO, puis cliquez sur \u00ab Obtenir des donn\u00e9es \u00bb et copiez-le en tant que script Python.

    "},{"location":"2-Publication/R-Shiny.html","title":"Aper\u00e7u","text":"

    R-Shiny est un package R qui facilite la cr\u00e9ation d'applications Web interactives dans R.

    H\u00e9bergement d'applications R Shiny

    Nous ne prenons actuellement pas en charge l'h\u00e9bergement d'applications R Shiny, mais vous pouvez les cr\u00e9er. Nous souhaitons activer l'h\u00e9bergement de l'application R Shiny \u00e0 l'avenir.

    "},{"location":"2-Publication/R-Shiny.html#r-shiny","title":"R Shiny","text":"

    Publier des graphismes de qualit\u00e9 professionnelle

    R Shiny est un framework d'application Web open source qui permet aux scientifiques de donn\u00e9es et aux analystes de cr\u00e9er des tableaux de bord et des visualisations de donn\u00e9es interactifs bas\u00e9s sur le Web \u00e0 l'aide du langage de programmation R. L'un des principaux avantages de R Shiny est qu'il offre un moyen simple de cr\u00e9er des tableaux de bord interactifs de haute qualit\u00e9 sans avoir besoin d'une expertise approfondie en d\u00e9veloppement Web. Avec R Shiny, les scientifiques de donn\u00e9es peuvent tirer parti de leurs comp\u00e9tences en codage R pour cr\u00e9er des applications Web dynamiques, bas\u00e9es sur les donn\u00e9es, qui peuvent \u00eatre facilement partag\u00e9es avec les acteurs.

    Un autre avantage de R Shiny est qu'il prend en charge une vari\u00e9t\u00e9 de visualisations de donn\u00e9es qui peuvent \u00eatre facilement personnalis\u00e9es pour r\u00e9pondre aux besoins du projet. Les utilisateurs peuvent cr\u00e9er une large gamme de diagrammes et de graphiques, allant de simples diagrammes \u00e0 barres et nuages de points \u00e0 des cartes thermiques et des graphiques de r\u00e9seau plus complexes. De plus, R Shiny prend en charge une vari\u00e9t\u00e9 de widgets interactifs qui permettent aux utilisateurs de manipuler et d'explorer des donn\u00e9es en temps r\u00e9el.

    R Shiny est \u00e9galement hautement extensible et peut \u00eatre int\u00e9gr\u00e9 \u00e0 d'autres outils et plates-formes open source pour cr\u00e9er des workflows de science des donn\u00e9es de bout en bout. Avec ses fonctionnalit\u00e9s puissantes et flexibles, R Shiny est un choix populaire pour cr\u00e9er des tableaux de bord de visualisation de donn\u00e9es pour un large \u00e9ventail d'applications, de la recherche scientifique \u00e0 l'analyse commerciale. Dans l'ensemble, R Shiny offre une solution puissante, personnalisable et rentable pour cr\u00e9er des tableaux de bord interactifs et des visualisations de donn\u00e9es.

    Utilisez R-Shiny pour cr\u00e9er des applications Web interactives directement \u00e0 partir de R. Vous pouvez d\u00e9ployer votre tableau de bord R Shiny en soumettant une demande d'extraction \u00e0 notre R\u00e9f\u00e9rentiel R-Dashboards GitHub .

    "},{"location":"2-Publication/R-Shiny.html#editeur-dinterface-utilisateur-r-shiny","title":"\u00c9diteur d'interface utilisateur R Shiny","text":"

    Le script Rscript suivant installe les packages requis pour ex\u00e9cuter \"shinyuieditor\" sur l'ETAA. Il commence par installer les packages R n\u00e9cessaires et utilise conda pour installer yarn.

    Une fois l'installation termin\u00e9e, vous pouvez acc\u00e9der au code de votre application dans ./my-app

    Ex\u00e9cutez ce script depuis rstudio. RStudio peut demander la permission d'ouvrir une nouvelle fen\u00eatre si vous avez un bloqueur de popup.

    setup-shinyuieditor.R
    #!/usr/bin/env Rscript\n\n#' Installer les packages n\u00e9cessaires\ninstall.packages(c(\n  \"shiny\",\n  \"plotly\",\n  \"gridlayout\",\n  \"bslib\",\n  \"remotes\",\n  \"rstudioapi\"\n))\n\n#' n'a pas \u00e9t\u00e9 install\u00e9 lors de l'installation ci-dessus\ninstall.packages(\"DT\")\n\n#' Cela installe shinyuieditor de Github\nremotes::install_github(\"rstudio/shinyuieditor\", upgrade = F)\n\n#' Nous avons besoin de fil donc nous allons l'installer avec conda\nsystem(\"conda install yarn\", wait = T)\n\n#' Ceci clone Shinyuieditor et un exemple d'application de Github\nsystem(\"git clone https://github.com/rstudio/shinyuieditor\", wait = T)\n\n#' Copiez l'application des vignettes vers notre r\u00e9pertoire de travail actuel\nsystem(\"cp -R ./shinyuieditor/vignettes/demo-app/ ./my-app\")\n\n#' D\u00e9finit le r\u00e9pertoire de travail actuel sur le r\u00e9pertoire racine de l'application\nsetwd(\"./my-app\")\n\n#' Yarn va mettre en place notre projet\nsystem(\"yarn install\", wait = T)\n\n#' Chargez et lancez shinyuieditor\nlibrary(shinyuieditor)\nshinyuieditor::launch_editor(app_loc = \"./\")\n
    "},{"location":"2-Publication/R-Shiny.html#choisissez-un-modele-dapplication","title":"Choisissez un mod\u00e8le d'application","text":"

    La premi\u00e8re chose que vous verrez est le s\u00e9lecteur de mod\u00e8le. Il existe trois options au moment d'\u00e9crire ces lignes (shinyuieditor est actuellement en alpha).

    "},{"location":"2-Publication/R-Shiny.html#mode-fichier-unique-ou-multi","title":"Mode fichier unique ou multi","text":"

    Je recommande le mode multi-fichiers, cela mettra le code back-end dans un fichier appel\u00e9 server.R et le front-end dans un fichier appel\u00e9 ui.R.

    "},{"location":"2-Publication/R-Shiny.html#concevez-votre-application","title":"Concevez votre application","text":"

    Vous pouvez concevoir votre application avec du code ou l'interface utilisateur graphique. Essayez de concevoir la mise en page avec l'interface graphique et de concevoir les trac\u00e9s avec du code.

    Toutes les modifications que vous apportez dans shinyuieditor appara\u00eetront imm\u00e9diatement dans le code.

    Toute modification que vous apportez au code appara\u00eetra imm\u00e9diatement dans le shinyuieditor.

    "},{"location":"2-Publication/R-Shiny.html#publication-sur-letaa","title":"Publication sur l'ETAA","text":""},{"location":"2-Publication/R-Shiny.html#envoyez-simplement-une-pull-request","title":"Envoyez simplement une pull request\u00a0!","text":"

    Tout ce que vous avez \u00e0 faire est d'envoyer une demande d'extraction \u00e0 notre r\u00e9f\u00e9rentiel R-Dashboards. Incluez votre r\u00e9f\u00e9rentiel dans un dossier avec le nom que vous voulez (par exemple, \"air-quality-dashboard\"). Ensuite, nous l'approuverons et il sera mis en ligne.

    Si vous avez besoin d'installer des biblioth\u00e8ques R suppl\u00e9mentaires, envoyez votre liste au d\u00e9p\u00f4t R-Shiny en cr\u00e9ant un probl\u00e8me GitHub et nous ajouterons les d\u00e9pendances.

    Voir le tableau de bord ci-dessus ici

    Le tableau de bord ci-dessus est dans GitHub. Jetez un \u0153il \u00e0 la source.

    "},{"location":"2-Publication/R-Shiny.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":""},{"location":"2-Publication/R-Shiny.html#integrer-des-tableaux-de-bord-dans-vos-sites-web","title":"Int\u00e9grer des tableaux de bord dans vos sites Web","text":"

    Int\u00e9grer des tableaux de bord dans d'autres sites

    Nous n'avons pas encore eu l'occasion de l'examiner ou de le prototyper, mais si vous avez un cas d'utilisation, n'h\u00e9sitez pas \u00e0 contacter l'ing\u00e9nierie. Nous travaillerons avec vous pour trouver quelque chose.

    "},{"location":"2-Publication/Sur-mesure.html","title":"Aper\u00e7u","text":""},{"location":"2-Publication/Sur-mesure.html#applications-web-personnalisees","title":"Applications Web personnalis\u00e9es","text":"

    Nous pouvons tout d\u00e9ployer, dans la mesure o\u00f9 il s'agit de logiciel libre, et nous pouvons le mettre dans un conteneur Docker (p. ex. applications Node.js, Flask, Dash).

    Voir le code de source de cette application

    Nous int\u00e9grons ces types d'applications au serveur au moyen de GitHub.

    "},{"location":"2-Publication/Sur-mesure.html#installation","title":"Installation","text":""},{"location":"2-Publication/Sur-mesure.html#comment-faire-heberger-votre-application","title":"Comment faire h\u00e9berger votre application","text":"

    Si vous avez d\u00e9j\u00e0 une application Web dans un r\u00e9pertoire Git, d\u00e8s qu'elle est plac\u00e9e dans un conteneur Docker, nous pouvons int\u00e9grer le r\u00e9pertoire Git dans le r\u00e9pertoire GitHub de StatCan et pointer une URL vers elle. Pour la mettre \u00e0 jour, il vous suffit d'interagir avec le r\u00e9pertoire GitHub de StatCan au moyen de demandes d'extraction.

    Si vous avez des questions, n'h\u00e9sitez pas \u00e0 communiquer avec nous.

    "},{"location":"3-Pipelines/Argo.html","title":"Argo","text":""},{"location":"3-Pipelines/Argo.html#flux-de-travail-argo","title":"Flux de travail Argo","text":"

    Flux de travail Argo est un moteur de flux de travail \u00e0 logiciel libre natif de conteneur pour orchestrer des t\u00e2ches parall\u00e8les sur Kubernetes. Les flux de travails Argo sont impl\u00e9ment\u00e9s en tant que Kubernetes CRD (Custom Resource Definition). Il est particuli\u00e8rement adapt\u00e9 aux flux de travail de science des donn\u00e9es et aux flux de travail d\u2019apprentissage automatique.

    La documentation compl\u00e8te peut \u00eatre trouv\u00e9e ici.

    Les flux de travails Argo ont les avantages suivants:

    • Les t\u00e2ches des flux de travail peuvent \u00eatre d\u00e9finies sous forme de scripts (ex. Python) ou \u00eatre conteneuris\u00e9es (ex. Docker).
    • Des flux de travail complexes peuvent \u00eatre mod\u00e9lis\u00e9s \u00e0 l'aide de graphes acycliques dirig\u00e9s (DAG) pour capturer les cha\u00eenes de d\u00e9pendance.
    • Les t\u00e2ches ind\u00e9pendantes peuvent \u00eatre ex\u00e9cut\u00e9es en parall\u00e8le avec une granularit\u00e9 jusqu'au niveau de mise en \u0153uvre, r\u00e9duisant ainsi les charges de t\u00e2ches chronophages.
    • Agnositique de la plateforme Kubernetes, ce qui signifie que votre travail est tr\u00e8s portable.

    Avec les flux de travails Argo, vous pouvez facilement cr\u00e9er des flux de travails qui int\u00e8grent des t\u00e2ches telles que des constructions et des d\u00e9ploiements automatis\u00e9s, le pr\u00e9traitement des donn\u00e9es, la formation de mod\u00e8les et le d\u00e9ploiement de mod\u00e8les, le tout dans un environnement Cloud Native Kubernetes.

    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\u00e8le d'apprentissage automatique \u00e0 l'aide des flux de travail Argo sur AAW.

    "},{"location":"3-Pipelines/Argo.html#1-ecrivez-un-script-pour-entrainer-votre-modele","title":"1. \u00c9crivez un script pour entra\u00eener votre mod\u00e8le","text":"

    Voici un exemple de script qui entra\u00eene un mod\u00e8le de r\u00e9gression logistique sur l'ensemble de donn\u00e9es iris. N'oubliez pas de consulter le code de chaque langue ci-dessous.

    PythonR train.py
    #!/usr/bin/env python\n\n# Importer les biblioth\u00e8ques n\u00e9cessaires\nimport argparse\nimport pandas as pd\nfrom sklearn.datasets import load_iris\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import accuracy_score\nimport joblib\n\n# Analyser les arguments d'entr\u00e9e\nparser = argparse.ArgumentParser(description=\"Train logistic regression model on iris dataset.\")\nparser.add_argument(\"--input\", default=\"iris.csv\", help=\"Path to input dataset file.\")\nparser.add_argument(\"--output\", default=\"model.pkl\", help=\"Path to output model file.\")\nargs = parser.parse_args()\n\n# Charger l'ensemble de donn\u00e9es d'iris\ndata = load_iris()\nX, y = data.data, data.target\n\n# Divisez les donn\u00e9es en ensembles d'entra\u00eenement et de test\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n\n# Entra\u00eener un mod\u00e8le de r\u00e9gression logistique\nclf = LogisticRegression(random_state=42)\nclf.fit(X_train, y_train)\n\n# \u00c9valuer le mod\u00e8le sur l'ensemble de test\ny_pred = clf.predict(X_test)\naccuracy = accuracy_score(y_test, y_pred)\nprint(\"Accuracy:\", accuracy)\n\n# Enregistrer le mod\u00e8le dans un fichier\njoblib.dump(clf, args.output)\n
    train.R
    #!/usr/bin/env Rscript\n\n# Importer les biblioth\u00e8ques n\u00e9cessaires\nlibrary(caret)\n\n# Copier les arguments d'entr\u00e9e\nargs <- commandArgs(trailingOnly = TRUE)\ninput_file <- ifelse(length(args) > 0, args[1], \"iris.csv\")\noutput_file <- ifelse(length(args) > 1, args[2], \"model.rds\")\n\n# Charger l'ensemble de donn\u00e9es d'iris\ndata(iris)\nX <- iris[, 1:4]\ny <- iris[, 5]\n\n# Divisez les donn\u00e9es en ensembles d'entra\u00eenement et de test\nset.seed(42)\ntrain_index <- createDataPartition(y, p = 0.8, list = FALSE)\nX_train <- X[train_index, ]\ny_train <- y[train_index]\nX_test <- X[-train_index, ]\ny_test <- y[-train_index]\n\n# Entra\u00eener un mod\u00e8le de r\u00e9gression logistique\nclf <- train(x = X_train, y = y_train, method = \"glm\")\n\n# \u00c9valuer le mod\u00e8le sur l'ensemble de test\ny_pred <- predict(clf, newdata = X_test)\naccuracy <- confusionMatrix(y_pred, y_test)$overall[\"Accuracy\"]\nprint(paste0(\"Accuracy: \", accuracy))\n\n# Enregistrer le mod\u00e8le dans un fichier\nsaveRDS(clf, output_file)\n
    "},{"location":"3-Pipelines/Argo.html#2-ecrivez-un-dockerfile-pour-executer-votre-code","title":"2. \u00c9crivez un Dockerfile pour ex\u00e9cuter votre code","text":"

    Vous aurez besoin d'un Dockerfile qui inclut toutes les d\u00e9pendances n\u00e9cessaires pour entra\u00eener votre mod\u00e8le 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\u00e8ques ou scripts personnalis\u00e9s
    • le code de votre mod\u00e8le d'apprentissage automatique sous la forme d'un script comme dans l'exemple ci-dessus.

    Utilisez le Dockerfile suivant comme point de d\u00e9part pour vos projets R et Python.

    PythonR Dockerfile
    FROM python:3.8-slim-buster\n\n# Installez toutes les d\u00e9pendances n\u00e9cessaires\nRUN pip install --no-cache-dir scikit-learn pandas numpy\n\n# D\u00e9finir le r\u00e9pertoire de travail\nWORKDIR /app\n\n# Copier le code dans le conteneur\nCOPY train.py .\n\n# D\u00e9finir le point d'entr\u00e9e\nENTRYPOINT [\"python\", \"train.py\"]\n
    Dockerfile
    FROM rocker/r-base:latest\n\nRUN apt-get update && apt-get install -y --no-install-recommends \\\n    libssl-dev \\\n    libcurl4-openssl-dev \\\n    libxml2-dev \\\n    && apt-get clean \\\n    && rm -rf /var/lib/apt/lists/*\n\nRUN R -e 'install.packages(c(\"caret\", \"janitor\", \"tidyverse\"))'\n\nCOPY train.R /app/train.R\n\nWORKDIR /app\n\nENTRYPOINT [\"Rscript\", \"train.R\"]\n
    "},{"location":"3-Pipelines/Argo.html#3-ecrivez-votre-flux-de-travail-en-yaml","title":"3. \u00c9crivez votre flux de travail en YAML","text":"

    YAML est encore un autre langage de balisage et vous devrez \u00e9crire les \u00e9tapes de votre pipeline de formation dans un fichier YAML de flux de travails Argo. Ce fichier doit inclure une r\u00e9f\u00e9rence au Dockerfile que vous avez cr\u00e9\u00e9 \u00e0 l'\u00c9tape 1, ainsi que toutes les donn\u00e9es d'entr\u00e9e et de sortie avec lesquelles vous travaillerez.

    Voici un exemple de fichier YAML pour un pipeline d'apprentissage automatique simple qui entra\u00eene un mod\u00e8le de r\u00e9gression logistique sur l'ensemble de donn\u00e9es iris. La seule vraie diff\u00e9rence entre les versions Python et R est la commande command: [\"python\", \"train.py\"] vs command: [\"Rscript\", \"train.R\"] et le les mod\u00e8les sont stock\u00e9s dans diff\u00e9rents formats, pkl pour python et rds pour R.

    Le fichier YAML d\u00e9finit une seule \u00e9tape appel\u00e9e train qui ex\u00e9cute un script appel\u00e9 train.py ou train.R dans l'image Docker machine-learning:v1. Le script prend un fichier d'ensemble de donn\u00e9es d'entr\u00e9e, sp\u00e9cifi\u00e9 par un param\u00e8tre appel\u00e9 dataset, et g\u00e9n\u00e8re un fichier de mod\u00e8le entra\u00een\u00e9 vers un artefact de sortie appel\u00e9 model.pkl ou model.rds selon le langage utilis\u00e9.

    PythonR workflow.yaml
    apiVersion: argoproj.io/v1alpha1\nkind: Workflow\nmetadata:\ngenerateName: ml-pipeline-\nspec:\nentrypoint: train\ntemplates:\n- name: train\n    container:\n    image: machine-learning:v1\n    command: [\"python\", \"train.py\"]\n    args: [\"--input\", \"{{inputs.parameters.dataset}}\", \"--output\", \"{{outputs.artifacts.model}}\"]\n    inputs:\n    parameters:\n    - name: dataset\n        default: \"iris.csv\"\n    outputs:\n    artifacts:\n    - name: model\n        path: /output/model.pkl\n
    workflow.yaml
    apiVersion: argoproj.io/v1alpha1\nkind: Workflow\nmetadata:\ngenerateName: ml-pipeline-\nspec:\nentrypoint: train\ntemplates:\n- name: train\n    container:\n    image: machine-learning:v1\n    command: [\"Rscript\", \"train.R\"]\n    args: [\"--input\", \"{{inputs.parameters.dataset}}\", \"--output\", \"{{outputs.artifacts.model}}\"]\n    inputs:\n    parameters:\n    - name: dataset\n        default: \"iris.csv\"\n    outputs:\n    artifacts:\n    - name: model\n        path: /output/model.rds\n
    "},{"location":"3-Pipelines/Argo.html#4-soumettez-le-flux-de-travail-a-laide-de-lentree-de-ligne-de-commandecli-du-flux-de-travail-argo","title":"4. Soumettez le flux de travail \u00e0 l'aide de l'entr\u00e9e de ligne de commande(CLI) du flux de travail Argo","text":"

    Pour ex\u00e9cuter le flux de travail ci-dessus, vous devrez d'abord envoyer le Dockerfile vers notre registre de conteneurs, puis soumettre le fichier YAML \u00e0 l'aide de la commande argo submit. Une fois le pipeline termin\u00e9, vous pouvez r\u00e9cup\u00e9rer le fichier de mod\u00e8le entra\u00een\u00e9 en t\u00e9l\u00e9chargeant l'artefact de sortie \u00e0 partir de la commande argo logs.

    Terminal
    $ argo submit workflow.yaml # soumettre une sp\u00e9cification de flux de travail \u00e0 Kubernetes\n

    Il est \u00e9galement possible de soumettre des flux de travail argo \u00e0 partir des flux de travail \u00e0 l'aide de SDK et d'appels API (c'est juste un autre service Web\u00a0!). Voir cette section.

    "},{"location":"3-Pipelines/Argo.html#5-surveillez-le-pipeline-a-laide-de-la-cli-du-flux-de-travail-argo","title":"5. Surveillez le pipeline \u00e0 l'aide de la CLI du flux de travail Argo","text":"

    Pendant l'ex\u00e9cution du pipeline, vous pouvez surveiller sa progression \u00e0 l'aide de la CLI de flux de travail Argo. Cela vous montrera quelles \u00e9tapes se sont termin\u00e9es avec succ\u00e8s et lesquelles sont toujours en cours. Vous trouverez ci-dessous quelques commandes utiles. Pour plus d'informations sur la CLI des flux de travail Argo, veuillez consulter la documentation officielle de la CLI de flux de travail Argo .

    Terminal
    $ argo list                       # lister les flux de travail actuels\n$ argo get workflow-xxx           # obtenir des informations sur un flux de travail sp\u00e9cifique\n$ argo logs workflow-xxx          # imprimer les journaux d'un flux de travail\n$ argo delete workflow-xxx        # suprimer un flux de travail\n
    "},{"location":"3-Pipelines/Argo.html#6-recuperer-le-modele-entraine","title":"6. R\u00e9cup\u00e9rer le mod\u00e8le entra\u00een\u00e9","text":"

    Une fois le pipeline termin\u00e9, vous pouvez r\u00e9cup\u00e9rer les donn\u00e9es de sortie \u00e0 l'aide de la commande argo logs ou en affichant les artefacts de sortie \u00e0 l'aide de la CLI, c'est-\u00e0-dire acc\u00e9der au r\u00e9pertoire que vous avez sp\u00e9cifi\u00e9 dans votre script et localiser le fichier model.pkl ou model.rds. L'extrait de code suivant, extrait du script de formation ci-dessus, indique au langage de programmation respectif o\u00f9 enregistrer le mod\u00e8le entra\u00een\u00e9.

    PythonR Saving Output Data
    #!/usr/bin/env python\n\nparser.add_argument(\"--output\", default=\"model.pkl\", help=\"Path to output model file.\")\n\n# Enregistrer le mod\u00e8le dans un fichier\njoblib.dump(clf, args.output)\n
    Saving Output Data
    #!/usr/bin/env Rscript\n\noutput_file <- ifelse(length(args) > 1, args[2], \"model.rds\")\n\n# Enregistrer le mod\u00e8le dans un fichier\nsaveRDS(clf, output_file)\n
    "},{"location":"3-Pipelines/Argo.html#exemples-utilisant-des-sdk-bases-sur-flux-de-travail-argo","title":"Exemples utilisant des SDK bas\u00e9s sur flux de travail Argo","text":"

    Argo prend en charge les biblioth\u00e8ques client, g\u00e9n\u00e9r\u00e9es automatiquement et g\u00e9r\u00e9es par la communaut\u00e9, qui incluent les SDK Java et Python.

    Si vous pr\u00e9f\u00e9rez utiliser un cadres de niveau sup\u00e9rieur, alors Couler et Hera sont des alternatives bien adapt\u00e9es. Ces cadress rendent la cr\u00e9ation et la gestion de flux de travail complexes plus accessibles \u00e0 un public plus large.

    "},{"location":"3-Pipelines/Argo.html#hera","title":"Hera","text":"

    Hera vise \u00e0 simplifier le processus de cr\u00e9ation et de soumission de flux de travail en \u00e9liminant de nombreux d\u00e9tails techniques via une interface de programmation d'application simple. Il utilise \u00e9galement un ensemble coh\u00e9rent 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.

    "},{"location":"3-Pipelines/Argo.html#couler","title":"Couler","text":"

    Couler fournit une interface de programmation d'applications simple et unifi\u00e9e pour d\u00e9finir des flux de travail \u00e0 l'aide d'un style de programmation imp\u00e9ratif. Il construit \u00e9galement automatiquement des graphiques acycliques dirig\u00e9s (DAG) pour les flux de travail, ce qui peut contribuer \u00e0 simplifier le processus de cr\u00e9ation et de gestion de ceux-ci.

    CoulerHera couler.py
    #!/usr/bin/env python\n\n# Pr\u00e9parez votre syst\u00e8me\n!pip config --user set global.index-url https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple\n!python3 -m pip install git+https://github.com/couler-proj/couler --ignore-installed\n\n# D\u00e9finir une variable globale pour plus de commodit\u00e9\nNAMESPACE = \"<your-namespace>\"\n\n# Importer les packages n\u00e9cessaires\nimport json\nimport random\n\nimport couler.argo as couler\nfrom couler.argo_submitter import ArgoSubmitter\n\n\n# D\u00e9finir les \u00e9tapes (fonctions) utilis\u00e9es dans le flux de travail\ndef random_code():\n    import random\n    res = \"heads\" if random.randint(0, 1) == 0 else \"tails\"\n    print(res)\n\n\ndef flip_coin():\n    return couler.run_script(\n        image=\"k8scc01covidacr.azurecr.io/ubuntu\",\n        source=random_code\n    )\n\n\ndef heads():\n    return couler.run_container(\n        image=\"k8scc01covidacr.azurecr.io/ubuntu\",\n        command=[\"sh\", \"-c\", 'echo \"it was heads\"']\n    )\n\n\ndef tails():\n    return couler.run_container(\n        image=\"k8scc01covidacr.azurecr.io/ubuntu\",\n        command=[\"sh\", \"-c\", 'echo \"it was tails\"']\n    )\n\n\nresult = flip_coin()\n\ncouler.when(couler.equal(result, \"heads\"), lambda: heads())\ncouler.when(couler.equal(result, \"tails\"), lambda: tails())\n\nsubmitter = ArgoSubmitter(namespace=\"NAMESPACE\")\nresult = couler.run(submitter=submitter)\n\nprint(json.dumps(result, indent=2))\n
    hera.py
    #!/usr/bin/env python\n\n# Pr\u00e9parez votre syst\u00e8me\n!pip config --user set global.index-url https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple\n!pip install hera-workflows\n\n# Importer les packages n\u00e9cessaires\nimport hera\nfrom hera import Task, Workflow\n\n# Configurer Hera\nhera.global_config.GlobalConfig.token = \"<your-token>\"\nhera.global_config.GlobalConfig.host = \"https://argo-workflows.aaw-dev.cloud.statcan.ca:443\"\nhera.global_config.GlobalConfig.namespace = \"<your-namespace>\"\nhera.global_config.GlobalConfig.service_account_name = \"<your-account-name>\"\n\n\n# D\u00e9finir les \u00e9tapes (fonctions) utilis\u00e9es dans le workflow\ndef random_code():\n    res = \"heads\" if random.randint(0, 1) == 0 else \"tails\"\n    print(res)\n\n\ndef heads():\n    print(\"it was heads\")\n\n\ndef tails():\n    print(\"it was tails\")\n\n# D\u00e9finir le flux de travail\nwith Workflow(\"coin-flip\") as w:\n    r = Task(\"r\", random_code)\n    h = Task(\"h\", heads)\n    t = Task(\"t\", tails)\n\n    h.on_other_result(r, \"heads\")\n    t.on_other_result(r, \"tails\")\n\n# Ex\u00e9cuter le flux de travail\nw.create()\n
    "},{"location":"3-Pipelines/Argo.html#ressources-supplementaires-pour-les-flux-de-travail-argo","title":"Ressources suppl\u00e9mentaires pour les flux de travail Argo","text":"

    Des exemples de flux de travail Argo peuvent \u00eatre trouv\u00e9s dans les r\u00e9f\u00e9rentiels Github suivants\u00a0:

    • Documentation des flux de travail Argo
    • R\u00e9f\u00e9rence Argo CLI
    "},{"location":"4-Collaboration/Aper%C3%A7u.html","title":"Aper\u00e7u","text":"

    La collaboration est essentielle en science des donn\u00e9es car elle permet \u00e0 des individus ayant des perspectives et des parcours diff\u00e9rents de travailler ensemble pour r\u00e9soudre des probl\u00e8mes complexes et g\u00e9n\u00e9rer de nouvelles informations. En science des donn\u00e9es, la collaboration peut impliquer de travailler avec des personnes issues de divers domaines tels que les math\u00e9matiques, l\u2019informatique et les affaires, ainsi qu\u2019avec des experts en la mati\u00e8re poss\u00e9dant une connaissance approfondie d\u2019une industrie ou d\u2019un domaine particulier.

    Il existe de nombreuses fa\u00e7ons de collaborer sur la plateforme. Selon votre situation,ce qu vous voulez partager et le nombre de personnes que vous souhaitez partager avec. Les sc\u00e9narios se d\u00e9composent en gros en ce que vous voulez partager (Donn\u00e9es, Code, ou Environnements de calcul (e.g.: Partager les m\u00eames machines virtuelles)) et avec qui vous voulez le partager (Personne, Mon \u00e9quipe, ou Tout le monde). Cela conduit au tableau d'options suivant:

    Priv\u00e9e \u00c9quipe StatCan Code GitLab/GitHub ou un dossier personnel GitLab/GitHub or dossier d'\u00e9quipe GitLab/GitHub Donn\u00e9es Dossier personnel ou compartiment Dossier d'\u00e9quipe ou compartiment , ou espace de noms partag\u00e9 Compartiment partag\u00e9 Calcul Espace de nom personnel Espace de noms partag\u00e9 N/A

    Le partage de code, de disques et d'espaces de travail (par exemple\u00a0: deux personnes partageant la m\u00eame machine virtuelle) est d\u00e9crit plus en d\u00e9tail ci-dessous. Le partage de donn\u00e9es via des compartiments est d\u00e9crit plus en d\u00e9tail dans la section Stockage Blob Azure.

    Quelle est la diff\u00e9rence entre un compartiment et un dossier?

    Les compartiments sont comme le stockage sur r\u00e9seau. Consulter pr\u00e9sentation du stockage pour plus de d\u00e9tails sur les diff\u00e9rences entre ces deux options.

    Choisir la meilleure fa\u00e7on de partager le code, les donn\u00e9es et le calcul implique un ensemble de diff\u00e9rent facteurs, mais vous pouvez g\u00e9n\u00e9ralement m\u00e9langer et assortir (partager le code avec votre \u00e9quipe via github, mais stockez vos donn\u00e9es en priv\u00e9 dans un compartiment personnel). Ces cas sont d\u00e9crits plus en d\u00e9tail dans les sections ci-dessous

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-le-code-entre-les-membres-de-lequipe","title":"Partager le code entre les membres de l'\u00e9quipe","text":"

    Dans la plupart des cas, il est plus facile de partager du code en utilisant GitHub ou GitLab. L'avantage du partage avec GitHub ou GitLab est que cela fonctionne avec les utilisateurs \u00e0 travers les espaces de noms, et conserver le code dans git est un excellent moyen de g\u00e9rer de grands projets logiciels.

    N'oubliez pas d'inclure une licence !

    Si votre code est public, n'oubliez pas de respecter les directives de l'\u00e9quipe d'innovation et d'utiliser une licence appropri\u00e9e si votre travail est effectu\u00e9 pour Statistique Canada.

    Si vous devez partager du code sans le publier sur un r\u00e9f\u00e9rentiel, partager un espace de nom) pourrait aussi fonctionner.

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-le-calcul-espace-de-nom-dans-kubeflow","title":"Partager le calcul (espace de nom) dans Kubeflow","text":"

    Partager un espace de nom signifie que vous partagez toutes les choses dans l'espace de nom

    Kubeflow ne prend pas en charge le partage granulaire d'une ressource (un bloc-notes, un volume, etc.), mais plut\u00f4t le partage de toutes ressources. Si vous souhaitez partager un serveur bloc-notes Jupyter avec quelqu'un, vous devez partager l'int\u00e9gralit\u00e9 de votre espace de nom et ils auront acc\u00e8s \u00e0 toutes les autres ressources (Storage Blob Azure, etc.).

    Dans Kubeflow, chaque utilisateur dispose d'un espace de noms qui contient son travail (ses serveurs bloc-notes, pipelines, disques, etc.). Votre espace de noms vous appartient, mais peut \u00eatre partag\u00e9 si vous souhaitez collaborer avec d'autres. Vous pouvez \u00e9galement demander un nouvel espace de noms (soit pour vous-m\u00eame, soit pour le partager avec une \u00e9quipe). Une option de collaboration consiste \u00e0 partager des espaces de noms avec d\u2019autres.

    L'avantage du partage d'un espace de noms Kubeflow est qu'il vous permet, \u00e0 vous et \u00e0 vos coll\u00e8gues, de partager l'environnement de calcul et les volumes associ\u00e9s \u00e0 l'espace de noms. Cela en fait un moyen de partage tr\u00e8s simple et libre.

    Pour partager votre espace de noms, consultez gestion des contributeurs

    Demander de l'aide en production

    Le personnel d'assistance d'Espace de travail d'analyse avanc\u00e9e se fera un plaisir de vous aider avec les cas d'utilisation orient\u00e9s vers la production, et nous pouvons probablement vous faire gagner beaucoup de temps. Ne soyez pas timide Demander pour l'aide!

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-des-donnees","title":"Partager des donn\u00e9es","text":"

    Une fois que vous avez un espace de nom partag\u00e9, vous avez deux approches de stockage partag\u00e9

    Possibilit\u00e9 de stockage Avantages Serveurs/espaces de travail Jupyter partag\u00e9s Plus adapt\u00e9 aux petits fichiers, aux cahiers et aux petites exp\u00e9riences. Compartiments partag\u00e9s( consultez Stockage) Mieux adapt\u00e9 pour une utilisation dans les pipelines, les API et pour les fichiers volumineux.

    Pour en savoir plus sur la technologie qui les sous-tend, consultez le Stockage.

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#partager-avec-le-monde","title":"Partager avec le monde","text":"

    Renseignez-vous \u00e0 ce sujet sur notre cha\u00eene Slack. Il existe de nombreuses fa\u00e7ons de proc\u00e9der du c\u00f4t\u00e9 informatique, mais il est important que cela passe par des processus appropri\u00e9s, afin que cela ne se fasse pas de mani\u00e8re \u00ab libre-service \u00bb comme le sont les autres. Cela dit, c'est tout \u00e0 fait possible.

    "},{"location":"4-Collaboration/Aper%C3%A7u.html#gestion-des-contributeurs","title":"Gestion des contributeurs","text":"

    Vous pouvez ajouter ou supprimer des personnes d'un espace de noms que vous poss\u00e9dez d\u00e9j\u00e0 via le menu G\u00e9rer les contributeurs dans Kubeflow.

    Maintenant, vous et vos coll\u00e8gues pouvez partager l'acc\u00e8s \u00e0 un serveur!

    Essayer le!

    "},{"location":"4-Collaboration/Demander-EspaceDeNom.html","title":"Aper\u00e7u","text":"

    Par d\u00e9faut, chaque personne a son espace de nom personnel, pr\u00e9nom-nom. Si vous souhaitez collaborer avec votre \u00e9quipe, vous pouvez demander un Espace de nom \u00e0 partager.

    "},{"location":"4-Collaboration/Demander-EspaceDeNom.html#installation","title":"Installation","text":""},{"location":"4-Collaboration/Demander-EspaceDeNom.html#demander-un-espace-de-nom","title":"Demander un espace de nom","text":"

    Pour cr\u00e9er un espace de noms pour une \u00e9quipe, acc\u00e9dez au portail ETAA. Cliquez Commencer.

    L'espace de noms ne peut pas avoir de caract\u00e8res sp\u00e9ciaux autres que des traits d'union

    Le nom de l'espace de noms ne doit \u00eatre compos\u00e9 que de lettres minuscules \u00ab a-z \u00bb avec des tirets. Sinon,l'espace de noms ne sera pas cr\u00e9\u00e9.

    Vous recevrez une notification par e-mail lorsque l'espace de noms sera cr\u00e9\u00e9. Une fois l'espace de noms partag\u00e9 cr\u00e9\u00e9, vous pouvez y acc\u00e9der de la m\u00eame mani\u00e8re que n'importe quel autre espace de noms dont vous disposez via l'interface utilisateur de Kubeflow, comme illustr\u00e9 ci-dessous. Vous serez alors capable de partager et g\u00e9rer) \u00e0 votre espace de nom.

    Pour changer d'espace de noms, regardez en haut de votre fen\u00eatre, juste \u00e0 droite du logo Kubeflow.

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html","title":"Environnement d'Analyse G\u00e9ospatiale (EAG) - Acc\u00e8s multi-plateforme","text":"Donn\u00e9es non prot\u00e9g\u00e9es uniquement, SSI bient\u00f4t disponible!

    \u00c0 l'heure actuelle, notre serveur g\u00e9ospatial ne peut h\u00e9berger et donner acc\u00e8s qu'\u00e0 des informations statistiques non sensibles.

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#demarrage","title":"D\u00e9marrage","text":"

    Conditions pr\u00e9alables

    1. Un projet int\u00e9gr\u00e9 avec acc\u00e8s au portail SAD EAG ArcGIS
    2. Un identifiant client ArcGIS Portal (cl\u00e9 API)

    Le portail ArcGIS Enterprise est accessible dans ETAA ou EAC \u00e0 l'aide de l'API, \u00e0 partir de n'importe quel service qui exploite le langage de programmation Python.

    Par exemple, dans ETAA et l'utilisation de Bloc-notes Jupyter dans l'espace, ou pour EAC l'utilisation de Databricks, DataFactory, etc.

    Le portail DAS GAE ArcGIS Enterprise est accessible directement ici

    Pour obtenir de l'aide sur l'auto-inscription en tant qu'utilisateur du portail g\u00e9ospatial SAD

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#utilisation-de-lapi-arcgis-pour-python","title":"Utilisation de l'API ArcGIS pour Python","text":""},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#connexion-a-arcgis-enterprise-portal-a-laide-de-lapi-arcgis","title":"Connexion \u00e0 ArcGIS Enterprise Portal \u00e0 l'aide de l'API ArcGIS","text":"

    1. Installez les packages\u00a0:

      conda install -c esri arcgis\n

      ou utilisez Artifactory

      conda install -c https://jfrog.aaw.cloud.statcan.ca/artifactory/api/conda/esri-remote arcgis\n

    2. Importez les biblioth\u00e8ques n\u00e9cessaires dont vous aurez besoin dans le bloc-note. 

      from arcgis.gis import GIS\nfrom arcgis.gis import Item\n

    3. Acc\u00e9der au portail Votre groupe de projet recevra un identifiant client lors de l'int\u00e9gration. Collez l'ID client entre les guillemetsclient_id='######'. 

      gis = GIS(\"https://geoanalytics.cloud.statcan.ca/portal\", client_id=' ')\nprint(\"Connexion r\u00e9ussie sous le nom de: \" + gis.properties.user.username)\n

    4. La sortie vous redirigera vers un portail de connexion.

      • Utilisez l'option de connexion Azure de StatCan et votre identifiant Cloud
      • Apr\u00e8s une connexion r\u00e9ussie, vous recevrez un code pour vous connecter en utilisant SAML.

      • Collez ce code dans la sortie.

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#afficher-les-informations-utilisateur","title":"Afficher les informations utilisateur","text":"

    En utilisant la fonction \u00ab me \u00bb, nous pouvons afficher diverses informations sur l'utilisateur connect\u00e9. 

    me = gis.users.me\nusername = me.username\ndescription = me.description\ndisplay(me)\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#rechercher-du-contenu","title":"Rechercher du contenu","text":"

    Recherchez le contenu que vous avez h\u00e9berg\u00e9 sur le portail SAD EAG. En utilisant la fonction \u00ab me \u00bb, nous pouvons rechercher tout le contenu h\u00e9berg\u00e9 sur le compte. Il existe plusieurs fa\u00e7ons de rechercher du contenu. Deux m\u00e9thodes diff\u00e9rentes sont d\u00e9crites ci-dessous.

    Recherchez tous vos \u00e9l\u00e9ments h\u00e9berg\u00e9s dans le portail g\u00e9ographique SAD. 

    my_content = me.items()\nmy_content\n
    Recherchez du contenu sp\u00e9cifique que vous poss\u00e9dez dans le portail g\u00e9ographique SAD.

    Ceci est similaire \u00e0 l'exemple ci-dessus, mais si vous connaissez le titre de la couche que vous souhaitez utiliser, vous pouvez l'enregistrer en tant que fonction. 

    my_items = me.items()\nfor items in my_items:\n    print(items.title, \" | \", items.type)\n    if items.title == \"Inondation \u00e0 Sorel-Tracy\":\n        flood_item = items\n\n    else:\n        continue\nprint(flood_item)\n

    Recherchez tout le contenu auquel vous avez acc\u00e8s, pas seulement le v\u00f4tre.

    flood_item = gis.content.search(\"tags: flood\", item_type =\"Service des caract\u00e9ristiques\")\nflood_item\n
    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#obtenir-du-contenu","title":"Obtenir du contenu","text":"

    Nous devons obtenir l'\u00e9l\u00e9ment du portail g\u00e9ographique SAD afin de l'utiliser dans le bloc-notes Jupyter. Cela se fait en fournissant le num\u00e9ro d'identification unique de l'article que vous souhaitez utiliser. Trois exemples sont d\u00e9crits ci-dessous, tous acc\u00e9dant \u00e0 la m\u00eame couche.

    item1 = gis.content.get(my_content[5].id) #de la recherche de votre contenu ci-dessus\ndisplay(item1)\n\nitem2 = gis.content.get(flood_item.id) #de la recherche de votre contenu ci-dessus\ndisplay(item2)\n\nitem3 = gis.content.get('edebfe03764b497f90cda5f0bfe727e2') #le num\u00e9ro d'identification du contenu\ndisplay(item3)\n
    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#effectuer-une-analyse","title":"Effectuer une analyse","text":"

    Une fois les couches import\u00e9es dans le bloc-note Jupyter, nous sommes en mesure d'effectuer des types d'analyse similaires \u00e0 ceux que vous vous attendriez \u00e0 trouver dans un logiciel SIG tel qu'ArcGIS. Il existe de nombreux modules contenant de nombreux sous-modules qui peuvent effectuer plusieurs types d'analyses.

    \u00c0 l'aide du module arcgis.features, importez le sous-module use_proximity from arcgis.features import use_proximity. Ce sous-module nous permet de .create_buffers - des zones \u00e0 \u00e9gale distance des entit\u00e9s. Ici, nous sp\u00e9cifions la couche que nous voulons utiliser, la distance, les unit\u00e9s et le nom de sortie (vous pouvez \u00e9galement sp\u00e9cifier d'autres caract\u00e9ristiques telles que le champ, le type d'anneau, le type de fin et autres). En sp\u00e9cifiant un nom de sortie, apr\u00e8s avoir ex\u00e9cut\u00e9 la commande buffer, une nouvelle couche sera automatiquement t\u00e9l\u00e9charg\u00e9e dans le portail SAD EAG contenant la nouvelle fonctionnalit\u00e9 que vous venez de cr\u00e9er. 

    buffer_lyr = use_proximity.create_buffers(item1, distances=[1], \n                                          units = \"Kilom\u00e8tres\", \n                                          output_name='item1_buffer')\n\ndisplay(item1_buffer)\n

    Certains utilisateurs pr\u00e9f\u00e8rent travailler avec des packages Open Source. La traduction d'ArcGIS vers Spatial Dataframes est simple. 

    # cr\u00e9er un objet DataFrame spatialis\u00e9\nsdf = pd.DataFrame.spatial.from_layer(feature_layer)\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#mettre-a-jour-les-elements","title":"Mettre \u00e0 jour les \u00e9l\u00e9ments","text":"

    En obtenant l'\u00e9l\u00e9ment comme nous l'avons fait similaire \u00e0 l'exemple ci-dessus, nous pouvons utiliser la fonction .update pour mettre \u00e0 jour l'\u00e9l\u00e9ment existant dans le portail SAD EAG. Nous pouvons mettre \u00e0 jour les propri\u00e9t\u00e9s, les donn\u00e9es, les vignettes et les m\u00e9tadonn\u00e9es des \u00e9l\u00e9ments. 

    item1_buffer = gis.content.get('c60c7e57bdb846dnbd7c8226c80414d2')\nitem1_buffer.update(item_properties={'title': 'Saisir le titre'\n                                     'tags': 'tag1, tag2, tag3, tag4',\n                                     'description': 'Saisir la description de l'article'}\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#visualisez-vos-donnees-sur-une-carte-interactive","title":"Visualisez vos donn\u00e9es sur une carte interactive","text":"

    Exemple\u00a0: biblioth\u00e8que MatplotLib Dans le code ci-dessous, nous cr\u00e9ons un objet ax, qui est un trac\u00e9 de style carte. Nous tra\u00e7ons ensuite notre colonne de changement de donn\u00e9es (\"Population Change\") sur les axes 

    import matplotlib.pyplot as plt\nax = sdf.boundary.plot(figsize=(10, 5))\nshape.plot(ax=ax, column='Population Change', legend=True)\nplt.show()\n

    Exemple\u00a0: biblioth\u00e8que ipyleaflet Dans cet exemple, nous utiliserons la biblioth\u00e8que ipyleaflet pour cr\u00e9er une carte interactive. Cette carte sera centr\u00e9e autour de Toronto, ON. Les donn\u00e9es utilis\u00e9es seront d\u00e9crites ci-dessous. Commencez par coller conda install -c conda-forge ipyleaflet vous permettant d'installer les biblioth\u00e8ques ipyleaflet dans l'environnement Python.

    Importer les biblioth\u00e8ques n\u00e9cessaires.

    import ipyleaflet \nfrom ipyleaflet import *\n
    Maintenant que nous avons import\u00e9 le module ipyleaflet, nous pouvons cr\u00e9er une carte simple en sp\u00e9cifiant la latitude et la longitude de l'emplacement que nous voulons, le niveau de zoom et le fond de carte (plus de fonds de carte). Des contr\u00f4les suppl\u00e9mentaires ont \u00e9t\u00e9 ajout\u00e9s tels que les calques et l'\u00e9chelle. 
    toronto_map = Map(center=[43.69, -79.35], zoom=11, basemap=basemaps.Esri.WorldStreetMap)\n\ntoronto_map.add_control(LayersControl(position='topright'))\ntoronto_map.add_control(ScaleControl(position='bottomleft'))\ntoronto_map\n

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#en-savoir-plus-sur-lapi-arcgis-pour-python","title":"En savoir plus sur l'API ArcGIS pour Python","text":"

    La documentation compl\u00e8te de l'API ArcGIS peut \u00eatre trouv\u00e9e ici

    "},{"location":"4-Collaboration/Environnement-Analyse-Geospatiale.html#en-savoir-plus-sur-lenvironnement-analytique-geospatial-gae-et-les-services-sad","title":"En savoir plus sur l'environnement analytique g\u00e9ospatial (GAE) et les services SAD","text":"

    Guide d'aide GAE

    "},{"location":"5-Stockage/Aper%C3%A7u.html","title":"Stockage","text":"

    La plateforme propose plusieurs types de stockage :

    • Disque (\u00e9galement appel\u00e9 Volumes sur l'\u00e9cran de cr\u00e9ation de serveur de blocs-note)
    • Compartiment (Stockage Azure Blob)
    • Data Lakes (\u00e0 venir)

    Selon votre cas d'utilisation, le disque ou le compartiment peut \u00eatre le plus appropri\u00e9 :

    Type Utilisateurs simultan\u00e9s Vitesse Taille totale Partageable avec d'autres utilisateurs Disque Une machine/serveur de bloc-notes \u00e0 la fois Le plus rapide (d\u00e9bit et latence) <=512GB total par stockage Non Compartiment (via Stockage Blob Azure) Acc\u00e8s simultan\u00e9 depuis plusieurs machines/serveurs d'ordinateurs portables en m\u00eame temps Fast-ish (t\u00e9l\u00e9chargement rapide, t\u00e9l\u00e9chargement modeste, latence modeste) Infini (dans la limite du raisonnable) [Oui] Si vous ne savez pas lequel choisir, ne vous en faites pas

    Ce sont des lignes directrices, pas une science exacte - choisissez ce qui sonne le mieux maintenant et ex\u00e9cutez-le. Le meilleur choix pour une utilisation compliqu\u00e9e n'est pas \u00e9vident et n\u00e9cessite souvent une exp\u00e9rience pratique, donc essayer quelque chose vous aidera. Dans la plupart des situations, les deux options fonctionnent bien m\u00eame si elles ne sont pas parfaites, et n'oubliez pas que les donn\u00e9es peuvent toujours \u00eatre copi\u00e9es plus tard si vous changez d'avis.

    "},{"location":"5-Stockage/Disque.html","title":"Aper\u00e7u","text":"

    Les disques sont les syst\u00e8mes de fichiers familiers de type disque dur auxquels vous \u00eates habitu\u00e9, fournis \u00e0 vous des disques SSD rapides !

    "},{"location":"5-Stockage/Disque.html#installation","title":"Installation","text":"

    Lors de la cr\u00e9ation de votre serveur bloc-notes, vous demandez des disques en ajoutant des volumes de donn\u00e9es \u00e0 votre serveur de bloc-note (illustr\u00e9 ci-dessous, en allant dans Options avanc\u00e9es). Ils sont automatiquement mont\u00e9s dans le r\u00e9pertoire (Point de montage) que vous choisissez et constituent un moyen simple et fiable de conserver les donn\u00e9es attach\u00e9es \u00e0 un serveur bloc-note.

    Vous payez pour tous les disques que vous poss\u00e9dez, qu'ils soient connect\u00e9s \u00e0 un serveur bloc-note ou non

    D\u00e8s que vous cr\u00e9ez un disque, vous le payez jusqu'\u00e0 ce qu'il soit supprim\u00e9, m\u00eame si le Serveur de blocs-note d'origine est supprim\u00e9. Voir Suppression du stockage sur disque pour plus d'informations

    "},{"location":"5-Stockage/Disque.html#une-fois-que-vous-avez-les-bases","title":"Une fois que vous avez les bases...","text":"

    Lorsque vous supprimez votre serveur bloc-notes, vos disques ne sont pas supprim\u00e9s. Cela vous permet de r\u00e9utiliser ult\u00e9rieurement ce m\u00eame disque (avec tout son contenu) sur un nouveau serveur bloc-notes (comme indiqu\u00e9 ci-dessus avec Type = Existant et le Nom d\u00e9fini sur le volume que vous souhaitez r\u00e9utiliser). Si vous en avez termin\u00e9 avec le disque et son contenu, supprimez-le.

    "},{"location":"5-Stockage/Disque.html#suppression-du-stockage-sur-disque","title":"Suppression du stockage sur disque","text":"

    Pour voir vos disques, consultez la section Volumes de la page Serveur bloc-notes (illustr\u00e9 ci-dessous). Vous pouvez supprimer n'importe quel disque non connect\u00e9 (ic\u00f4ne \u00e0 gauche) en cliquant sur l'ic\u00f4ne de la corbeille.

    "},{"location":"5-Stockage/Disque.html#prix","title":"Prix","text":"Les mod\u00e8les de tarification sont provisoires et peuvent changer

    Au moment de la r\u00e9daction, la tarification est couverte par la plate-forme pour les utilisateurs initiaux. Ce guide explique comment les choses devraient \u00eatre tarif\u00e9es \u00e0 l'avenir, mais cela peut changer.

    Lors du montage d'un disque, vous obtenez un Disque manag\u00e9 Azure. La tarification des Disques g\u00e9r\u00e9s SSD Premium indique le co\u00fbt par disque en fonction de la taille. Notez que vous payez pour la taille du disque demand\u00e9e, et non pour la quantit\u00e9 d'espace que vous utilisez actuellement.

    Conseils pour minimiser les co\u00fbts

    Comme les disques peuvent \u00eatre attach\u00e9s \u00e0 un Serveur blocs-note et r\u00e9utilis\u00e9s, un mod\u00e8le d'utilisation typique pourrait \u00eatre :

    • \u00c0 9h, cr\u00e9ez un Serveur blocs-note (demandez 2CPU/8GB RAM et un 32GB attach\u00e9 disque)
    • Travaillez tout au long de la journ\u00e9e, en enregistrant les r\u00e9sultats sur le disque attach\u00e9
    • \u00c0 17h, \u00e9teignez votre Serveur blocs-note pour \u00e9viter de le payer du jour au lendemain
    • REMARQUE : Le disque attach\u00e9 ** n'est pas d\u00e9truit ** par cette action
    • \u00c0 9 heures du matin le lendemain, cr\u00e9ez un nouveau serveur blocs-note et ** joignez votre disque**
    • Continuez votre travail...

    Cela prot\u00e8ge tout votre travail sans payer pour l'ordinateur lorsque vous ne l'utilisez pas

    "},{"location":"5-Stockage/StockageBlobAzure.html","title":"Aper\u00e7u","text":"

    Azure Blob Storage est la solution de stockage d'objets de Microsoft pour le nuage informatique. Le stockage blob est optimis\u00e9 pour stocker des quantit\u00e9s massives de donn\u00e9es non structur\u00e9es. Les donn\u00e9es non structur\u00e9es sont des donn\u00e9es qui n'adh\u00e8rent pas \u00e0 un mod\u00e8le de donn\u00e9es ou \u00e0 une d\u00e9finition particuli\u00e8re, comme du texte ou des donn\u00e9es binaires.

    Les conteneurs de stockage blob Azure sont efficaces dans trois domaines\u00a0:

    • De grandes quantit\u00e9s de donn\u00e9es - Les conteneurs peuvent \u00eatre \u00e9normes : bien plus gros que les disques durs. Et ils sont toujours rapides.
    • Accessible par plusieurs consommateurs \u00e0 la fois - Vous pouvez acc\u00e9der \u00e0 la m\u00eame source de donn\u00e9es \u00e0 partir de plusieurs serveurs bloc-note et pipelines en m\u00eame temps sans avoir besoin de dupliquer les donn\u00e9es.
    • Partage - Les espaces de noms de projet peuvent partager un conteneur. C'est id\u00e9al pour partager des donn\u00e9es avec des personnes ext\u00e9rieures \u00e0 votre espace de travail.
    "},{"location":"5-Stockage/StockageBlobAzure.html#installation","title":"Installation","text":"

    Les conteneurs de stockage Azure Blob et le support de buckets remplaceront les supports de stockage Minio Buckets et Minio

    Les utilisateurs seront responsables de la migration des donn\u00e9es des Minio Buckets vers les dossiers Azure Storage. Pour les fichiers plus volumineux, les utilisateurs peuvent contacter AAW pour obtenir de l'aide.

    "},{"location":"5-Stockage/StockageBlobAzure.html#conteneur-blob-monte-sur-un-serveur-de-bloc-note","title":"Conteneur Blob mont\u00e9 sur un serveur de bloc-note","text":"

    Les volumes Blob CSI sont conserv\u00e9s sous /home/jovyan/buckets lors de la cr\u00e9ation d'un serveur bloc-notes. Les fichiers sous /buckets sont sauvegard\u00e9s par le stockage Blob. Tous les ordinateurs portables AAW auront le /buckets mont\u00e9 sur le syst\u00e8me de fichiers, rendant les donn\u00e9es accessibles de partout.

    "},{"location":"5-Stockage/StockageBlobAzure.html#support-de-dossier-aaw-pour-ordinateur-portable-non-classe","title":"Support de dossier AAW pour ordinateur portable non class\u00e9","text":""},{"location":"5-Stockage/StockageBlobAzure.html#support-de-dossier-aaw-pour-ordinateur-portable-protege-b","title":"Support de dossier AAW pour ordinateur portable prot\u00e9g\u00e9-b","text":"

    Ces dossiers peuvent \u00eatre utilis\u00e9s comme n'importe quel autre : vous pouvez copier des fichiers vers/depuis l'explorateur de fichiers, \u00e9crire \u00e0 partir de Python/R, etc. La seule diff\u00e9rence est que les donn\u00e9es sont stock\u00e9es dans le conteneur de stockage Blob plut\u00f4t que sur un disque local. (et est donc accessible partout o\u00f9 vous pouvez acc\u00e9der \u00e0 votre bloc-note Kubeflow).

    "},{"location":"5-Stockage/StockageBlobAzure.html#comment-migrer-de-minio-vers-azure-blob-storage","title":"Comment migrer de MinIO vers Azure Blob Storage","text":"

    Tout d\u2019abord, importez les variables d\u2019environnement stock\u00e9es dans votre coffre-fort de secrets. Vous importerez soit depuis minio-gateway soit depuis fdi-gateway selon l'endroit o\u00f9 vos donn\u00e9es ont \u00e9t\u00e9 ing\u00e9r\u00e9es.

    jovyan@rstudio-0\u00a0:~$ source /vault/secrets/fdi-gateway-protected-b\n

    Ensuite, vous cr\u00e9ez un alias pour acc\u00e9der \u00e0 vos donn\u00e9es.

    jovyan@rstudio-0\u00a0: ~$ mc alias d\u00e9fini minio $MINIO_URL $MINIO_ACCESS_KEY $MINIO_SECRET_KEY\n

    R\u00e9pertoriez le contenu de votre dossier de donn\u00e9es avec mc ls.

    jovyan@rstudio-0:~$ mc ls minio\n

    Enfin, copiez vos donn\u00e9es MinIO dans votre r\u00e9pertoire Azure Blob Storage avec mc cp --recursive.

    jovyan@rstudio-0:~$ mc cp --recursive minio ~/buckets/\n

    Si vous disposez de donn\u00e9es prot\u00e9g\u00e9es-b, vous pouvez copier vos donn\u00e9es dans le compartiment prot\u00e9g\u00e9-b.

    jovyan@rstudio-0:~$ mc cp \u2014-recursive minio ~/buckets/aaw-protected-b\n
    "},{"location":"5-Stockage/StockageBlobAzure.html#types-de-conteneurs","title":"Types de conteneurs","text":"

    Les conteneurs Blob suivants sont disponibles\u00a0:

    L\u2019acc\u00e8s \u00e0 tous les conteneurs Blob est le m\u00eame. La diff\u00e9rence entre les conteneurs r\u00e9side dans le type de stockage qui les sous-tend\u00a0:

    • aaw-unclassified\u00a0: Par d\u00e9faut, utilisez celui-ci. Stocke les donn\u00e9es non classifi\u00e9es.
    • aaw-protected-b\u00a0: Stocke les donn\u00e9es sensibles prot\u00e9g\u00e9es-b.
    • aaw-unclassified-ro\u00a0: Cette classification est prot\u00e9g\u00e9e-b mais en acc\u00e8s en lecture seule. Cela permet aux utilisateurs de visualiser les donn\u00e9es non classifi\u00e9es dans un bloc-notes prot\u00e9g\u00e9-b.
    "},{"location":"5-Stockage/StockageBlobAzure.html#acces-aux-donnees-internes","title":"Acc\u00e8s aux donn\u00e9es internes","text":"

    L'acc\u00e8s aux donn\u00e9es internes utilise la connexion de stockage commune DAS qui est utilis\u00e9e par les utilisateurs internes et externes qui ont besoin d'acc\u00e9der \u00e0 des donn\u00e9es non classifi\u00e9es ou prot\u00e9g\u00e9es-b. Les conteneurs suivants peuvent \u00eatre mis \u00e0 disposition :

    • externe-non class\u00e9
    • externe-prot\u00e9g\u00e9-b
    • interne-non class\u00e9
    • interne-prot\u00e9g\u00e9-b

    Ils suivent la m\u00eame convention que les conteneurs AAW ci-dessus en termes de donn\u00e9es, mais il existe une couche d'isolement entre les employ\u00e9s de StatCan et les non-employ\u00e9s de StatCan. Les employ\u00e9s non-Statcan ne sont autoris\u00e9s que dans les conteneurs externes, tandis que les employ\u00e9s de StatCan peuvent avoir acc\u00e8s \u00e0 n'importe quel conteneur.

    AAW dispose d'une int\u00e9gration avec l'\u00e9quipe FAIR Data Infrastructure qui permet aux utilisateurs de transf\u00e9rer des donn\u00e9es non classifi\u00e9es et prot\u00e9g\u00e9es vers des comptes de stockage Azure, permettant ainsi aux utilisateurs d'acc\u00e9der \u00e0 ces donn\u00e9es \u00e0 partir de serveurs bloc-note.

    Veuillez contacter l'\u00e9quipe FAIR Data Infrastructure si vous avez un cas d'utilisation de ces donn\u00e9es.

    "},{"location":"5-Stockage/StockageBlobAzure.html#tarifs","title":"Tarifs","text":"

    Les mod\u00e8les de tarification sont bas\u00e9s sur l'utilisation du processeur et de la m\u00e9moire

    Le prix est couvert par KubeCost pour les espaces de noms utilisateur (dans Kubeflow en bas de l'onglet bloc-notes).

    En g\u00e9n\u00e9ral, le stockage Blob est beaucoup moins cher que Azure Manage Disks et offre de meilleures E/S que les SSD g\u00e9r\u00e9s.

    "},{"location":"6-Gitlab/Gitlab.html","title":"Guide de configuration de GitLab","text":"

    Bienvenue sur GitLab\u00a0! GitLab est une plateforme puissante qui facilite le d\u00e9veloppement collaboratif \u00e0 l'aide de Git. Avant de plonger dans le monde des r\u00e9f\u00e9rentiels, assurons-nous que votre configuration Git correspond \u00e0 votre identit\u00e9 GitLab. Vous trouverez ci-dessous des instructions sur la personnalisation de \u00ab git \u00bb et la cr\u00e9ation d'un jeton d'acc\u00e8s personnel (PAT) pour une interaction transparente avec les r\u00e9f\u00e9rentiels GitLab.

    "},{"location":"6-Gitlab/Gitlab.html#personnalisation-de-git","title":"Personnalisation de Git","text":"

    Lorsque vous utilisez git, il est essentiel de configurer votre identit\u00e9. Ouvrez une nouvelle session de terminal et ex\u00e9cutez les commandes suivantes pour configurer votre nom et votre adresse e-mail associ\u00e9s \u00e0 GitLab\u00a0:

    "},{"location":"6-Gitlab/Gitlab.html#nom-dutilisateur","title":"Nom d'utilisateur","text":"
    git config --global user.name \"Votre nom\"\n
    "},{"location":"6-Gitlab/Gitlab.html#e-mail","title":"E-mail","text":"
    git config --global user.email \"votreemail@votredomaine.com\"\n

    D\u00e9sormais, chaque fois que vous interagissez avec GitLab, git utilisera ces informations pour vous identifier.

    "},{"location":"6-Gitlab/Gitlab.html#creer-un-jeton-dacces-personnel-pat","title":"Cr\u00e9er un jeton d'acc\u00e8s personnel (PAT)","text":"

    Pour interagir (push, pull) avec n'importe quel r\u00e9f\u00e9rentiel GitLab de Statistique Canada, vous devez cr\u00e9er un jeton d'acc\u00e8s personnel. Suivez ces \u00e9tapes:

    1. Allez sur GitLab.
    2. Cliquez sur votre ic\u00f4ne de profil dans le coin sup\u00e9rieur gauche.
    3. S\u00e9lectionnez Pr\u00e9f\u00e9rences, puis Jetons d'acc\u00e8s.
    "},{"location":"6-Gitlab/Gitlab.html#icone-de-profil","title":"Ic\u00f4ne de profil","text":""},{"location":"6-Gitlab/Gitlab.html#jetons-dacces","title":"Jetons d'acc\u00e8s","text":""},{"location":"6-Gitlab/Gitlab.html#formulaire-de-jeton-dacces-personnel","title":"Formulaire de jeton d'acc\u00e8s personnel","text":"
    • Remplissez le formulaire en fournissant un nom pour le jeton (pour une identification facile), en d\u00e9finissant la date d'expiration du jeton et en accordant des autorisations (par exemple, read_repository et write_repository).
    • Le token expire \u00e0 cette date \u00e0 minuit UTC.
    • Si vous ne saisissez pas de date d'expiration, la date d'expiration est automatiquement fix\u00e9e \u00e0 365 jours apr\u00e8s la date du jour.
    • Par d\u00e9faut, cette date peut \u00eatre post\u00e9rieure au maximum de 365 jours \u00e0 la date du jour.
    "},{"location":"6-Gitlab/Gitlab.html#le-jeton","title":"Le jeton","text":"

    Gardez vos secrets pour vous!

    1. Veuillez NE PAS stocker votre jeton d'acc\u00e8s personnel n'importe o\u00f9 dans le syst\u00e8me de fichiers de votre serveur d'espace de travail. Les contributeurs \u00e0 un espace de noms y auront acc\u00e8s\u00a0!
    2. S'il y a un contributeur externe \u00e0 Statistique Canada dans votre espace de noms, vous perdrez l'acc\u00e8s \u00e0 l'acc\u00e8s principal au cloud GitLab\u00a0!

    Le jeton g\u00e9n\u00e9r\u00e9 pourra \u00eatre copi\u00e9 en haut apr\u00e8s avoir cliqu\u00e9 sur Cr\u00e9er un jeton d'acc\u00e8s personnel. Copiez et enregistrez ce jeton en toute s\u00e9curit\u00e9, car il ne pourra pas \u00eatre r\u00e9cup\u00e9r\u00e9 ult\u00e9rieurement.

    "},{"location":"6-Gitlab/Gitlab.html#fournissez-le-jeton-genere-comme-mot-de-passe-gitlab","title":"Fournissez le jeton g\u00e9n\u00e9r\u00e9 comme mot de passe GitLab","text":"

    Utilisez le jeton g\u00e9n\u00e9r\u00e9 comme mot de passe GitLab lorsque vous y \u00eates invit\u00e9. Voici un exemple de la fa\u00e7on d'incorporer le jeton dans vos commandes\u00a0:

    Nous pouvons utiliser git-credential-cache pour mettre en cache notre nom d'utilisateur et notre mot de passe pendant une p\u00e9riode donn\u00e9e. Entrez simplement ce qui suit dans votre CLI (terminal ou invite de commande)\u00a0:

    git config --global credential.helper cache\n

    Vous pouvez \u00e9galement d\u00e9finir le d\u00e9lai d'attente (en secondes) comme tel\u00a0:

    git config --global credential.helper 'cache --timeout=3600'\n

    Pour plus d'informations sur les jetons d'acc\u00e8s personnels Gitlab, veuillez visiter\u00a0: la documentation officielle. Avec ces \u00e9tapes, vous \u00eates d\u00e9sormais pr\u00eat \u00e0 collaborer de mani\u00e8re transparente sur GitLab\u00a0! Bon codage\u00a0!

    "},{"location":"7-MLOps/Aper%C3%A7u.html","title":"Aper\u00e7u","text":"

    MLOps, ou Machine Learning Operations, fait r\u00e9f\u00e9rence \u00e0 l'ensemble de pratiques et d'outils qui permettent aux organisations de d\u00e9velopper, d\u00e9ployer et maintenir des mod\u00e8les d'apprentissage automatique \u00e0 grande \u00e9chelle. MLOps vise \u00e0 rationaliser le processus de bout en bout de cr\u00e9ation et de d\u00e9ploiement de mod\u00e8les d'apprentissage automatique en int\u00e9grant les diff\u00e9rentes \u00e9tapes du cycle de vie de l'apprentissage automatique dans un flux de travail coh\u00e9rent et automatis\u00e9.

    MLOps implique une gamme d'activit\u00e9s diff\u00e9rentes, notamment la pr\u00e9paration et le pr\u00e9traitement des donn\u00e9es, la formation et l'optimisation des mod\u00e8les, le d\u00e9ploiement et la maintenance des mod\u00e8les, la surveillance et la maintenance, ainsi que l'am\u00e9lioration continue. Certains des composants cl\u00e9s de MLOps incluent\u00a0:

    1. Gestion des donn\u00e9es\u00a0: MLOps implique la gestion et le traitement de grandes quantit\u00e9s de donn\u00e9es pour garantir la qualit\u00e9 et l'exactitude des mod\u00e8les d'apprentissage automatique. Cela implique des activit\u00e9s telles que le nettoyage des donn\u00e9es, l'int\u00e9gration des donn\u00e9es et la transformation des donn\u00e9es.

    2. Formation et optimisation des mod\u00e8les\u00a0: MLOps implique le d\u00e9veloppement et le test de mod\u00e8les d'apprentissage automatique, ainsi que leur optimisation en termes de performances et de pr\u00e9cision. Cela peut impliquer d'exp\u00e9rimenter diff\u00e9rents algorithmes, hyperparam\u00e8tres et techniques de pr\u00e9traitement des donn\u00e9es.

    3. D\u00e9ploiement de mod\u00e8les\u00a0: MLOps implique le d\u00e9ploiement de mod\u00e8les d'apprentissage automatique dans des environnements de production, les rendant disponibles pour une utilisation dans des applications du monde r\u00e9el. Cela peut impliquer la conteneurisation des mod\u00e8les pour un d\u00e9ploiement et une mise \u00e0 l'\u00e9chelle faciles, ainsi que la configuration d'API et d'autres interfaces pour la diffusion de mod\u00e8les.

    4. Surveillance et maintenance\u00a0: MLOps implique la surveillance des mod\u00e8les d'apprentissage automatique en production pour garantir qu'ils fonctionnent comme pr\u00e9vu. Cela peut impliquer la configuration d'alertes et de notifications en cas de d\u00e9faillance du mod\u00e8le, ainsi que la mise en \u0153uvre de processus de maintenance et de mise \u00e0 jour du mod\u00e8le.

    5. Am\u00e9lioration continue\u00a0: MLOps implique l'am\u00e9lioration continue des mod\u00e8les d'apprentissage automatique au fil du temps, sur la base des commentaires des utilisateurs et de l'analyse continue des donn\u00e9es de performances. Cela peut impliquer de recycler les mod\u00e8les avec de nouvelles donn\u00e9es ou d'int\u00e9grer les commentaires des utilisateurs pour affiner les mod\u00e8les.

    Afin de mettre en \u0153uvre efficacement les MLOps, les organisations doivent g\u00e9n\u00e9ralement adopter une gamme d'outils et de technologies diff\u00e9rents, notamment des plates-formes de gestion de donn\u00e9es, des cadres d'apprentissage automatique, des outils de conteneurisation et des outils de surveillance et de journalisation. Ils doivent \u00e9galement \u00e9tablir des flux de travail et des processus clairs pour g\u00e9rer les diff\u00e9rentes \u00e9tapes du cycle de vie du machine learning, ainsi que mettre en \u0153uvre des mesures de gouvernance et de conformit\u00e9 pour garantir la confidentialit\u00e9 et la s\u00e9curit\u00e9 des donn\u00e9es.

    En r\u00e9sum\u00e9, MLOps est un composant essentiel du cycle de vie du machine learning, permettant aux organisations de d\u00e9velopper, d\u00e9ployer et maintenir des mod\u00e8les de machine learning \u00e0 grande \u00e9chelle. En adoptant les pratiques et outils MLOps, les organisations peuvent rationaliser leurs flux de travail d'apprentissage automatique, am\u00e9liorer la pr\u00e9cision et les performances des mod\u00e8les et offrir plus de valeur aux utilisateurs et aux parties prenantes.

    "},{"location":"7-MLOps/Integration-PaaS.html","title":"Aper\u00e7u","text":"

    L'un des principaux avantages de la plateforme ETAA est sa capacit\u00e9 \u00e0 s'int\u00e9grer aux plateformes d'apprentissage automatique populaires telles que Databricks et AzureML.

    L'Espace de travail d'analyse avanc\u00e9e (ETAA) est une plateforme d'analyse de donn\u00e9es open source con\u00e7ue pour \u00eatre hautement int\u00e9grable. Cela signifie qu'il peut \u00eatre facilement int\u00e9gr\u00e9 \u00e0 d'autres plates-formes et outils pour \u00e9tendre ses capacit\u00e9s et rationaliser les flux de travail.

    Un exemple de diagramme illustrant une strat\u00e9gie de connexion PaaS possible\u00a0:

    Configuration\u00a0: Si vous avez besoin d'aide pour int\u00e9grer une offre de plateforme en tant que service, nous serons heureux de vous aider!

    "},{"location":"7-MLOps/Integration-PaaS.html#integration-avec-les-offres-de-plateforme-externe-en-tant-que-service-paas","title":"Int\u00e9gration avec les offres de plateforme externe en tant que service (PaaS)","text":"

    L'int\u00e9gration est la cl\u00e9 du succ\u00e8s.

    Notre plateforme open source offre une optionnalit\u00e9 in\u00e9gal\u00e9e \u00e0 nos utilisateurs. En permettant aux utilisateurs d'utiliser des outils open source, nous leur permettons d'utiliser leurs cadres pr\u00e9f\u00e9r\u00e9s de science des donn\u00e9es et d'apprentissage automatique. Mais la v\u00e9ritable puissance de notre plateforme vient de sa capacit\u00e9 \u00e0 s'int\u00e9grer \u00e0 de nombreuses offres Platform as a Service (PaaS), comme Databricks ou AzureML. Cela signifie que nos utilisateurs peuvent tirer parti de la puissance du cloud pour ex\u00e9cuter des pipelines complexes de traitement de donn\u00e9es et d\u2019apprentissage automatique \u00e0 grande \u00e9chelle. Avec la possibilit\u00e9 de s'int\u00e9grer aux offres PaaS, notre plateforme permet \u00e0 nos utilisateurs de faire passer leur travail au niveau sup\u00e9rieur, en leur donnant le pouvoir d'adapter facilement leurs charges de travail et de profiter des derni\u00e8res innovations dans le domaine de la science des donn\u00e9es et des machines. apprentissage. En offrant ce niveau d'optionnalit\u00e9, nous garantissons que nos utilisateurs peuvent toujours choisir le bon outil pour le travail et garder une longueur d'avance dans un domaine en constante \u00e9volution.

    Nous pouvons int\u00e9grer de nombreuses offres Platform as a Service (PaaS), comme Databricks ou AzureML.

    "},{"location":"7-MLOps/Integration-PaaS.html#databricks","title":"Databricks","text":"
    • Databricks de Microsoft

    Databricks est une plateforme bas\u00e9e sur le nuage qui fournit une plateforme d'analyse unifi\u00e9e pour le traitement du Big Data et l'apprentissage automatique. Avec son puissant moteur informatique distribu\u00e9 et ses outils de flux de travail rationalis\u00e9s, Databricks est un choix populaire pour cr\u00e9er et d\u00e9ployer des mod\u00e8les d'apprentissage automatique. En s'int\u00e9grant \u00e0 Databricks, la plateforme ETAA peut exploiter ses capacit\u00e9s informatiques distribu\u00e9es pour former et d\u00e9ployer des mod\u00e8les d'apprentissage automatique \u00e0 grande \u00e9chelle.

    "},{"location":"7-MLOps/Integration-PaaS.html#azureml","title":"AzureML","text":"
    • Azure ML de Microsoft

    AzureML est une autre plate-forme d'apprentissage automatique populaire qui fournit une large gamme d'outils pour cr\u00e9er, former et d\u00e9ployer des mod\u00e8les d'apprentissage automatique. En s'int\u00e9grant \u00e0 AzureML, la plateforme ETAA peut tirer parti de ses puissants outils de cr\u00e9ation et de formation de mod\u00e8les, ainsi que de sa capacit\u00e9 \u00e0 d\u00e9ployer des mod\u00e8les dans le nuage.

    "},{"location":"7-MLOps/Integration-PaaS.html#exemples","title":"Exemples","text":"

    Des exemples de la fa\u00e7on d'int\u00e9grer la plate-forme ETAA avec ces plates-formes et d'autres peuvent \u00eatre trouv\u00e9s sur le r\u00e9f\u00e9rentiel MLOps Github.

    • D\u00e9p\u00f4t Github MLOps

    Ce r\u00e9f\u00e9rentiel contient une gamme d'exemples et de didacticiels permettant d'utiliser la plateforme ETAA dans divers flux de travail d'apprentissage automatique, notamment la pr\u00e9paration des donn\u00e9es, la formation de mod\u00e8les et le d\u00e9ploiement de mod\u00e8les.

    "},{"location":"7-MLOps/Integration-PaaS.html#conclusion","title":"Conclusion","text":"

    En s'int\u00e9grant \u00e0 des plateformes d'apprentissage automatique populaires telles que Databricks et AzureML, la plateforme ETAA fournit une solution puissante et flexible pour cr\u00e9er, d\u00e9ployer et g\u00e9rer des flux de travail d'apprentissage automatique \u00e0 grande \u00e9chelle.

    En tirant parti des int\u00e9grations et des outils fournis par ces plateformes, les data scientists et les ing\u00e9nieurs en apprentissage automatique peuvent acc\u00e9l\u00e9rer leurs flux de travail et obtenir de meilleurs r\u00e9sultats avec moins d'efforts.

    "},{"location":"7-MLOps/Modele-ML-stockage.html","title":"Donn\u00e9es B prot\u00e9g\u00e9es par Statcan","text":"

    Prot\u00e9g\u00e9 B

    L'ETAA est certifi\u00e9 pour l'h\u00e9bergement de donn\u00e9es Prot\u00e9g\u00e9 B\u00a0!

    Afin de t\u00e9l\u00e9charger des donn\u00e9es Prot\u00e9g\u00e9 B vers l'ETAA, les utilisateurs devront demander l'acc\u00e8s via la Customer Success Unit (CSU). Les utilisateurs d'ETAA devront \u00e9galement fournir un espace de noms, trouver un sponsor et obtenir l'approbation d'OPMIC. Une fois le processus approuv\u00e9, notre \u00e9quipe Fair Data Infrastructure (FDI) cr\u00e9era ensuite un dossier sur Net A qui \u00e0 son tour donnera acc\u00e8s aux utilisateurs via l'annuaire actif. Les donn\u00e9es pourront ensuite \u00eatre transf\u00e9r\u00e9es de Net A vers le nuage ETAA

    Le stockage des mod\u00e8les d'apprentissage automatique dans un environnement de stockage cloud prot\u00e9g\u00e9 est essentiel pour garantir la s\u00e9curit\u00e9 et la confidentialit\u00e9 des donn\u00e9es sensibles. L'espace de travail d'analyse avanc\u00e9e (ETAA) fournit un environnement de nuage stockage s\u00e9curis\u00e9 et robuste qui peut \u00eatre utilis\u00e9 pour stocker des mod\u00e8les d'apprentissage automatique et d'autres actifs de donn\u00e9es.

    La plate-forme ETAA fournit un environnement de nuage stockage prot\u00e9g\u00e9 con\u00e7u pour r\u00e9pondre aux exigences les plus strictes en mati\u00e8re de s\u00e9curit\u00e9 et de confidentialit\u00e9 des donn\u00e9es. L'environnement de stockage est prot\u00e9g\u00e9 par un cryptage et des contr\u00f4les d'acc\u00e8s conformes aux normes de l'industrie, ce qui garantit que seul le personnel autoris\u00e9 peut acc\u00e9der aux donn\u00e9es sensibles. Cela prot\u00e8ge contre les acc\u00e8s non autoris\u00e9s, les violations de donn\u00e9es et autres menaces de s\u00e9curit\u00e9.

    En plus de ses fonctionnalit\u00e9s de s\u00e9curit\u00e9 robustes, l'environnement de nuage stockage ETAA est \u00e9galement hautement \u00e9volutif et flexible. Cela signifie que les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique peuvent facilement faire \u00e9voluer leurs besoins de stockage \u00e0 mesure que leurs ensembles de donn\u00e9es et la taille de leurs mod\u00e8les augmentent. Cela leur permet de stocker et de g\u00e9rer de gros volumes de donn\u00e9es et de mod\u00e8les sans avoir \u00e0 se soucier des limitations de stockage ou des goulots d'\u00e9tranglement des performances.

    Le stockage des mod\u00e8les d'apprentissage automatique dans un environnement de stockage en nuage prot\u00e9g\u00e9 sur l'espace de travail d'analyse avanc\u00e9e fournit une solution s\u00e9curis\u00e9e, \u00e9volutive et flexible pour g\u00e9rer et prot\u00e9ger les donn\u00e9es sensibles. En tirant parti des capacit\u00e9s de nuage stockage fournies par la plateforme ETAA, les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique peuvent se concentrer sur la cr\u00e9ation et le d\u00e9ploiement de leurs mod\u00e8les en toute confiance, sachant que leurs donn\u00e9es sont prot\u00e9g\u00e9es et s\u00e9curis\u00e9es.

    "},{"location":"7-MLOps/Modele-ML-stockage.html#stockage-en-ligne","title":"Stockage en ligne","text":"

    Avantages du nuage de stockage

    Le stockage en nuage offre plusieurs avantages pour la science des donn\u00e9es et l'apprentissage automatique, notamment en termes d'\u00e9volutivit\u00e9, d'accessibilit\u00e9 et de rentabilit\u00e9.

    Premi\u00e8rement, le stockage dans le nuage permet aux scientifiques des donn\u00e9es de stocker et de traiter de grandes quantit\u00e9s de donn\u00e9es sans avoir \u00e0 se soucier des limites du stockage local. Ceci est particuli\u00e8rement important dans le contexte de l\u2019apprentissage automatique, o\u00f9 de grands ensembles de donn\u00e9es sont n\u00e9cessaires pour la formation et le test des mod\u00e8les. Le stockage dans le nuage permet aux scientifiques des donn\u00e9es d'augmenter leur capacit\u00e9 de stockage selon leurs besoins, sans avoir \u00e0 investir dans du mat\u00e9riel co\u00fbteux.

    Deuxi\u00e8mement, le stockage dans le nuage permet aux scientifiques des donn\u00e9es d'acc\u00e9der aux donn\u00e9es de n'importe o\u00f9, en utilisant n'importe quel appareil dot\u00e9 d'une connexion Internet. Cela permet la collaboration entre des \u00e9quipes g\u00e9ographiquement r\u00e9parties et permet aux scientifiques des donn\u00e9es de travailler \u00e0 distance. De plus, le stockage dans le nuage facilite le partage de donn\u00e9es avec d'autres parties prenantes, telles que des partenaires commerciaux ou des clients. Enfin, le stockage dans le nuage est g\u00e9n\u00e9ralement plus rentable que le stockage sur site, en particulier pour les petites organisations ou celles disposant de ressources informatiques limit\u00e9es.

    Dans l\u2019ensemble, le stockage dans le nuage est une solution fiable et pratique pour stocker et g\u00e9rer vos donn\u00e9es. Que vous ayez besoin de stocker de grandes quantit\u00e9s de donn\u00e9es ou seulement quelques fichiers, le stockage dans le 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 (\u00e9galement appel\u00e9s Volumes sur l'\u00e9cran de cr\u00e9ation de Kubeflow Serveur Bloc-notes)
    • Lacs de donnees (\u00e0 venir)

    Selon votre cas d'utilisation, le disque ou le compartiment peuvent \u00eatre les plus adapt\u00e9s. Notre aper\u00e7u du stockage vous aidera \u00e0 les comparer.

    "},{"location":"7-MLOps/Modele-ML-stockage.html#disques","title":"Disques","text":"

    Disques sont ajout\u00e9s \u00e0 votre serveur bloc-notes en augmentant les volumes de donn\u00e9es.

    "},{"location":"7-MLOps/Modele-ML-stockage.html#lacs-de-donnees-a-venir","title":"Lacs de donn\u00e9es (\u00e0 venir)","text":"

    Un lac de donn\u00e9es est un r\u00e9f\u00e9rentiel central qui vous permet de stocker toutes vos donn\u00e9es structur\u00e9es et non structur\u00e9es \u00e0 n'importe quelle \u00e9chelle. C'est un moyen rentable de stocker et de g\u00e9rer tous les types de donn\u00e9es, des donn\u00e9es brutes aux donn\u00e9es trait\u00e9es, et c'est un outil essentiel pour les scientifiques des donn\u00e9es.

    L\u2019un des principaux avantages d\u2019un lac de donn\u00e9es est sa flexibilit\u00e9. Il permet de stocker tous types de donn\u00e9es sans avoir besoin de d\u00e9finir un sch\u00e9ma au pr\u00e9alable, ce qui est particuli\u00e8rement utile lorsqu'il s'agit de donn\u00e9es non structur\u00e9es. Cette flexibilit\u00e9 permet aux scientifiques des donn\u00e9es d'explorer, d'exp\u00e9rimenter et d'extraire facilement des informations \u00e0 partir de leurs donn\u00e9es sans \u00eatre contraints par les limites d'une base de donn\u00e9es relationnelle traditionnelle.

    Les lacs de donn\u00e9es permettent \u00e9galement aux scientifiques des donn\u00e9es de centraliser leurs donn\u00e9es, facilitant ainsi la gestion et l'analyse de gros volumes de donn\u00e9es provenant de diverses sources. Avec un lac de donn\u00e9es, les scientifiques des donn\u00e9es peuvent facilement ing\u00e9rer et stocker des donn\u00e9es provenant de diverses sources, telles que des bases de donn\u00e9es, le stockage cloud et des API tierces. De plus, les lacs de donn\u00e9es fournissent souvent des fonctionnalit\u00e9s de gouvernance des donn\u00e9es, de gestion des m\u00e9tadonn\u00e9es et de contr\u00f4le d'acc\u00e8s, ce qui permet de garantir que les donn\u00e9es sont de haute qualit\u00e9 et conformes aux r\u00e9glementations en vigueur.

    De plus, les lacs de donn\u00e9es bas\u00e9s sur le cloud offrent des solutions de stockage \u00e9volutives et rentables qui peuvent \u00eatre facilement \u00e9tendues d'un simple clic. \u00c0 mesure que les besoins de stockage des donn\u00e9es des scientifiques des donn\u00e9es augmentent, ils peuvent ajouter une capacit\u00e9 de stockage suppl\u00e9mentaire \u00e0 leur lac de donn\u00e9es avec un minimum d'effort, sans se soucier de l'infrastructure ou de la maintenance sous-jacente.

    Dans l'ensemble, les lacs de donn\u00e9es sont un outil essentiel pour les scientifiques des donn\u00e9es, car ils offrent la flexibilit\u00e9, l'\u00e9volutivit\u00e9 et la facilit\u00e9 d'utilisation n\u00e9cessaires pour stocker et g\u00e9rer de grands volumes de donn\u00e9es, permettant aux data scientists de se concentrer sur l'extraction d'informations et de valeur \u00e0 partir des donn\u00e9es.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html","title":"Formation de mod\u00e8les d'apprentissage automatique sur l'ETAA","text":"

    Info

    La formation de mod\u00e8les d'apprentissage automatique implique l'utilisation d'algorithmes pour apprendre des mod\u00e8les et des relations dans les donn\u00e9es. Ce processus implique d'identifier les caract\u00e9ristiques ou les variables pertinentes pour le probl\u00e8me en question et d'utiliser ces caract\u00e9ristiques pour effectuer des pr\u00e9dictions ou des classifications.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#pourquoi-sentrainer-avec-nous","title":"Pourquoi s'entra\u00eener avec nous ?","text":"

    La formation de mod\u00e8les d'apprentissage automatique sur Advanced Analytics Workspace (AAW) pr\u00e9sente plusieurs avantages.

    1. Code Logiciel Ouvert\u00a0: L'ETAA est une plate-forme de donn\u00e9es open source h\u00e9berg\u00e9e par Statistique Canada qui offre un acc\u00e8s s\u00e9curis\u00e9 (Prot\u00e9g\u00e9 B) \u00e0 une vari\u00e9t\u00e9 de sources de donn\u00e9es, y compris les donn\u00e9es de recensement, les enqu\u00eates et les dossiers administratifs. Ces donn\u00e9es peuvent \u00eatre utilis\u00e9es pour former des mod\u00e8les d'apprentissage automatique et g\u00e9n\u00e9rer des informations susceptibles d'\u00e9clairer les d\u00e9cisions politiques et d'am\u00e9liorer les processus m\u00e9tier.

    2. Polyvalent\u00a0: L'ETAA est con\u00e7u pour g\u00e9rer des ensembles de donn\u00e9es volumineux et complexes. Il donne acc\u00e8s \u00e0 une gamme d'outils d'analyse avanc\u00e9s, dans le langage de votre choix, notamment Python, R et SAS, qui peuvent \u00eatre utilis\u00e9s pour pr\u00e9traiter les donn\u00e9es, former des mod\u00e8les d'apprentissage automatique et g\u00e9n\u00e9rer des visualisations. \u00c9tant donn\u00e9 que l'ETAA exploite les technologies cloud, les utilisateurs peuvent augmenter leur puissance de calcul selon leurs besoins*. *

    3. S\u00e9curis\u00e9\u00a0: L'ETAA est une plateforme s\u00e9curis\u00e9e (Prot\u00e9g\u00e9e B) qui adh\u00e8re aux normes les plus \u00e9lev\u00e9es en mati\u00e8re de confidentialit\u00e9 et de s\u00e9curit\u00e9 des donn\u00e9es. Les donn\u00e9es peuvent \u00eatre stock\u00e9es et trait\u00e9es sur la plateforme sans risque d'acc\u00e8s non autoris\u00e9 ou de violation de donn\u00e9es.
    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#mlops-et-pipelines-de-donnees","title":"MLOps et pipelines de donn\u00e9es","text":"

    Optimiser les flux de donn\u00e9es

    Les MLOps et les pipelines de donn\u00e9es sont des outils importants utilis\u00e9s dans le domaine de la science des donn\u00e9es pour g\u00e9rer et optimiser les flux de travail de donn\u00e9es.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#mlops","title":"MLOps","text":"

    MLOps fait r\u00e9f\u00e9rence \u00e0 l'ensemble de pratiques et d'outils utilis\u00e9s pour g\u00e9rer l'ensemble du cycle de vie d'un mod\u00e8le d'apprentissage automatique. Cela comprend tout, depuis le d\u00e9veloppement et la formation du mod\u00e8le jusqu'\u00e0 son d\u00e9ploiement en production et sa maintenance au fil du temps. MLOps garantit que les mod\u00e8les d'apprentissage automatique sont fiables, pr\u00e9cis et \u00e9volutifs, et qu'ils peuvent \u00eatre mis \u00e0 jour et am\u00e9lior\u00e9s selon les besoins.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#pipelines-de-donnees","title":"Pipelines de donn\u00e9es","text":"

    Les pipelines de donn\u00e9es sont une s\u00e9rie d'\u00e9tapes qui permettent de d\u00e9placer les donn\u00e9es d'un syst\u00e8me ou d'une application \u00e0 un autre. Cela inclut la collecte, le nettoyage, la transformation et le stockage des donn\u00e9es, ainsi que leur r\u00e9cup\u00e9ration en cas de besoin. Les pipelines de donn\u00e9es sont importants pour garantir que les donn\u00e9es sont exactes, fiables et accessibles \u00e0 ceux qui en ont besoin.

    Automatisation et fiabilit\u00e9

    Les MLOps et les pipelines de donn\u00e9es aident les organisations \u00e0 g\u00e9rer le processus complexe consistant \u00e0 travailler avec de grandes quantit\u00e9s de donn\u00e9es et \u00e0 d\u00e9velopper des mod\u00e8les d'apprentissage automatique. En automatisant ces processus et en garantissant que les donn\u00e9es sont exactes et fiables, les organisations peuvent \u00e9conomiser du temps et des ressources tout en prenant de meilleures d\u00e9cisions bas\u00e9es sur des informations bas\u00e9es sur les donn\u00e9es.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#pourquoi-des-mlops-conteneurises","title":"Pourquoi des MLOps conteneuris\u00e9s\u00a0?","text":"

    Les avantages de l'utilisation d'une approche conteneuris\u00e9e pour la formation de mod\u00e8les d'apprentissage automatique avec flux de travail Argo incluent\u00a0:

    1. Reproductibilit\u00e9\u00a0: La conteneurisation du mod\u00e8le d'apprentissage automatique et de ses d\u00e9pendances garantit que l'environnement reste coh\u00e9rent d'une ex\u00e9cution \u00e0 l'autre, ce qui facilite la reproduction des r\u00e9sultats.

    2. \u00c9volutivit\u00e9\u00a0: Les flux de travail Argo peut orchestrer des t\u00e2ches parall\u00e8les et des flux de travail complexes, ce qui facilite l'\u00e9volution du processus de formation selon les besoins.

    3. Portabilit\u00e9\u00a0: Les conteneurs peuvent \u00eatre ex\u00e9cut\u00e9s sur n'importe quelle plate-forme prenant en charge la conteneurisation, ce qui facilite le d\u00e9placement du processus de formation vers diff\u00e9rents environnements ou fournisseurs de cloud.

    4. Collaboration\u00a0: En transf\u00e9rant le conteneur vers un registre de conteneurs, d'autres utilisateurs peuvent facilement t\u00e9l\u00e9charger et utiliser le conteneur \u00e0 leurs propres fins, ce qui facilite la collaboration sur des projets d'apprentissage automatique.

    Lesflux de travail Argo et la conteneurisation offrent une approche puissante et flexible pour la formation de mod\u00e8les d'apprentissage automatique. En tirant parti de ces outils, les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique peuvent cr\u00e9er, d\u00e9ployer et g\u00e9rer des flux de travail d'apprentissage automatique avec facilit\u00e9 et reproductibilit\u00e9.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#comment-former-des-modeles","title":"Comment former des mod\u00e8les","text":"

    Il existe de nombreuses fa\u00e7ons de former des mod\u00e8les d\u2019apprentissage automatique et ce n\u2019est pas \u00e0 nous de dire \u00e0 qui que ce soit comment proc\u00e9der. Cela \u00e9tant dit, nous avons fourni ci-dessous quelques guides sur la fa\u00e7on de former des mod\u00e8les d'apprentissage automatique \u00e0 l'aide des outils disponibles sur l'ETAA. Le premier tutoriel concerne la formation d'un mod\u00e8le simple directement dans un bloc-note JupyterLab. Le deuxi\u00e8me didacticiel suppose que l'utilisateur est plus avanc\u00e9 et souhaite d\u00e9finir un pipeline MLOps pour la formation de mod\u00e8les \u00e0 l'aide des flux de travail Argo.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#creer-un-serveur-de-bloc-note-sur-letaa","title":"Cr\u00e9er un serveur de bloc-note sur l'ETAA","text":"

    Serveurs bloc-notes

    Que vous envisagiez de travailler dans JupyterLab, R Studio ou quelque chose de plus avanc\u00e9 avec les flux de travail Argo, vous aurez besoin du serveur bloc-notes appropri\u00e9. Suivez les instructions trouv\u00e9es ici pour commencer.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#utiliser-jupyterlab","title":"Utiliser JupyterLab","text":"

    JupyterLab est populaire

    La formation de mod\u00e8les d'apprentissage automatique avec JupyterLab est une approche populaire parmi les scientifiques des donn\u00e9es et les ing\u00e9nieurs en apprentissage automatique.

    Vous trouverez ici les \u00e9tapes n\u00e9cessaires pour entra\u00eener un mod\u00e8le d'apprentissage automatique avec JupyterLab sur AAW. 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.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#1-importez-les-bibliotheques-requises","title":"1. Importez les biblioth\u00e8ques requises","text":"

    Une fois qu'une session JupyterLab est en cours d'ex\u00e9cution, vous devez importer les biblioth\u00e8ques requises pour votre mod\u00e8le d'apprentissage automatique. Cela pourrait inclure des biblioth\u00e8ques telles que NumPy, Pandas, Scikit-learn, Tensorflow ou PyTorch. Si vous utilisez R, vous aurez besoin de tidyverse, caret et janitor.

    PythonRSASPySAS libraries.py
    #!/usr/bin/env python\n\n# tensorflow et keras pour la cr\u00e9ation et la formation de mod\u00e8les d'apprentissage profond\nimport tensorflow as tf\nfrom tensorflow import keras\n\n# numpy pour les calculs num\u00e9riques\nimport numpy as np\n\n# pandas pour la manipulation et l'analyse des donn\u00e9es\nimport pandas as pd\n\n# matplotlib pour la visualisation de donn\u00e9es \nimport matplotlib.pyplot as plt\n
    libraries.R
    #!/usr/bin/env Rscript\n\n# tidyverse pour des outils impressionnants d'analyse de donn\u00e9es et de munging\nlibrary(tidyverse)\n\n# janitor pour nettoyer vos donn\u00e9es\nlibrary(janitor)\n\n# caret pour un apprentissage automatique facile\nlibrary(caret)\n
    libraries.py
    #!/usr/bin/env python\n\n# la seule biblioth\u00e8que dont vous aurez besoin pour acc\u00e9der \u00e0 SAS depuis Python\nimport saspy\n
    libraries.sas
    \n

    \u00c0 propos du code

    Les exemples de code que vous voyez dans ce document et dans toute la documentation sont fournis \u00e0 des fins d'illustration pour vous aider \u00e0 d\u00e9marrer vos projets. En fonction de la t\u00e2che ou du projet sp\u00e9cifique, d'autres biblioth\u00e8ques et \u00e9tapes peuvent \u00eatre n\u00e9cessaires.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#2-charger-et-pretraiter-les-donnees","title":"2. Charger et pr\u00e9traiter les donn\u00e9es","text":"

    Ensuite, vous devez charger et pr\u00e9traiter les donn\u00e9es que vous utiliserez pour entra\u00eener votre mod\u00e8le d'apprentissage automatique. Cela pourrait inclure le nettoyage des donn\u00e9es, l\u2019extraction de fonctionnalit\u00e9s et la normalisation. Les \u00e9tapes exactes de pr\u00e9traitement que vous devrez effectuer d\u00e9pendront de l'ensemble de donn\u00e9es sp\u00e9cifique avec lequel vous travaillez, des exigences de votre mod\u00e8le d'apprentissage automatique et du travail \u00e0 effectuer.

    PythonRSASPySAS load_data.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport pandas as pd\nfrom sklearn.preprocessing import StandardScaler\n\n# Charger des donn\u00e9es \u00e0 partir d'un fichier CSV\ndata = pd.read_csv('data.csv')\n\n# Nettoyage des donn\u00e9es\u00a0! On peut faire beaucoup plus, c'est fondamental\ndata = data.dropna()  # Drop rows with missing values\ndata = data.drop_duplicates()  # Drop duplicate rows\n\n# Extraction de caract\u00e9ristiques\nX = data[['feature1', 'feature2', 'feature3']]  # Select relevant features\n\n# Normalisation\nscaler = StandardScaler()  # Create a scaler object\nX_norm = scaler.fit_transform(X)  # Normalize the feature values\n
    load_data.R
    #!/usr/bin/env Rscript\n\n# Importer les packages n\u00e9cessaires\nlibrary(tidyverse)\nlibrary(janitor)\n\n# Charger des donn\u00e9es \u00e0 partir d'un fichier CSV\ndata <- read_csv(\"data.csv\")\n\n# Nettoyer les donn\u00e9es en utilisant janitor\ndata_cleaned <- data %>%\n\n# Supprimer les espaces de d\u00e9but/fin dans les noms de colonnes\nclean_names() %>%\n\n# Supprimer les lignes avec des valeurs manquantes\nremove_empty() %>%\n\n# Convertir la colonne de date au format Date\nmutate(date = as.Date(date, format = \"%m/%d/%Y\")) %>%\n\n# Supprimer les lignes en double\ndistinct() %>%\n\n# R\u00e9organiser les colonnes\nselect(date, column2, column1, column3)\n
    load_data.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport saspy\n\n# D\u00e9marrez une session SAS et v\u00e9rifiez les informations de configuration\nsas = saspy.SASsession(cfgname='default')\n\n# Charger des donn\u00e9es \u00e0 partir d'un fichier CSV\ndata = sas.read_csv(\"./data.csv\")\n
    load_data.sas
    /* Lecture d'un fichier d\u00e9limit\u00e9 par des virgules avec une extension .csv */\n /* */\n /* Puisque la valeur DBMS= est CSV, vous n'avez pas besoin d'utiliser DELIMITER= */\n /* d\u00e9claration. Par d\u00e9faut, on suppose que les noms des variables sont en premier */\n /* ligne, donc l'instruction GETNAMES= n'est pas requise. */\n /* */\n /* Cr\u00e9ez un fichier de test d\u00e9limit\u00e9 par des virgules \u00e0 lire en utilisant PROC IMPORT ci-dessous. */\n\n /* Charger les donn\u00e9es depuis un fichier CSV */\nproc import\n    datafile='data.csv'\n    out=data\n    dbms=csv\n    replace; \nrun;\n\n/* Afficher les donn\u00e9es */\nproc print;\nrun;\n
    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#3-divisez-les-donnees-en-ensembles-de-formation-et-de-test","title":"3. Divisez les donn\u00e9es en ensembles de formation et de test","text":"

    Une fois les donn\u00e9es pr\u00e9trait\u00e9es, vous devez les diviser en ensembles de formation et de test. L'ensemble de formation sera utilis\u00e9 pour entra\u00eener le mod\u00e8le d'apprentissage automatique, tandis que l'ensemble de test sera utilis\u00e9 pour \u00e9valuer ses performances.

    PythonRSASPySAS train_test.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(X_norm,\ndata['target'], test_size=0.2, random_state=42)\n
    train_test.R
    #!/usr/bin/env Rscript\n\n# Importer les packages n\u00e9cessaires\nlibrary(caret)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv(\"my-dataset.csv\")\n\n# D\u00e9finir la graine pour la reproductibilit\u00e9\nset.seed(123)\n\n# Divisez l'ensemble de donn\u00e9es en train et test \u00e0 l'aide de la fonction createDataPartition de Caret\ntrain_index <- createDataPartition(data$target_variable, p = 0.7, list = FALSE)\ntrain_data <- data[train_index, ]\ntest_data <- data[-train_index, ]\n
    train_test.py
    #!/usr/bin/env python\n
    train_test.sas
    \n

    Note

    Nous divisons les donn\u00e9es en ensembles d'entra\u00eenement et de test \u00e0 l'aide de la fonction train_test_split de scikit-learn, qui divise al\u00e9atoirement les donn\u00e9es en deux ensembles en fonction de la taille de test sp\u00e9cifi\u00e9e et de la graine al\u00e9atoire.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#4-definir-et-entrainer-le-modele-dapprentissage-automatique","title":"4. D\u00e9finir et entra\u00eener le mod\u00e8le d'apprentissage automatique","text":"

    Avec la r\u00e9partition des donn\u00e9es, vous pouvez d\u00e9sormais d\u00e9finir et entra\u00eener votre mod\u00e8le d'apprentissage automatique \u00e0 l'aide de l'ensemble de formation. Cela pourrait impliquer la s\u00e9lection de l\u2019algorithme appropri\u00e9, le r\u00e9glage des hyperparam\u00e8tres et la validation crois\u00e9e.

    PythonRSASPySAS train.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.model_selection import train_test_split\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv(\"my-dataset.csv\")\n\n# Divisez l'ensemble de donn\u00e9es en entra\u00eenement et test\nX_train, X_test, y_train, y_test = train_test_split(data.iloc[:, :-1], data.iloc[:, -1], test_size=0.3, random_state=123)\n\n# Entra\u00eener le mod\u00e8le\nmodel = RandomForestClassifier(n_estimators=100, random_state=123)\nmodel.fit(X_train, y_train)\n\n# Imprimer le score de pr\u00e9cision sur les donn\u00e9es de test\nprint(\"Accuracy on test set: {:.3f}\".format(model.score(X_test, y_test)))\n
    train.R
    #!/usr/bin/env Rscript\n\n# Importer les packages n\u00e9cessaires\nlibrary(caret)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv(\"my-dataset.csv\")\n\n# D\u00e9finir la graine pour la reproductibilit\u00e9\nset.seed(123)\n\n# Divisez l'ensemble de donn\u00e9es en train et test \u00e0 l'aide de la fonction curseur createDataPartition\ntrain_index <- createDataPartition(data$target_variable, p = 0.7, list = FALSE)\ntrain_data <- data[train_index, ]\ntest_data <- data[-train_index, ]\n\n# D\u00e9finir le contr\u00f4le de la formation\ntrain_control <- trainControl(method = \"cv\", number = 5)\n\n# Entra\u00eenez le mod\u00e8le \u00e0 l'aide de la fonction d'entra\u00eenement de Caret (la m\u00e9thode = \"rf\" est pour la for\u00eat al\u00e9atoire)\nmodel <- train(target_variable ~ ., data = train_data, method = \"rf\", trControl = train_control)\n\n# Imprimez l'objet mod\u00e8le pour afficher les r\u00e9sultats\nprint(model)\n
    train.py
    #!/usr/bin/env python\n\n# Importer les packages n\u00e9cessaires\nimport saspy\nimport pandas as pd\n\n# \u00c9tablir une connexion \u00e0 une session SAS\nsas = saspy.SASsession()\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv(\"my-dataset.csv\")\n\n# T\u00e9l\u00e9chargez l'ensemble de donn\u00e9es sur SAS\nsas_df = sas.df2sd(data, \"mydata\")\n\n# Divisez l'ensemble de donn\u00e9es en train et test\ntrain, test = sas.surveyselect(data=sas_df,\n                            method=\"SRS\",\n                            seed=123,\n                            samprate=0.7,\n                            outall=True,\n                            strata=\"target_variable\",\n                            partind=True)\n\n# Entra\u00eener le mod\u00e8le \u00e0 l'aide de la proc\u00e9dure HPFOREST\nmodel = sas.hpforest(data=train,\n                    target=\"target_variable\",\n                    input=\"input_variable_1-input_variable_n\",\n                    partition=\"rolevar\",\n                    rolevars={\"test\": \"0\", \"train\": \"1\"},\n                    nominals=[\"input_variable_1-input_variable_n\"],\n                    forestopts={\"ntree\": 100, \"seed\": 123})\n\n# Noter le mod\u00e8le sur les donn\u00e9es de test\npredictions = model.predict(newdata=test, out=pred_out)\n\n# Calculer le score de pr\u00e9cision sur les donn\u00e9es de test\naccuracy = sas.freq(data=predictions, tables=\"target_variable*p_target_variable\", nocum=True, nocol=True)\n\n# Imprimer le score de pr\u00e9cision\nprint(\"Accuracy on test set: {:.3f}\".format(accuracy.Frequency.iloc[0, 1] / accuracy.Frequency.iloc[:, 1].sum()))\n\n# Se d\u00e9connecter de la session SAS\nsas.disconnect()\n

    ``` sas title=\"train.sas\" linenums=\"1\" / Charger l'ensemble de donn\u00e9es / proc import datafile=\"my-dataset.csv\" out=mydata dbms=csv replace; run;

    / Diviser l'ensemble de donn\u00e9es en train et test / proc surveyselect data=mydata method=srs seed=123 out=selected outall samprate=0.7; strata target_variable; run;

    /* Entra\u00eener le mod\u00e8le */\nproc hpforest data=selected;\nclass _all_;\ntarget target_variable / level=nominal;\npartition rolevar=target_variable(test=\"0\" train=\"1\");\ninput _all_;\nforest ntree=100 seed=123;\nrun;\n\n/* Noter le mod\u00e8le sur les donn\u00e9es de test */\nproc hpforest predict testdata=selected out=testout;\nrun;\n\n/* Imprimer le score de pr\u00e9cision sur les donn\u00e9es du test */\nproc freq data=testout;\ntables target_variable*p_target_variable / nocum nocol;\nrun;\n```\n
    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#5-evaluer-le-modele","title":"5. \u00c9valuer le mod\u00e8le","text":"

    Apr\u00e8s avoir entra\u00een\u00e9 le mod\u00e8le, vous devez \u00e9valuer ses performances sur l\u2019ensemble de tests. Cela vous donnera une id\u00e9e des performances du mod\u00e8le sur de nouvelles donn\u00e9es invisibles.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#6-deployer-le-modele","title":"6. D\u00e9ployer le mod\u00e8le","text":"

    Enfin, vous pouvez d\u00e9ployer le mod\u00e8le d'apprentissage automatique form\u00e9 dans un environnement de production.

    "},{"location":"7-MLOps/Modele-Ml-entrainement.html#utiliser-les-flux-de-travail-argo","title":"Utiliser les flux de travail Argo","text":"

    Meilleures pratiques MLOps

    Les flux de travail Argo sont un excellent outil pour tous ceux qui cherchent \u00e0 mettre en \u0153uvre des pratiques MLOps et \u00e0 rationaliser le processus de formation et de d\u00e9ploiement de mod\u00e8les d'apprentissage automatique ou d'autres t\u00e2ches de science des donn\u00e9es telles que ETL.

    Flux de travail Argo est un moteur de flux de travail open source natif pour conteneurs permettant d'orchestrer des t\u00e2ches parall\u00e8les sur Kubernetes. Les flux de travail Argo sont impl\u00e9ment\u00e9s en tant que Kubernetes CRD (Custom Resource Definition). Il est particuli\u00e8rement adapt\u00e9 aux flux de travail d\u2019apprentissage automatique et de science des donn\u00e9es.

    Les flux de travail Argo vous permettent de

    • D\u00e9finir des flux de travail o\u00f9 chaque \u00e9tape du flux est un conteneur.
    • Mod\u00e9lisez des flux de travail en plusieurs \u00e9tapes sous la forme d'une s\u00e9quence de t\u00e2ches ou capturez les d\u00e9pendances entre les t\u00e2ches \u00e0 l'aide d'un graphe acyclique dirig\u00e9 (DAG).
    • Ex\u00e9cutez facilement des t\u00e2ches de calcul intensives pour l'apprentissage automatique ou le traitement des donn\u00e9es en une fraction du temps \u00e0 l'aide de flux de travail Argo sur Kubernetes.
    • Ex\u00e9cutez des pipelines CI/CD de mani\u00e8re native sur Kubernetes sans configurer de produits de d\u00e9veloppement logiciel complexes.

    ce qui facilite la gestion de l'ensemble du pipeline d'apprentissage automatique de bout en bout. Avec les flux de travail Argo, vous pouvez facilement cr\u00e9er des flux de travail qui int\u00e8grent des t\u00e2ches telles que le pr\u00e9traitement des donn\u00e9es, la formation de mod\u00e8les et le d\u00e9ploiement de mod\u00e8les, le tout dans un environnement Kubernetes.

    Voir la section flux de travail argo pour plus de d\u00e9tails.

    "},{"location":"7-MLOps/Modele-Service-ML.html","title":"Introduction \u00e0 la diffusion de mod\u00e8les","text":"

    Dans le contexte des gouvernements, servir des mod\u00e8les d\u2019apprentissage automatique signifie rendre les mod\u00e8les form\u00e9s disponibles pour \u00eatre utilis\u00e9s par d\u2019autres applications et syst\u00e8mes. Cela pourrait inclure la r\u00e9alisation de pr\u00e9dictions ou de classifications bas\u00e9es sur les donn\u00e9es d'entr\u00e9e, ou la fourniture d'informations et de recommandations bas\u00e9es sur les r\u00e9sultats de l'analyse des donn\u00e9es.

    La mise en \u0153uvre de mod\u00e8les d'apprentissage automatique dans un contexte gouvernemental soul\u00e8ve des probl\u00e8mes importants li\u00e9s \u00e0 la confidentialit\u00e9 des donn\u00e9es. Les agences gouvernementales sont souvent charg\u00e9es de collecter et de g\u00e9rer des donn\u00e9es personnelles sensibles, telles que les dossiers m\u00e9dicaux, les donn\u00e9es financi\u00e8res et les casiers judiciaires. Lorsque vous servez des mod\u00e8les d'apprentissage automatique, il est essentiel de garantir que ces donn\u00e9es sont prot\u00e9g\u00e9es et que leur acc\u00e8s est strictement contr\u00f4l\u00e9.

    Pour r\u00e9pondre \u00e0 ces pr\u00e9occupations, les agences gouvernementales doivent mettre en \u0153uvre des mesures robustes de confidentialit\u00e9 et de s\u00e9curit\u00e9 des donn\u00e9es lorsqu'elles servent des mod\u00e8les d'apprentissage automatique. Cela pourrait inclure le chiffrement des donn\u00e9es au repos et en transit, la mise en \u0153uvre de contr\u00f4les d'acc\u00e8s et d'authentification des utilisateurs, ainsi qu'une surveillance r\u00e9guli\u00e8re des violations de donn\u00e9es et des vuln\u00e9rabilit\u00e9s.

    Outre la confidentialit\u00e9 et la s\u00e9curit\u00e9 des donn\u00e9es, il est \u00e9galement important de prendre en compte les implications \u00e9thiques de la mise en \u0153uvre de mod\u00e8les d'apprentissage automatique dans un contexte gouvernemental. Les mod\u00e8les d\u2019apprentissage automatique peuvent \u00eatre biais\u00e9s ou discriminatoires, conduisant \u00e0 un traitement injuste de certains groupes de personnes. Pour att\u00e9nuer ces risques, les agences gouvernementales doivent \u00e9valuer et surveiller soigneusement leurs mod\u00e8les d'apprentissage automatique et prendre des mesures pour rem\u00e9dier \u00e0 tout pr\u00e9jug\u00e9 ou discrimination qui pourrait survenir.

    Dans l\u2019ensemble, la mise en \u0153uvre de mod\u00e8les d\u2019apprentissage automatique dans un contexte gouvernemental n\u00e9cessite un examen attentif de la confidentialit\u00e9 des donn\u00e9es, de la s\u00e9curit\u00e9 et des pr\u00e9occupations \u00e9thiques. En mettant en \u0153uvre des mesures robustes pour prot\u00e9ger les donn\u00e9es personnelles et pr\u00e9venir les pr\u00e9jug\u00e9s, les agences gouvernementales peuvent tirer parti de la puissance de l'apprentissage automatique pour prendre de meilleures d\u00e9cisions et am\u00e9liorer les r\u00e9sultats pour les citoyens tout en pr\u00e9servant la confiance et la transparence.

    "},{"location":"7-MLOps/Modele-Service-ML.html#pourquoi-servir-avec-nous","title":"Pourquoi servir avec nous ?","text":"

    Servir des mod\u00e8les d'apprentissage automatique avec l'Espace de travail d'analyse avanc\u00e9e (ETAA) pr\u00e9sente plusieurs avantages. Premi\u00e8rement, ETAA est une plate-forme d'analyse de donn\u00e9es open source qui donne acc\u00e8s \u00e0 une vari\u00e9t\u00e9 d'outils d'analyse avanc\u00e9s, notamment Python, R et SAS. Cela facilite le d\u00e9ploiement de mod\u00e8les d'apprentissage automatique et leur int\u00e9gration dans les flux de travail existants.

    Deuxi\u00e8mement, l'ETAA prend en charge plusieurs frameworks MLOps, notamment les workflows Couler, Seldon et Argo. Ces frameworks fournissent une gamme de fonctionnalit\u00e9s, notamment la gestion des versions de mod\u00e8les, la diffusion de mod\u00e8les et la surveillance de mod\u00e8les, qui simplifient le processus de d\u00e9ploiement et de gestion des mod\u00e8les d'apprentissage automatique en production.

    Troisi\u00e8mement, l'ETAA fournit une plate-forme s\u00e9curis\u00e9e et \u00e9volutive pour servir des mod\u00e8les d'apprentissage automatique avec le statut Prot\u00e9g\u00e9 B. Les mod\u00e8les peuvent \u00eatre servis \u00e0 l'aide d'environnements conteneuris\u00e9s, tels que Docker, qui offrent un haut niveau d'isolation et de s\u00e9curit\u00e9. L'ETAA donne \u00e9galement acc\u00e8s aux ressources de cloud computing, permettant aux utilisateurs d'augmenter leur puissance de calcul selon leurs besoins pour g\u00e9rer des volumes \u00e9lev\u00e9s de requ\u00eates.

    Enfin, l'ETAA est une plateforme collaborative qui permet aux utilisateurs de partager du code et des donn\u00e9es avec d'autres chercheurs et analystes. Cela favorise une communaut\u00e9 d'utilisateurs qui peuvent apprendre du travail de chacun et collaborer sur des projets n\u00e9cessitant des capacit\u00e9s d'analyse avanc\u00e9es.

    En r\u00e9sum\u00e9, servir des mod\u00e8les d'apprentissage automatique avec Advanced Analytics Workspace donne acc\u00e8s \u00e0 des outils d'analyse avanc\u00e9s, \u00e0 plusieurs frameworks MLOps, \u00e0 une plate-forme Proteced B s\u00e9curis\u00e9e et \u00e9volutive et \u00e0 une communaut\u00e9 collaborative d'utilisateurs, ce qui en fait une plate-forme id\u00e9ale pour les scientifiques et les analystes de donn\u00e9es qui souhaitent pour d\u00e9ployer et g\u00e9rer des mod\u00e8les d\u2019apprentissage automatique en production.

    "},{"location":"7-MLOps/Modele-Service-ML.html#noyau-seldon","title":"Noyau Seldon","text":"

    Seldon Core est une plate-forme open source permettant de d\u00e9ployer, de mettre \u00e0 l'\u00e9chelle et de surveiller des mod\u00e8les d'apprentissage automatique sur Kubernetes. Il fournit un moyen simple et efficace de d\u00e9ployer des mod\u00e8les d'apprentissage automatique sous forme de microservices dans un environnement de production.

    La diffusion de mod\u00e8les d'apprentissage automatique \u00e0 l'aide de Seldon Core implique les \u00e9tapes suivantes\u00a0:

    1. Conditionnement du mod\u00e8le\u00a0: la premi\u00e8re \u00e9tape consiste \u00e0 empaqueter le mod\u00e8le d'apprentissage automatique form\u00e9 dans une image de conteneur avec toutes les d\u00e9pendances requises. Seldon Core prend en charge divers frameworks d'apprentissage automatique, notamment TensorFlow, PyTorch et Scikit-learn.

    2. D\u00e9ploiement du mod\u00e8le\u00a0: une fois l'image du conteneur cr\u00e9\u00e9e, l'\u00e9tape suivante consiste \u00e0 d\u00e9ployer le mod\u00e8le sur Kubernetes \u00e0 l'aide de Seldon Core. Cela implique de d\u00e9finir le fichier de configuration de d\u00e9ploiement, qui sp\u00e9cifie les ressources requises pour le d\u00e9ploiement, telles que le nombre de r\u00e9plicas et les ressources de calcul.

    3. Service de mod\u00e8le\u00a0: une fois le mod\u00e8le d\u00e9ploy\u00e9, Seldon Core expose un point de terminaison d'API REST qui peut \u00eatre utilis\u00e9 pour effectuer des pr\u00e9dictions. Les clients peuvent envoyer des requ\u00eates au point de terminaison avec des donn\u00e9es d'entr\u00e9e, et le mod\u00e8le renverra la sortie correspondante. Seldon Core prend \u00e9galement en charge divers mod\u00e8les de d\u00e9ploiement, tels que le d\u00e9ploiement Canary et les tests A/B, pour permettre une exp\u00e9rimentation et un test faciles de diff\u00e9rents mod\u00e8les.

    4. Surveillance des mod\u00e8les : Seldon Core fournit diverses capacit\u00e9s de surveillance pour suivre les performances des mod\u00e8les d\u00e9ploy\u00e9s. Cela inclut la surveillance en temps r\u00e9el des m\u00e9triques du mod\u00e8le, telles que la latence et le d\u00e9bit, ainsi que la journalisation des donn\u00e9es de requ\u00eate et de r\u00e9ponse \u00e0 des fins de d\u00e9bogage.

    Seldon Core facilite la mise en \u0153uvre de mod\u00e8les d'apprentissage automatique \u00e0 grande \u00e9chelle, avec la prise en charge de la haute disponibilit\u00e9, de l'\u00e9volutivit\u00e9 et de la tol\u00e9rance aux pannes. Il fournit \u00e9galement une int\u00e9gration avec divers outils natifs de Kubernetes, tels que Istio et Prometheus, pour permettre une surveillance et une observabilit\u00e9 avanc\u00e9es.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html","title":"Mod\u00e8les d'apprentissage automatique","text":"

    Les mod\u00e8les d'apprentissage automatique sont des algorithmes informatiques con\u00e7us pour apprendre automatiquement des mod\u00e8les et des relations \u00e0 partir des donn\u00e9es. Ces mod\u00e8les sont form\u00e9s sur un ensemble de donn\u00e9es, qui est g\u00e9n\u00e9ralement une collection d'exemples ou d'instances, chacun \u00e9tant constitu\u00e9 d'un ensemble de fonctionnalit\u00e9s ou de variables, ainsi que d'une variable ou d'une sortie cible.

    L\u2019objectif d\u2019un mod\u00e8le d\u2019apprentissage automatique est d\u2019identifier des mod\u00e8les et des relations au sein des donn\u00e9es qui peuvent \u00eatre utilis\u00e9s pour faire des pr\u00e9dictions ou prendre des d\u00e9cisions concernant de nouvelles donn\u00e9es invisibles. Cela implique de d\u00e9velopper une repr\u00e9sentation math\u00e9matique de la relation entre les caract\u00e9ristiques d'entr\u00e9e et la variable de sortie, bas\u00e9e sur les mod\u00e8les observ\u00e9s dans les donn\u00e9es d'entra\u00eenement. Une fois le mod\u00e8le entra\u00een\u00e9, il peut \u00eatre utilis\u00e9 pour faire des pr\u00e9dictions ou prendre des d\u00e9cisions sur de nouvelles donn\u00e9es invisibles.

    Il existe plusieurs types de mod\u00e8les d'apprentissage automatique, chacun \u00e9tant con\u00e7u pour r\u00e9soudre diff\u00e9rents types de probl\u00e8mes ou de donn\u00e9es. Certains des types de mod\u00e8les d\u2019apprentissage automatique les plus courants incluent\u00a0:

    1. Mod\u00e8les de r\u00e9gression\u00a0: Les mod\u00e8les de r\u00e9gression sont utilis\u00e9s pour pr\u00e9dire des valeurs num\u00e9riques continues, telles que les cours des actions ou les prix de l'immobilier.

    2. Mod\u00e8les de classification\u00a0: Les mod\u00e8les de classification sont utilis\u00e9s pour pr\u00e9dire des valeurs cat\u00e9gorielles discr\u00e8tes, par exemple si un client ach\u00e8tera un produit ou non.

    3. Mod\u00e8les de grappe : Les mod\u00e8les de grappe sont utilis\u00e9s pour identifier des groupes ou des clusters au sein d'un ensemble de donn\u00e9es en fonction des similitudes entre les instances.

    4. Mod\u00e8les de recommandation\u00a0: Les mod\u00e8les de recommandation sont utilis\u00e9s pour recommander des produits ou des services aux utilisateurs en fonction de leur comportement ou de leurs pr\u00e9f\u00e9rences pass\u00e9es.

    5. R\u00e9seaux de neurones\u00a0: Les r\u00e9seaux de neurones sont un type de mod\u00e8le d'apprentissage automatique con\u00e7u pour imiter la structure et le fonctionnement du cerveau humain. Ils sont couramment utilis\u00e9s dans les applications de reconnaissance d\u2019images, de reconnaissance vocale et de traitement du langage naturel.

    Les mod\u00e8les d'apprentissage automatique peuvent \u00eatre biais\u00e9s

    Les mod\u00e8les d'apprentissage automatique sont un outil puissant pour analyser et faire des pr\u00e9dictions sur les donn\u00e9es, et ils ont un large \u00e9ventail d'applications dans des domaines tels que la finance, la sant\u00e9, le marketing, etc. Cependant, il est important de noter que les mod\u00e8les d\u2019apprentissage automatique ne sont pas parfaits et peuvent parfois commettre des erreurs ou produire des r\u00e9sultats biais\u00e9s. Par cons\u00e9quent, il est important d\u2019\u00e9valuer et de tester soigneusement les mod\u00e8les d\u2019apprentissage automatique avant de les utiliser dans des applications r\u00e9elles.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemples","title":"Exemples","text":""},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#regression-lineaire","title":"R\u00e9gression lin\u00e9aire","text":"

    R\u00e9gression lin\u00e9aire

    \\[ \\hat{Y}_i = \\hat{\\beta}_0 + \\hat{\\beta}_1 X_i + \\hat{\\epsilon}_i \\]

    O\u00f9 \\(\\hat{Y}_i\\) d\u00e9signe le \\(i\\)i\u00e8me estimateur de la vraie valeur \\(Y\\) bas\u00e9 sur la \\(i\\)i\u00e8me \u00e9poque d'entra\u00eenement. Chaque \\(\\hat{\\beta}\\) est un param\u00e8tre \u00e0 apprendre. \\(\\hat{\\epsilon}_i\\) est la quantit\u00e9 de bruit autoris\u00e9e dans le mod\u00e8le et peut varier en fonction du num\u00e9ro d'\u00e9poque d'entra\u00eenement indiqu\u00e9 par \\(i\\). Chaque \\(X_i\\) repr\u00e9sente le \\(i\\)\u00e8me lot de donn\u00e9es d'entra\u00eenement.

    Dans les mod\u00e8les statistiques classiques comme la r\u00e9gression lin\u00e9aire, l\u2019objectif est de trouver une droite qui correspond le mieux aux donn\u00e9es, nous permettant ainsi de faire des pr\u00e9dictions sur de nouveaux points de donn\u00e9es.

    \u00c0 mesure que la complexit\u00e9 du probl\u00e8me augmente, des algorithmes plus sophistiqu\u00e9s sont n\u00e9cessaires, tels que des arbres de d\u00e9cision, des machines \u00e0 vecteurs de support et des for\u00eats al\u00e9atoires. Cependant, ces m\u00e9thodes ont leurs limites et peuvent ne pas \u00eatre en mesure de capturer des mod\u00e8les complexes dans de grands ensembles de donn\u00e9es.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code","title":"Exemple de code","text":"PythonR linear_regression.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.metrics import mean_squared_error\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Entra\u00eener le mod\u00e8le de r\u00e9gression lin\u00e9aire\nlinear_model = LinearRegression()\nlinear_model.fit(X_train, y_train)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred = linear_model.predict(X_test)\n\n# \u00c9valuer les performances du mod\u00e8le\nmse = mean_squared_error(y_test, y_pred)\nrmse = mse ** 0.5\nprint('Root Mean Squared Error:', rmse)\n
    linear_regression.r
    #!/usr/bin/env Rscript\n\n# D\u00e9finir une graine al\u00e9atoire pour la reproductibilit\u00e9\nset.seed(123)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\ntrain_data <- data[train_index,]\ntest_data <- data[-train_index,]\n\n# Entra\u00eener le mod\u00e8le de r\u00e9gression lin\u00e9aire\nlm_model <- lm(target_variable ~ ., data=train_data)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred <- predict(lm_model, newdata=test_data[,-which(names(test_data)=='target_variable')])\n\n# \u00c9valuer les performances du mod\u00e8le\nmse <- mean((y_pred - test_data$target_variable)^2)\nrmse <- sqrt(mse)\nprint(paste('Root Mean Squared Error:', rmse))\n
    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#machine-a-vecteurs-de-support-svm","title":"Machine \u00e0 vecteurs de support (SVM)","text":"

    SVM

    \\[ \\underset{\\mathbf{w},b,\\boldsymbol{\\xi}}{\\operatorname{minimiser}} \\hspace{0.2cm} \\frac{1}{2} ||\\mathbf{w}||^2 + C \\sum_{i=1}^{N} \\xi_i \\] \\[ \\text{o\u00f9} \\hspace{0.2cm} y_i(\\mathbf{w}^T\\mathbf{x}_i + b) \\geq 1-\\xi_i \\quad \\text{et} \\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\u00f9 \\(\\mathbf{w}\\) est le vecteur de poids, \\(b\\) est le terme de biais et \\(\\boldsymbol{\\xi}\\) est le vecteur variable de rel\u00e2chement. L'objectif est de minimiser la norme L2 du vecteur de poids \\(\\mathbf{w}\\), sous la contrainte que tous les exemples d'entra\u00eenement soient class\u00e9s correctement avec une marge d'au moins 1, plus une tol\u00e9rance pour certaines violations de marge contr\u00f4l\u00e9es par le param\u00e8tre de r\u00e9gularisation \\(C\\). La variable cible \\(y_i\\) prend les valeurs de 1 ou -1, repr\u00e9sentant les deux classes du probl\u00e8me de classification binaire, et \\(\\mathbf{x}_i\\) est le vecteur de caract\u00e9ristiques du \\(i\\)\u00e8me exemple de formation.

    Une machine \u00e0 vecteurs de support (SVM) est un algorithme d'apprentissage automatique supervis\u00e9 qui peut \u00eatre utilis\u00e9 pour la classification, la r\u00e9gression et la d\u00e9tection des valeurs aberrantes. Il s\u2019agit d\u2019un algorithme populaire dans le domaine de l\u2019apprentissage automatique, notamment pour r\u00e9soudre des probl\u00e8mes de classification.

    L'id\u00e9e de base derri\u00e8re SVM est de trouver un hyperplan qui s\u00e9pare au mieux les donn\u00e9es d'entr\u00e9e en diff\u00e9rentes classes. Dans un probl\u00e8me de classification \u00e0 deux classes, l'hyperplan est une ligne qui divise les points de donn\u00e9es d'une classe des points de donn\u00e9es de l'autre classe. SVM essaie de trouver l'hyperplan qui maximise la marge entre les deux classes, la marge \u00e9tant la distance entre l'hyperplan et les points de donn\u00e9es les plus proches de chaque classe.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code_1","title":"Exemple de code","text":"PythonR svm.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.svm import SVC\nfrom sklearn.metrics import accuracy_score\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Entra\u00eener le mod\u00e8le SVM\nsvm_model = SVC(kernel='linear', C=1.0, random_state=42)\nsvm_model.fit(X_train, y_train)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred = svm_model.predict(X_test)\n\n# \u00c9valuer les performances du mod\u00e8le\naccuracy = accuracy_score(y_test, y_pred)\nprint('Accuracy:', accuracy)\n
    svm.r
    #!/usr/bin/env Rscript\n\n# Charger les biblioth\u00e8ques requises\nlibrary(e1071)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nset.seed(123)\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\ntrain_data <- data[train_index,]\ntest_data <- data[-train_index,]\n\n# Entra\u00eener le mod\u00e8le SVM\nsvm_model <- svm(target_variable ~ ., data=train_data, kernel='linear', cost=1)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred <- predict(svm_model, newdata=test_data[,-which(names(test_data)=='target_variable')])\n\n# \u00c9valuer les performances du mod\u00e8le\naccuracy <- mean(y_pred == test_data$target_variable)\nprint(paste('Accuracy:', accuracy))\n
    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#foret-aleatoire","title":"For\u00eat al\u00e9atoire","text":"

    For\u00eat al\u00e9atoire

    \\[ \\hat{y} = \\frac{1}{T} \\sum_{t=1}^{T} f_t(\\mathbf{x}), \\]

    o\u00f9 \\(\\hat{y}\\) est la sortie pr\u00e9dite, \\(f_t(\\mathbf{x})\\) est la pr\u00e9diction du \\(t\\)\u00e8me arbre dans la for\u00eat pour l'entr\u00e9e \\(\\mathbf{x}\\) et $T $ est le nombre d'arbres dans la for\u00eat.

    Les for\u00eats al\u00e9atoires sont une m\u00e9thode d'apprentissage d'ensemble qui peut \u00eatre utilis\u00e9e pour des probl\u00e8mes de classification et de r\u00e9gression. Ils sont souvent utilis\u00e9s pour leur capacit\u00e9 \u00e0 g\u00e9rer des ensembles de donn\u00e9es d'am\u00e9lioration continue \u00e0 forte intensit\u00e9 variable et des relations non lin\u00e9aires entre les caract\u00e9ristiques et les cibles.

    Chaque arbre est form\u00e9 sur un sous-ensemble amorc\u00e9 des donn\u00e9es d'entra\u00eenement d'origine, et \u00e0 chaque division, un sous-ensemble al\u00e9atoire de fonctionnalit\u00e9s est pris en compte pour d\u00e9terminer la division. La pr\u00e9diction finale est obtenue en faisant la moyenne des pr\u00e9dictions de tous les arbres de la for\u00eat.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code_2","title":"Exemple de code","text":"PythonR random_forest.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.ensemble import RandomForestRegressor\nfrom sklearn.metrics import mean_squared_error\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Entra\u00eener le mod\u00e8le de for\u00eat al\u00e9atoire\nrf_model = RandomForestRegressor(n_estimators=100, random_state=42)\nrf_model.fit(X_train, y_train)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred = rf_model.predict(X_test)\n\n# \u00c9valuer les performances du mod\u00e8le\nmse = mean_squared_error(y_test, y_pred)\nrmse = mse ** 0.5\nprint('Root Mean Squared Error:', rmse)\n
    random_forest.r
    #!/usr/bin/env Rscript\n\n# Charger les biblioth\u00e8ques requises\nlibrary(randomForest)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- read.csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nset.seed(123)\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\ntrain_data <- data[train_index,]\ntest_data <- data[-train_index,]\n\n# Entra\u00eener le mod\u00e8le de for\u00eat al\u00e9atoire\nrf_model <- randomForest(target_variable ~ ., data=train_data, ntree=100, importance=TRUE)\n\n# Faire des pr\u00e9dictions sur l'ensemble de tests\ny_pred <- predict(rf_model, newdata=test_data[,-which(names(test_data)=='target_variable')])\n\n# \u00c9valuer les performances du mod\u00e8le\nmse <- mean((y_pred - test_data$target_variable)^2)\nrmse <- sqrt(mse)\nprint(paste('Root Mean Squared Error:', rmse))\n
    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#lapprentissage-en-profondeur","title":"L'apprentissage en profondeur","text":"

    L'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\u00f9 \\(\\mathbf{x}\\) est le vecteur d'entr\u00e9e, \\(\\mathbf{W}_i\\) et \\(\\mathbf{b}_i\\) sont respectivement la matrice de poids et le vecteur de biais pour la \\(i\\)\u00e8me couche, et $ f$ est la fonction d'activation.

    Cette formule repr\u00e9sente un r\u00e9seau neuronal \u00e0 action directe avec des couches \\(L\\), o\u00f9 chaque couche applique une transformation lin\u00e9aire \u00e0 la sortie de la couche pr\u00e9c\u00e9dente, suivie d'une fonction d'activation non lin\u00e9aire. La sortie de la couche finale, \\(\\hat{y}\\), repr\u00e9sente la sortie pr\u00e9vue du r\u00e9seau neuronal pour l'entr\u00e9e donn\u00e9e \\(\\mathbf{x}\\).

    L'apprentissage profond est un sous-ensemble de l'apprentissage automatique qui implique la formation de r\u00e9seaux de neurones comportant de nombreuses couches de n\u0153uds interconnect\u00e9s. Cette approche peut g\u00e9rer des ensembles de donn\u00e9es volumineux et complexes et est utilis\u00e9e dans un large \u00e9ventail d'applications, notamment la reconnaissance d'images, le traitement du langage naturel et la reconnaissance vocale. Le processus de formation consiste \u00e0 alimenter le r\u00e9seau neuronal avec un grand ensemble de donn\u00e9es et \u00e0 ajuster les poids des connexions entre les n\u0153uds pour minimiser l'erreur entre les sorties pr\u00e9dites et les sorties r\u00e9elles. Gr\u00e2ce \u00e0 des it\u00e9rations r\u00e9p\u00e9t\u00e9es, le r\u00e9seau neuronal peut apprendre \u00e0 reconna\u00eetre des mod\u00e8les dans les donn\u00e9es et \u00e0 faire des pr\u00e9dictions pr\u00e9cises sur les nouvelles donn\u00e9es.

    "},{"location":"7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html#exemple-de-code_3","title":"Exemple de code","text":"PythonR deep_learning.py
    #!/usr/bin/env python\n\n# Charger les biblioth\u00e8ques requises\nimport pandas as pd\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow import keras\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.metrics import accuracy_score\n\n# Charger l'ensemble de donn\u00e9es\ndata = pd.read_csv('path/to/dataset.csv')\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nX_train, X_test, y_train, y_test = train_test_split(data.drop('target_variable', axis=1), data['target_variable'], test_size=0.2)\n\n# Standardiser les fonctionnalit\u00e9s d'entr\u00e9e\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nX_test_scaled = scaler.transform(X_test)\n\n# D\u00e9finir le mod\u00e8le d'apprentissage profond\nmodel = keras.Sequential([\n    keras.layers.Dense(64, activation='relu', input_shape=[X_train_scaled.shape[1]]),\n    keras.layers.Dropout(0.2),\n    keras.layers.Dense(1, activation='sigmoid')\n])\n\n# Compiler le mod\u00e8le\nmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n# Entra\u00eener le mod\u00e8le\nhistory = model.fit(X_train_scaled, y_train, epochs=50, batch_size=32, validation_split=0.1)\n\n# \u00c9valuer les performances du mod\u00e8le\ny_pred = model.predict_classes(X_test_scaled)\naccuracy = accuracy_score(y_test, y_pred)\nprint('Accuracy:', accuracy)\n
    deep_learning.r
    #!/usr/bin/env Rscript\n\n# Charger les biblioth\u00e8ques requises\nlibrary(keras)\nlibrary(tensorflow)\n\n# Charger l'ensemble de donn\u00e9es\ndata <- iris\nx <- as.matrix(data[, 1:4])\ny <- to_categorical(as.numeric(data[, 5]) - 1)\n\n# Divisez les donn\u00e9es en ensembles de formation et de test\nset.seed(123)\ntrain_index <- sample(1:nrow(data), size=0.8*nrow(data))\nx_train <- x[train_index,]\ny_train <- y[train_index,]\nx_test <- x[-train_index,]\ny_test <- y[-train_index,]\n\n# D\u00e9finir l'architecture du r\u00e9seau de neurones\nmodel <- keras_model_sequential() %>%\nlayer_dense(units = 8, input_shape = c(4)) %>%\nlayer_activation('relu') %>%\nlayer_dense(units = 3) %>%\nlayer_activation('softmax')\n\n# Compiler le mod\u00e8le\nmodel %>% compile(\nloss = 'categorical_crossentropy',\noptimizer = 'adam',\nmetrics = c('accuracy')\n)\n\n# Entra\u00eener le mod\u00e8le\nhistory <- model %>% fit(\nx_train, y_train,\nepochs = 50,\nbatch_size = 10,\nvalidation_split = 0.2,\nverbose = 0\n)\n\n# \u00c9valuer les performances du mod\u00e8le\nmetrics <- model %>% evaluate(x_test, y_test)\nprint(paste('Test Loss:', metrics[1]))\nprint(paste('Test Accuracy:', metrics[2]))\n\n# Tracez la pr\u00e9cision de la formation et de la validation au fil du temps\nplot(history$metrics$accuracy, type='l', col='blue', ylim=c(0,1), ylab='Accuracy', xlab='Epoch')\nlines(history$metrics$val_accuracy, type='l', col='red')\nlegend('bottomright', legend=c('Training', 'Validation'), col=c('blue', 'red'), lty=1)\n
    "},{"location":"7-MLOps/Serving.html","title":"Service de mod\u00e8les avec Seldon Core et KFServing","text":"

    \u2692 Cette page est en construction \u2692

    La personne qui \u00e9crit cet article n'en sait pas assez sur cette fonctionnalit\u00e9 pour en parler, mais vous pouvez demander sur notre cha\u00eene Slack.

    "},{"location":"7-MLOps/Serving.html#sans-serveur-avec-knative","title":"Sans serveur avec KNative","text":"

    Kubernetes et KNative permettent \u00e0 vos services d'\u00e9voluer et vers le bas sur demande. Cela vous permet de cr\u00e9er des API pour servir des mod\u00e8les de Machine Learning, sans avoir besoin de g\u00e9rer l\u2019\u00e9quilibrage de charge ou la mise \u00e0 l\u2019\u00e9chelle. La plateforme peut g\u00e9rer toute votre mise \u00e0 l'\u00e9chelle pour vous, afin que vous puissiez vous concentrer sur la logique du programme.

    \u2692 Cette page est en construction \u2692

    La personne qui \u00e9crit cet article n'en sait pas assez \u00e0 ce sujet fonctionnalit\u00e9 pour \u00e9crire \u00e0 ce sujet, mais vous pouvez demander sur notre cha\u00eene Slack.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html","title":"Servir un classificateur d'iris avec Seldon","text":"In\u00a0[\u00a0]: Copied! 
    %%writefile requirements.txt\nscikit-learn\ndill\npandas\nsklearn\nseldon-core\nrequests\nmatplotlib\n
    %%writefile requirements.txt scikit-learn dill pandas sklearn seldon-core requests matplotlib In\u00a0[\u00a0]: Copied! 
    !if [ ! -d \"./venv\" ]; then python -m venv venv; fi\n
    !if [ ! -d \"./venv\" ]; then python -m venv venv; fi In\u00a0[\u00a0]: Copied! 
    !source ./venv/bin/activate\n
    !source ./venv/bin/activate In\u00a0[\u00a0]: Copied! 
    !if [ ! -d \"/home/jovyan/.config/pip\" ]; then mkdir /home/jovyan/.config/pip; fi\n
    !if [ ! -d \"/home/jovyan/.config/pip\" ]; then mkdir /home/jovyan/.config/pip; fi

    Seldon ne fonctionne que dans l'environnement de d\u00e9veloppement ETAA; modifiez pip.conf pour r\u00e9cup\u00e9rer les packages sur internet.

    In\u00a0[\u00a0]: Copied! 
    %%writefile /home/jovyan/.config/pip/pip.conf\n[global]\nindex-url = https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple\n
    %%writefile /home/jovyan/.config/pip/pip.conf [global] index-url = https://jfrog.aaw.cloud.statcan.ca/artifactory/api/pypi/pypi-remote/simple In\u00a0[\u00a0]: Copied! 
    %%capture\n%pip install -r requirements.txt\n
    %%capture %pip install -r requirements.txt

    Nous pouvons ajouter le noyau au lanceur JupyterLab pour une r\u00e9utilisation facile.

    In\u00a0[\u00a0]: Copied! 
    !python -m ipykernel install --user --name=sklearn_iris_jsondata\n
    !python -m ipykernel install --user --name=sklearn_iris_jsondata In\u00a0[\u00a0]: Copied! 
    %%writefile sklearn_iris_jsondata_deployment.yaml\napiVersion: machinelearning.seldon.io/v1alpha2\nkind: SeldonDeployment\nmetadata:\n  name: seldon-deployment-example\n  namespace: bryanpaget\nspec:\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\n
    %%writefile sklearn_iris_jsondata_deployment.yaml apiVersion: machinelearning.seldon.io/v1alpha2 kind: SeldonDeployment metadata: name: seldon-deployment-example namespace: bryanpaget spec: name: sklearn-iris-deployment annotations: sidecar.istio.io/inject: \"false\" predictors: - componentSpecs: - spec: containers: - image: seldonio/sklearn-iris:0.3 imagePullPolicy: IfNotPresent name: sklearn-iris-classifier graph: children: [] endpoint: type: REST name: sklearn-iris-classifier type: MODEL name: sklearn-iris-predictor replicas: 1

    D\u00e9ployez SeldonDeployment.

    In\u00a0[\u00a0]: Copied! 
    !kubectl create -f sklearn_iris_jsondata_deployment.yaml\n
    !kubectl create -f sklearn_iris_jsondata_deployment.yaml In\u00a0[\u00a0]: Copied! 
    !kubectl rollout status deploy \\\n    $(kubectl get deploy -l seldon-deployment-id=seldon-deployment-example \\\n        -o jsonpath='{.items[0].metadata.name}')\n
    !kubectl rollout status deploy \\ $(kubectl get deploy -l seldon-deployment-id=seldon-deployment-example \\ -o jsonpath='{.items[0].metadata.name}')

    Le service est-il disponible ?

    In\u00a0[\u00a0]: Copied! 
    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)\nassert state == \"Available\"\n
    for i in range(60): state = !kubectl get sdep seldon-deployment-example -o jsonpath='{.status.state}' state = state[0] print(state) if state == \"Available\": break time.sleep(1) assert state == \"Available\" In\u00a0[\u00a0]: Copied! 
    import json\nimport pandas as pd\n
    import json import pandas as pd

    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\u00e9s, une pour chacun des trois types de fleurs d'iris. Vous pouvez en savoir plus sur les donn\u00e9es d'iris ici. Envoyons quelques donn\u00e9es au mod\u00e8le.

    In\u00a0[\u00a0]: Copied! 
    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]]}}'\n
    res = !curl -v seldon-deployment-example-sklearn-iris-predictor.bryanpaget.svc.cluster.local:8000/api/v0.1/predictions \\ -H 'Content-Type: application/json' \\ -d '{\"data\": {\"ndarray\": [[5.964, 1.006, 2.081, 1.031]]}}' In\u00a0[\u00a0]: Copied! 
    parsed = json.loads(res[-1])\nprint(json.dumps(parsed, indent=4, sort_keys=True))\n
    parsed = json.loads(res[-1]) print(json.dumps(parsed, indent=4, sort_keys=True))

    Cette fonction de tra\u00e7age r\u00e9v\u00e8le un graphique \u00e0 barres avec l'inf\u00e9rence du classificateur.

    In\u00a0[\u00a0]: Copied! 
    def display_iris_classifier_results(res):\n    \"\"\" Prend les r\u00e9sultats de classification du classificateur d'iris et les trace dans un graphique \u00e0 barres pour une visualisation facile des probabilit\u00e9s de classe.\n\n     Arguments :\n         res (string) : r\u00e9sultats du mod\u00e8le 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\ndisplay_iris_classifier_results(res)\n
    def display_iris_classifier_results(res): \"\"\" Prend les r\u00e9sultats de classification du classificateur d'iris et les trace dans un graphique \u00e0 barres pour une visualisation facile des probabilit\u00e9s de classe. Arguments : res (string) : r\u00e9sultats du mod\u00e8le d'iris servi par Seldon. \"\"\" results = res[-1] results = json.loads(results) names = results[\"data\"][\"names\"] predictions = results[\"data\"][\"ndarray\"][0] model = results[\"meta\"][\"requestPath\"] model = model.popitem() model, version = model[0], model[1] df = pd.DataFrame({\"Class\": names, \"Probability\": predictions}) df.plot( kind=\"bar\", title=model.replace(\"-\", \" \").title(), xlabel=\"Classification\", ylabel=\"Probability\", legend=False ) display_iris_classifier_results(res) In\u00a0[\u00a0]: Copied! 
    !kubectl delete -f sklearn_iris_jsondata_deployment.yaml\n
    !kubectl delete -f sklearn_iris_jsondata_deployment.yaml"},{"location":"7-MLOps/sklearn_iris_jsondata.html#servir-un-classificateur-diris-avec-seldon","title":"Servir un classificateur d'iris avec Seldon\u00b6","text":""},{"location":"7-MLOps/sklearn_iris_jsondata.html#objectif-du-bloc-notes","title":"Objectif du bloc-notes\u00b6","text":"

    L'objectif de ce bloc-notes est d'encapsuler un mod\u00e8le Python \"scikit-learn\" \u00e0 utiliser comme microservice de pr\u00e9diction avec Seldon Core.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#configurer-python","title":"Configurer Python\u00b6","text":"

    \u00c9crivez requirements.txt et configurez notre environnement virtuel Python.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#deployer-le-modele","title":"D\u00e9ployer le mod\u00e8le\u00b6","text":"

    \u00c9crivez un fichier YAML SeldonDeployment pour le mod\u00e8le conteneuris\u00e9.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#modele-de-test","title":"Mod\u00e8le de test\u00b6","text":"

    Avec l'environnement virtuel configur\u00e9 et activ\u00e9, importez les biblioth\u00e8ques Python n\u00e9cessaires.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#resultats","title":"R\u00e9sultats\u00b6","text":"

    Ce sont les r\u00e9sultats en JSON brut.

    "},{"location":"7-MLOps/sklearn_iris_jsondata.html#nettoyer","title":"Nettoyer\u00b6","text":"

    Nettoyez en supprimant le d\u00e9ploiement.

    "}]} \ No newline at end of file diff --git a/fr/sitemap.xml b/fr/sitemap.xml index ffaaa13aa..6ad648728 100644 --- a/fr/sitemap.xml +++ b/fr/sitemap.xml @@ -2,207 +2,212 @@ https://statcan.github.io/aaw/fr/index.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/Aide.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/Collaboration.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/message-de-bienvenue.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/Apercu.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/Bureau-virtuel.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/Environnements-virtuels.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/Jupyter.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/Kubeflow.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/MLflow.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/RStudio.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/Selectionner-une-image.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/DTale_FR.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/DrawData_FR.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/MitoSheet_FR.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/PyGWalker_FR.html - 2023-12-11 + 2023-12-13 + daily + + + https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/ReRun_FR.html + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/SweetViz_FR.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/VisualPython_FR.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/1-Experiences/bloc-notes/YData-Profiling_FR.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/2-Publication/Dash.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/2-Publication/Datasette.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/2-Publication/Overview.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/2-Publication/PowerBI.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/2-Publication/R-Shiny.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/2-Publication/Sur-mesure.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/3-Pipelines/Argo.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/4-Collaboration/Aper%C3%A7u.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/4-Collaboration/Demander-EspaceDeNom.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/4-Collaboration/Environnement-Analyse-Geospatiale.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/5-Stockage/Aper%C3%A7u.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/5-Stockage/Disque.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/5-Stockage/StockageBlobAzure.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/6-Gitlab/Gitlab.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/Aper%C3%A7u.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/Integration-PaaS.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/Modele-ML-stockage.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/Modele-Ml-entrainement.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/Modele-Service-ML.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/Mod%C3%A8les-d%27apprentissage-automatique.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/Serving.html - 2023-12-11 + 2023-12-13 daily https://statcan.github.io/aaw/fr/7-MLOps/sklearn_iris_jsondata.html - 2023-12-11 + 2023-12-13 daily \ No newline at end of file diff --git a/fr/sitemap.xml.gz b/fr/sitemap.xml.gz index 38a3c12d1..162e3f3e3 100644 Binary files a/fr/sitemap.xml.gz and b/fr/sitemap.xml.gz differ