DataLab et Spyder : un duo gagnant#

Ce tutoriel montre comment utiliser Spyder pour travailler avec DataLab à travers un exemple pratique, en utilisant des algorithmes et des données d’exemple qui représentent un flux de travail hypothétique de recherche ou technique. L’objectif est d’illustrer comment utiliser DataLab pour tester vos algorithmes avec des données et les déboguer si nécessaire.

L’exemple est simple, mais il démontre les concepts essentiels du travail avec DataLab et Spyder.

Note

DataLab et Spyder sont des outils complémentaires. Alors que Spyder est un environnement de développement puissant avec des capacités de calcul scientifique interactif, DataLab est une plateforme d’analyse de données polyvalente qui peut effectuer une large gamme de tâches, de la simple visualisation de données à l’analyse et au traitement complexes de données. En d’autres termes, Spyder est un outil de développement, tandis que DataLab est un outil d”analyse de données. Vous pouvez utiliser Spyder pour développer des algorithmes, puis utiliser DataLab pour analyser des données avec ces algorithmes.

Concepts de base#

Dans le contexte de vos travaux de recherche ou techniques, nous supposons que vous développez un logiciel pour traiter des données (signaux ou images). Ce logiciel peut être une application autonome, une bibliothèque à utiliser dans d’autres applications, ou même un simple script à exécuter depuis la ligne de commande. Dans tous les cas, vous devrez suivre un processus de développement qui comprend généralement les étapes suivantes :

Prototyper l’algorithme dans un environnement de développement tel que Spyder.
Développer l’algorithme dans un environnement de développement tel que Spyder.
Tester l’algorithme avec des données.
Déboguer l’algorithme si nécessaire.
Répéter les étapes 2 et 3 jusqu’à ce que l’algorithme fonctionne comme prévu.
Utiliser l’algorithme dans votre application.

Note

DataLab peut vous aider avec l’étape 0 car il fournit toutes les primitives de traitement dont vous avez besoin pour prototyper votre algorithme : vous pouvez charger des données, les visualiser et effectuer des opérations de traitement de base. Nous ne couvrirons pas cette étape dans les sections suivantes car la documentation de DataLab fournit déjà des informations détaillées à ce sujet.

Dans ce tutoriel, nous verrons comment utiliser DataLab pour effectuer les étapes 2 et 3. Nous supposons que vous avez déjà prototypé (de préférence dans DataLab !) et développé votre algorithme dans Spyder. Maintenant, vous voulez le tester avec des données, mais sans quitter Spyder car vous devrez peut-être modifier votre algorithme et le re-tester. De plus, votre flux de travail est déjà configuré dans Spyder et vous ne voulez pas le changer.

Note

Ce tutoriel suppose que vous avez déjà installé DataLab et l’avez démarré. Si vous ne l’avez pas encore fait, veuillez vous référer à la section Installation de la documentation.

De plus, nous supposons que vous avez déjà installé Spyder et l’avez démarré. Si vous ne l’avez pas encore fait, veuillez vous référer à la documentation de Spyder. Notez que vous n’avez pas besoin d’installer DataLab dans le même environnement que Spyder : c’est tout l’intérêt de DataLab—c’est une application autonome qui peut être utilisée depuis n’importe quel environnement. Pour ce tutoriel, vous devez seulement installer le paquet Sigima (pip install sigima) dans le même environnement que Spyder.

Tester votre algorithme avec DataLab#

Supposons que vous avez développé des algorithmes dans le module my_work de votre projet. Vous les avez déjà prototypés dans DataLab et développés dans Spyder en écrivant des fonctions qui prennent des données en entrée et retournent des données traitées en sortie. Maintenant, vous voulez tester ces algorithmes avec des données.

Pour tester ces algorithmes, vous avez écrit deux fonctions dans le module my_work :

test_my_1d_algorithm : cette fonction retourne des données 1D qui vous permettront de valider votre premier algorithme, qui traite des données 1D.
test_my_2d_algorithm : cette fonction retourne des données 2D qui vous permettront de valider votre second algorithme, qui traite des données 2D.

Vous pouvez maintenant utiliser DataLab pour visualiser les données retournées par ces fonctions directement depuis Spyder :

Tout d’abord, démarrez DataLab et Spyder.
Rappelez-vous que DataLab est une application autonome qui peut être utilisée depuis n’importe quel environnement, donc vous n’avez pas besoin de l’installer dans le même environnement que Spyder car la connexion entre ces deux applications est établie via un protocole de communication.

Voici comment procéder :

# %% Connecting to DataLab current session

from sigima.client import SimpleRemoteProxy

proxy = SimpleRemoteProxy()
proxy.connect()

# %% Visualizing 1D data from my work

from my_work import test_my_1d_algorithm

x, y = test_my_1d_algorithm()  # Here is all my research/technical work!
proxy.add_signal("My 1D result data", x, y)  # Let's visualize it in DataLab
proxy.compute_wiener()  # Denoise the signal using the Wiener filter


# %% Visualizing 2D data from my work

from my_work import test_my_2d_algorithm

z = test_my_2d_algorithm()[1]  # Here is all my research/technical work!
proxy.add_image("My 2D result data", z)  # Let's visualize it in DataLab

Si nous exécutons les deux premières cellules, nous verrons la sortie suivante dans la console Spyder :

Python 3.11.5 (tags/v3.11.5:cce6ba9, Aug 24 2023, 14:38:34) [MSC v.1936 64 bit (AMD64)]
Type "copyright", "credits" or "license" for more information.

IPython 8.15.0 -- An enhanced Interactive Python.

In [1]: runcell('Connecting to DataLab current session', 'my_work_test_with_datalab.py')
Connecting to DataLab XML-RPC server...OK (port: 54577)

In [2]: runcell('Visualizing 1D data from my work', 'my_work_test_with_datalab.py')
Out[2]: True

../../_images/015.png — Dans cette capture d’écran, nous pouvons voir le résultat de l’évaluation des deux premières cellules : la première cellule se connecte à DataLab, et la seconde cellule visualise les données 1D retournées par la fonction `test_my_1d_algorithm`.#

../../_images/025.png — Dans cette capture d’écran, nous pouvons voir le résultat de l’évaluation de la troisième cellule : la fonction `test_my_2d_algorithm` retourne un tableau 2D, que nous pouvons visualiser directement dans DataLab.#

Déboguer votre algorithme avec DataLab#

Maintenant que vous avez testé vos algorithmes avec des données, vous voudrez peut-être les déboguer si nécessaire. Pour ce faire, vous pouvez combiner les capacités de débogage de Spyder avec DataLab.

Voici le code de l’algorithme d’exemple que nous voulons déboguer, dans lequel nous avons introduit un paramètre optionnel debug_with_datalab qui—s’il est défini à True—créera un objet proxy permettant la visualisation pas à pas des données dans DataLab :

def generate_2d_data(
    num_lines: int = 10,
    noise_std: float = 0.1,
    x_min: float = -1,
    x_max: float = 1,
    num_points: int = 100,
    debug_with_datalab: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """Generate 2D data that can be used in the tutorials to represent some results.

    Args:
        num_lines: Number of lines in the generated data, by default 10.
        noise_std: Standard deviation of the noise, by default 0.1.
        x_min: Minimum value of the x axis, by default -1.
        x_max: Maximum value of the x axis, by default 1.
        num_points: Number of points in the generated data, by default 100.
        debug_with_datalab: Whether to use the DataLab to debug the function,
         by default False.

    Returns:
        Generated data (x, y; where y is a 2D array and x is a 1D array).
    """
    proxy = None
    if debug_with_datalab:
        proxy = SimpleRemoteProxy()
        proxy.connect()
    z = np.zeros((num_lines, num_points))
    for i in range(num_lines):
        amplitude = 0.1 * i**2
        peak_position = 0.5 * i**2
        peak_width = 0.1 * i**2
        x, y = generate_1d_data(
            amplitude,
            peak_position,
            peak_width,
            relaxation_oscillations=True,
            noise=True,
            noise_std=noise_std,
            x_min=x_min,
            x_max=x_max,
            num_points=num_points,
        )
        z[i] = y
        if proxy is not None:
            proxy.add_signal(f"Line {i}", x, y)
    return x, z

La fonction test_my_2d_algorithm correspondante a également un paramètre optionnel debug_with_datalab qui est simplement passé à la fonction generate_2d_data.

Maintenant, nous pouvons utiliser Spyder pour déboguer la fonction test_my_2d_algorithm :

# %% Debugging my work with DataLab

from my_work import generate_2d_data

x, z = generate_2d_data(debug_with_datalab=True)

Dans cet exemple simple, l’algorithme itère 10 fois et génère un tableau 1D à chaque itération. Chaque tableau 1D est ensuite empilé dans un tableau 2D qui est retourné par la fonction generate_2d_data. Avec le paramètre debug_with_datalab défini à True, nous pouvons visualiser chaque tableau 1D dans DataLab : de cette façon, nous pouvons vérifier que l’algorithme fonctionne comme prévu.

../../_images/035.png — Dans cette capture d’écran, nous pouvons voir le résultat de l’évaluation de la première cellule : la fonction `test_my_2d_algorithm` est appelée avec le paramètre `debug_with_datalab` défini à `True` : 10 tableaux 1D sont générés et visualisés dans DataLab.#

Note

Si nous avions exécuté le script en utilisant le débogueur Spyder et défini un point d’arrêt dans la fonction generate_2d_data, nous aurions vu les tableaux 1D générés dans DataLab à chaque itération. Puisque DataLab s’exécute dans un processus séparé, nous aurions pu interagir avec les données dans DataLab pendant que l’algorithme est en pause dans Spyder.