DataLab et Spyder : un mariage parfait#

Concepts de base#

Dans le contexte de votre travail de recherche ou technique, nous supposons que vous développez un logiciel pour traiter des données (signaux ou images) : ce logiciel peut être une application autonome ou une bibliothèque que vous utiliserez dans d’autres applications, ou même un simple script que vous exécuterez à partir de la ligne de commande. Dans tous les cas, vous devrez suivre un processus de développement qui comprendra les étapes suivantes :

0. Prototyper l’algorithme dans un environnement de développement, tel que Spyder.

1. Développer l’algorithme dans un environnement de développement, tel que Spyder.

2. Tester l’algorithme avec des données.

3. Déboguer l’algorithme si nécessaire.

4. Répéter les étapes 2 et 3 jusqu’à ce que l’algorithme fonctionne comme prévu.

5. Utiliser l’algorithme dans votre application.

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 apporter des modifications à 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.

Tester votre algorithme avec DataLab#

Supposons que vous ayez développé des algorithmes dans le module my_work de votre projet. Vous les avez déjà prototypés dans DataLab, et vous les avez développés dans Spyder en écrivant des fonctions qui prennent des données en entrée et renvoient 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 renvoie des données 1D qui vous permettront de valider votre premier algorithme qui fonctionne sur des données 1D.

• test_my_2d_algorithm : cette fonction renvoie des données 2D qui vous permettront de valider votre deuxième algorithme qui fonctionne sur des données 2D.

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

• Tout d’abord, vous devez démarrer DataLab et Spyder.

• Rappelez-vous que DataLab est une application autonome qui peut être utilisée à partir de n’importe quel environnement, vous n’avez donc pas besoin de l’installer dans le même environnement que Spyder car la connexion entre ces deux applications se fait via un protocole de communication.

Voici comment faire :

# %% Connecting to DataLab current session

from cdlclient 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_cdl.py')
Connecting to DataLab XML-RPC server...OK (port: 54577)

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

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 fictif que nous voulons déboguer, dans lequel nous avons introduit un paramètre optionnel debug_with_datalab qui - s’il est défini sur True - créera un objet proxy permettant de visualiser les données étape par étape 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 simplement 10 fois et génère un tableau 1D à chaque itération. Chaque tableau 1D est ensuite empilé dans un tableau 2D qui est renvoyé par la fonction generate_2d_data. Avec le paramètre debug_with_datalab défini sur True, nous pouvons visualiser chaque tableau 1D dans DataLab : de cette façon, nous pouvons vérifier que l’algorithme fonctionne comme prévu.