iid-course-utils 0.1__py3-none-any.whl

iid_course_utils-0.1.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: iid-course-utils
+Version: 0.1
+Summary: A library for internal course tools used in IID ULaval courses.
+Project-URL: Homepage, https://github.com/iid-ulaval/iid-course-utils
+Author-email: Marouane Yassine <marouane.yassine.1@ulaval.ca>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: poutyne
+Requires-Dist: requests
+Requires-Dist: scikit-learn
+Requires-Dist: seaborn
+Requires-Dist: torch
+Requires-Dist: torchtext
+Description-Content-Type: text/markdown
+
+# A library for internal course tools used in IID ULaval courses

iid_course_utils-0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+iidcourse/__init__.py,sha256=ynyfXCEoiCL7SmyKKP3iGJ1MazPCkwmg7pC7r0ZnFhw,71
+iidcourse/convolution/__init__.py,sha256=WG5hjS6Yh7b4S4DoDlUjyVgwd64N9c4dfYqvdakaB6Y,169
+iidcourse/convolution/architectures.py,sha256=1QUG3JQ3Guf3_pN7HgAftQojUK8lB2fcoYubMCZN-Zo,8905
+iidcourse/convolution/callbacks.py,sha256=AANIzBiU1bsUXaGr8hhvuJ6ZliqV0a46Niw0JG9PEus,358
+iidcourse/convolution/datasets.py,sha256=ZIdk6L1cCA4rXKR_gRFV4P9ob46B9CjXoS1hl6yvIWc,2752
+iidcourse/convolution/visualisation.py,sha256=rHK05tifOsokoHhik_k2enkP3n70HcT1fE8A1kZv2Qg,8807
+iidcourse/convolution/weights_init.py,sha256=lcZJ9_kb-CF4oN62bDb0m_jW5qU5KyET8_2sC1MAWxs,295
+iidcourse/nlp/__init__.py,sha256=gPzMJEQubNzKJn0MZyLY8HEmVwVaPHXFDidNHLr6tKE,114
+iidcourse/nlp/data_transformer.py,sha256=YkUm2Kw-NlALdmF1ZF4ZRvCLj13jG8qOTkc7HhOh__M,2186
+iidcourse/nlp/datasets.py,sha256=j9ZiY8DcrScALLnAnUeADda_4XCGcNv85ANRQHP7oMk,1244
+iidcourse/nlp/evaluate.py,sha256=IKzUnI7iuzSlifiIoyWD26aSb3LvHP1of5xP8d0ApGM,1168
+iidcourse/resources/__init__.py,sha256=ybwE_sLeW8VT7I7HLeegelFOVtTFS0tLuN4TiumsI_c,27
+iidcourse/resources/files_setup.py,sha256=EiX34P9eYwIEG4UD0cs_z7rMqYvEZevJNvdiXBiT6_Q,3104
+iid_course_utils-0.1.dist-info/METADATA,sha256=jVKxqSTyMecR6OwBqzBCyYUxdq4xD1jjZcj-0kAVG30,651
+iid_course_utils-0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+iid_course_utils-0.1.dist-info/licenses/LICENSE,sha256=m0Ej54eG_LZbixr0A-xPunQSyCzhnbxw29eeTZaRNEY,1060
+iid_course_utils-0.1.dist-info/RECORD,,

iid_course_utils-0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iid_course_utils-0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 PAX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

iidcourse/__init__.py

@@ -0,0 +1,3 @@
+from .nlp import *
+from .convolution import *
+from .resources import *

iidcourse/convolution/__init__.py

@@ -0,0 +1,6 @@
+# pylint: disable=wildcard-import
+from .architectures import *
+from .callbacks import *
+from .datasets import *
+from .visualisation import *
+from .weights_init import *

iidcourse/convolution/architectures.py

@@ -0,0 +1,234 @@
+from functools import partial
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ClassicNet(nn.Module):
+    def __init__(self, num_layers):
+        super().__init__()
+        layers = [nn.Conv2d(3, 100, 3, padding=1), nn.ReLU()]
+        self.num_layers = num_layers
+        for layer_number in range(2, num_layers + 1):
+            layers.append(nn.Conv2d(100, 100, 3, padding=1))
+            layers.append(nn.ReLU())
+            if layer_number in [3, 5]:
+                layers.append(nn.MaxPool2d(2))
+
+        layers.append(nn.Flatten())
+        layers.append(nn.Linear(100 * 8 * 8, 10))
+
+        self.model = nn.Sequential(*layers)
+
+    def forward(self, x):
+
+        for layer in self.model:
+            x = layer(x)
+
+        return x
+
+    def eval_weight_distribution(self, x):
+        k = 2000  # Chiffre de valeurs aléatoires
+        entree = {}
+        indice = 0
+        for layer in self.model:
+            if isinstance(layer, torch.nn.modules.conv.Conv2d):
+                indice += 1
+                if indice in (1, self.num_layers - 1):  # Première ou dernière couche
+                    echantillon = nn.Flatten(0)(x.detach().cpu())
+                    entree[f"Conv_{indice}"] = np.random.choice(echantillon, size=k)
+
+            x = layer(x)
+
+        return x, entree
+
+
+class ResidualLayer(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1 = nn.Conv2d(100, 100, 3, padding=1)
+
+        self.conv2 = nn.Conv2d(100, 100, 3, padding=1)
+
+    def forward(self, x):
+        res = x
+        x = F.relu((self.conv1(x)))
+        x = self.conv2(x)
+        x = F.relu(x + res)
+        return x
+
+
+class ResNet(nn.Module):
+    def __init__(self, nb_bloc_residuelle):
+        super().__init__()
+        assert nb_bloc_residuelle > 2
+
+        self.conv1 = nn.Conv2d(3, 100, 3, padding=1)
+        self.bn1 = nn.BatchNorm2d(100)
+
+        self.layers = nn.ModuleList([ResidualLayer() for _ in range(nb_bloc_residuelle)])
+        self.fc1 = nn.Linear(100 * 8 * 8, 10)
+
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+
+        for i, layer in enumerate(self.layers):
+            x = layer(x)
+            if i <= 1:
+                x = F.max_pool2d(x, 2)
+
+        x = x.flatten(1)
+        x = self.fc1(x)
+        return x
+
+
+"""
+The code below was copied from the "Image-to-Image Translation in PyTorch" repository 
+
+COPYRIGHT
+
+All contributions from the https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/cf4191a3a4cc77fdffa5c0a8246c346049958e78/models/networks.py#L468.
+ authors.
+Copyright (c) 2017, Jun-Yan Zhu and Taesung Park
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+--------------------------- LICENSE FOR pix2pix --------------------------------
+BSD License
+
+For pix2pix software
+Copyright (c) 2016, Phillip Isola and Jun-Yan Zhu
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+----------------------------- LICENSE FOR DCGAN --------------------------------
+BSD License
+
+For dcgan.torch software
+
+Copyright (c) 2015, Facebook, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the 
+following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following 
+disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following 
+disclaimer in the documentation and/or other materials provided with the distribution.
+
+Neither the name Facebook nor the names of its contributors may be used to endorse or promote products derived from 
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR 
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY 
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 
+DAMAGE.
+"""
+
+
+class UNetSkipConnectionBlock(nn.Module):
+    """Defines the U-Net submodule with skip connection.
+    X -------------------identity----------------------
+    |-- downsampling -- |submodule| -- upsampling --|
+    """
+
+    def __init__(
+        self,
+        outer_nc,
+        inner_nc,
+        input_nc=None,
+        submodule=None,
+        outermost=False,
+        innermost=False,
+        norm_layer=nn.BatchNorm2d,
+        use_dropout=False,
+    ):
+        """Construct a Unet submodule with skip connections.
+        Parameters:
+            outer_nc (int): The number of filters in the outer conv layer.
+            inner_nc (int): The number of filters in the inner conv layer.
+            input_nc (int): The number of channels in input images/features.
+            submodule (UnetSkipConnectionBlock): Previously defined submodules.
+            outermost (bool): If this module is the outermost module.
+            innermost (bool): If this module is the innermost module.
+            norm_layer: Normalization layer.
+            use_dropout (bool): If use dropout layers.
+        """
+        super().__init__()
+        self.outermost = outermost
+        if isinstance(norm_layer, partial):
+            use_bias = norm_layer.func == nn.InstanceNorm2d
+        else:
+            use_bias = norm_layer == nn.InstanceNorm2d
+        if input_nc is None:
+            input_nc = outer_nc
+        downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4, stride=2, padding=1, bias=use_bias)
+        downrelu = nn.LeakyReLU(0.2, True)
+        downnorm = norm_layer(inner_nc)
+        uprelu = nn.ReLU(True)
+        upnorm = norm_layer(outer_nc)
+
+        if outermost:
+            upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, kernel_size=4, stride=2, padding=1)
+            down = [downconv]
+            up = [uprelu, upconv, nn.Tanh()]
+            model = down + [submodule] + up
+        elif innermost:
+            upconv = nn.ConvTranspose2d(inner_nc, outer_nc, kernel_size=4, stride=2, padding=1, bias=use_bias)
+            down = [downrelu, downconv]
+            up = [uprelu, upconv, upnorm]
+            model = down + up
+        else:
+            upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc, kernel_size=4, stride=2, padding=1, bias=use_bias)
+            down = [downrelu, downconv, downnorm]
+            up = [uprelu, upconv, upnorm]
+
+            if use_dropout:
+                model = down + [submodule] + up + [nn.Dropout(0.5)]
+            else:
+                model = down + [submodule] + up
+
+        self.model = nn.Sequential(*model)
+
+    def forward(self, x):
+        if self.outermost:
+            return self.model(x)
+        else:  # Add skip connections
+            return torch.cat([x, self.model(x)], 1)

iidcourse/convolution/callbacks.py

@@ -0,0 +1,11 @@
+from poutyne import Callback
+
+
+class SauvegardeLR(Callback):
+    def __init__(self, optimizer):
+        super().__init__()
+        self.optimizer = optimizer
+        self.lr_par_epoch = []
+
+    def on_epoch_begin(self, epoch_number, logs):  ## À chaque début d'époque
+        self.lr_par_epoch.append(self.optimizer.state_dict()["param_groups"][0]["lr"])

iidcourse/convolution/datasets.py

@@ -0,0 +1,91 @@
+import pickle as pk
+
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import Dataset
+
+
+class FaceDataset(Dataset):
+    def __init__(self, csv_file, transform=None, columns=None):
+
+        self.data = pd.read_csv(csv_file)
+
+        if columns is None:
+            self.columns = ["age", "ethnicity", "gender"]
+        else:
+            self.columns = columns
+
+        self.data.drop(columns={"img_name"}, inplace=True)
+        self.data["pixels"] = self.data["pixels"].apply(
+            lambda x: np.array(x.split(), dtype="float32").reshape((1, 48, 48)) / 255
+        )
+        self.data["age"] = self.data["age"].apply(lambda x: np.array([x], dtype="float32"))
+        self.X = torch.Tensor(self.data["pixels"])
+
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, indice):
+        if torch.is_tensor(indice):
+            indice = indice.tolist()
+        image = self.X[indice]
+        if len(self.columns) > 1:
+            attribute = torch.Tensor([float(self.data.iloc[indice][i]) for i in self.columns])
+        else:
+            attribute = self.data.iloc[indice][self.columns[0]]
+        sample = (image, attribute)
+
+        if self.transform:
+            sample = (self.transform(sample[0]), attribute)
+
+        return sample
+
+
+class EchantillonCIFAR10(Dataset):
+    """
+        Échantillon du jeu de donnée CIFAR10. L'échantillon comprend 10 000 données d'entraînements
+        et 2 000 de tests.
+    Args:
+        train (bool): Si True, prend les données d'entraînements, sinon les données de tests.
+        transform (callable, optional): Une function/transform qui prend le target et le transforme.
+        course (str, optional): Le sigle de la formation.
+
+    """
+
+    def __init__(self, train=True, transform=None, course='gif-u019'):
+        train_data_path = './CIFAR10_train_10000_sample.pk'
+        test_data_path = './CIFAR10_test_2000_sample.pk'
+        if train:
+            self.echantillon = pk.load(open(train_data_path, "rb"))
+        else:
+            self.echantillon = pk.load(open(test_data_path, "rb"))
+
+        self.transform = transform
+        self.classes = [
+            "avion",
+            "automobile",
+            "oiseau",
+            "chat",
+            "chevreuil",
+            "chien",
+            "grenouille",
+            "cheval",
+            "bateau",
+            "camion",
+        ]
+
+    def __len__(self):
+        return len(self.echantillon)
+
+    def __getitem__(self, indice):
+
+        if torch.is_tensor(indice):
+            indice = indice.tolist()
+        img, target = self.echantillon[indice]
+        if self.transform is not None:
+            img = self.transform(img)
+
+        return img, target

iidcourse/convolution/visualisation.py

@@ -0,0 +1,246 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+import torch
+
+from poutyne import Callback
+
+
+def visualiser_difference_de_poids(poids_initiaux, poids_finaux):
+    """
+    Affiche un graphique de la différence absolue moyenne entre les poids initiaux et finaux par couche.
+    Args:
+        poids_initiaux (Dict[str, torch.Tensor] ): Un dictionnaire où les clés sont le nom de
+        la couche et leur valeur sont les poids.
+        poids_finaux (Dict[str, torch.Tensor] ): Un dictionnaire où les clés sont le nom de
+        la couche et leur valeur sont les poids.
+    """
+
+    difference_etat = {}
+    nb_couches = len(poids_initiaux.keys())
+
+    for etat_initial_couche, etat_final_couche in zip(poids_initiaux.items(), poids_finaux.items()):
+        difference_etat[etat_initial_couche[0]] = torch.abs(
+            torch.flatten(
+                (etat_final_couche[1].cpu() - etat_initial_couche[1].cpu()).detach().clone(),
+                0,
+            )
+        ).tolist()
+
+    moyenne = [np.mean(poids_couche) for poids_couche in difference_etat.values()]
+    couche = [np.mean(i) for i in range(len(difference_etat.values()))]
+
+    max_moyenne = np.max(moyenne)
+
+    sns.lineplot(x=couche, y=moyenne)
+    plt.title(
+        f"Valeur moyenne de la différence absolue des poids initiaux et finaux par couche "
+        f"dans une architecture de {nb_couches} couches"
+    )
+    plt.xlabel("Indice de la couche")
+    plt.ylabel("différence")
+    plt.ylim(0, max_moyenne)
+    plt.show()
+
+
+class SauvegarderPoids(Callback):
+    """
+    This callback multiply the loss temperature with a decay before
+    each batch.
+
+    Args:
+        celoss_with_temp (CrossEntropyLossWithTemperature): the loss module.
+        decay (float): The value of the temperature decay.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.liste_poids = []
+
+    def on_epoch_begin(self, epoch_number, logs):  ## À chaque début d'époque
+        poids = tuple(self.model.network.parameters())[0][0].clone().detach().cpu()
+        self.liste_poids.append(poids)
+
+
+def show_2d_function(
+    fct,
+    min_val=-5,
+    max_val=5,
+    mesh_step=0.01,
+    *,
+    optimal=None,
+    bar=True,
+    ax=None,
+    **kwargs,
+):
+    # pylint: disable=blacklisted-name
+    """
+    Trace les courbes de niveau d'une fonction 2D.
+    Args:
+        fct (Callable[torch.Tensor, torch.Tensor]): Fonction objectif qui prend en paramètre un tenseur Nx2
+            correspondant à N paramètres pour lesquels on veut obtenir la valeur de la fonction.
+        optimal (torch.Tensor): La valeur optimale des poids pour la fonction objectif.
+    """
+    w1_values = torch.arange(min_val, max_val + mesh_step, mesh_step)
+    w2_values = torch.arange(min_val, max_val + mesh_step, mesh_step)
+
+    w2, w1 = torch.meshgrid(w2_values, w1_values, indexing='ij')
+    w_grid = torch.stack((w1.flatten(), w2.flatten()))
+    fct_values = fct(w_grid).view(w1_values.shape[0], w2.shape[0]).numpy()
+
+    w1_values, w2_values = w1_values.numpy(), w2_values.numpy()
+
+    if ax is not None:
+        plt.sca(ax)
+    if "cmap" not in kwargs:
+        kwargs["cmap"] = "RdBu"
+    plt.contour(w1_values, w2_values, fct_values, 40, **kwargs)
+    plt.xlim((min_val, max_val))
+    plt.ylim((min_val, max_val))
+    plt.xlabel("$w_1$")
+    plt.ylabel("$w_1$")
+
+    if bar:
+        plt.colorbar()
+
+    if optimal is not None:
+        plt.scatter(*optimal.numpy(), s=200, marker="*", c="r")
+
+
+def show_2d_trajectory(w_history, fct, min_val=-5, max_val=5, mesh_step=0.5, *, optimal=None, ax=None):
+    """
+    Trace le graphique de la trajectoire de descente en gradient en 2D.
+    Args:
+        w_history: L'historique de la valeur des poids lors de l'entraînement.
+        fct (Callable[torch.Tensor, torch.Tensor]): Fonction objectif qui prend en paramètre un tenseur Nx2
+            correspondant à N paramètres pour lesquels on veut obtenir la valeur de la fonction.
+        optimal (torch.Tensor): La valeur optimale des poids pour la fonction objectif.
+    """
+    show_2d_function(fct, min_val, max_val, mesh_step, optimal=optimal, ax=ax)
+
+    if len(w_history) > 0:
+        trajectory = np.array(w_history)
+        plt.plot(trajectory[:, 0], trajectory[:, 1], "o--", c="g")
+
+    plt.title("Trajectoire de la descente en gradient")
+    plt.xlabel("$w_1$")
+    plt.ylabel("$w_2$")
+
+
+def show_learning_curve(loss_list, loss_opt=None, ax=None):
+    """
+    Trace le graphique des valeurs de la fonction objectif lors de l'apprentissage.
+    Args:
+        loss_list: L'historique de la valeur de la perte lors de l'entraînement.
+        loss_opt: La valeur optimale de perte.
+    """
+    if ax is not None:
+        plt.sca(ax)
+    plt.plot(
+        np.arange(1, len(loss_list) + 1),
+        loss_list,
+        "o--",
+        c="g",
+        label="$F(\\mathbf{w})$",
+    )
+    if loss_opt is not None:
+        plt.plot([1, len(loss_list)], 2 * [loss_opt], "*--", c="r", label="optimal")
+    plt.title("Valeurs de la fonction objectif")
+    plt.xlabel("Itérations")
+    plt.legend()
+
+
+def show_optimization(w_history, loss_history, fct, optimal=None, title=None):
+    """
+    Trace deux graphiques montrant le trajet de l'optimisation d'une fonction objectif 2D. Le premier montre la valeur
+    des poids lors de l'optimisation. Le deuxième montre la valeur de la perte lors de l'optimisation.
+    Args:
+        w_history: L'historique des poids lors de l'optimisation
+        loss_history: L'historique de la valeur de la fonction perte.
+        fct (Callable[torch.Tensor, torch.Tensor]): Fonction objectif qui prend en paramètre un tenseur Nx2
+            correspondant à N paramètres pour lesquels on veut obtenir la valeur de la fonction.
+        optimal (torch.Tensor): La valeur optimale des poids pour la fonction objectif.
+    """
+    fig, axes = plt.subplots(1, 2, figsize=(14.5, 4))
+    if title is not None:
+        fig.suptitle(title)
+    show_2d_trajectory(w_history, fct, optimal=optimal, ax=axes[0])
+    show_learning_curve(loss_history, loss_opt=fct(optimal).numpy(), ax=axes[1])
+
+
+def plot_image_samples(dataset):
+    """
+    Affiche certaines images d'un jeu de données
+    """
+    classes = dataset.classes
+    num_samples = 15
+    indices = np.random.choice(len(dataset), size=num_samples, replace=False)
+    NROWS = 3
+    NCOLS = 5
+
+    assert len(indices) <= NROWS * NCOLS, f"Impossible d'afficher plus de {NROWS * NCOLS} images."
+
+    samples = [dataset[i] for i in indices]
+    images, targets = zip(*samples)
+    targets = list(targets)
+
+    # Affichage des images avec leurs étiquettes
+    fig, axes = plt.subplots(NROWS, NCOLS, sharex=True, sharey=True)
+    for ax, i, image, target in zip(axes.flat, indices, images, targets):
+        ax.imshow(image, cmap="gray")
+
+        target_class = classes[target]
+        ax.set_xlabel(f"Exemple {i}:\n" + target_class, fontsize=8)
+        ax.set_xticks([])
+        ax.set_yticks([])
+
+    fig.tight_layout()
+    plt.show()
+
+
+def visualiser_convolution(reseau, donnee, nb_image_max_par_couche):
+    x = torch.unsqueeze(list(donnee)[0][0], 0)
+    image_initiale = x[0].numpy().transpose((1, 2, 0))
+    x = x.cuda()
+    print("Image initiale :")
+    plt.imshow(image_initiale)
+    plt.show()
+    with torch.no_grad():
+        conv = 0
+        pool = 0
+
+        for layer in reseau.children():
+            x = layer(x)
+
+            if isinstance(layer, torch.nn.Conv2d):
+                conv += 1
+                print(f"Convolution {conv}")
+                _, axes = plt.subplots(
+                    min(x.shape[1] // 4, nb_image_max_par_couche // 4),
+                    4,
+                    constrained_layout=True,
+                )
+                for feature in range(min(x.shape[1], nb_image_max_par_couche)):
+                    image_conv = x[0, feature, :, :].clone().cpu()
+
+                    try:
+                        axes[feature // 4, feature % 4].imshow(image_conv)
+                    except IndexError:
+                        axes[feature % 4].imshow(image_conv)
+                plt.show()
+            if isinstance(layer, (torch.nn.modules.pooling.MaxPool2d, torch.nn.modules.pooling.AvgPool2d)):
+                pool += 1
+                print(f"Pooling {pool}")
+                _, axes = plt.subplots(
+                    min(x.shape[1] // 4, nb_image_max_par_couche // 4),
+                    4,
+                    constrained_layout=True,
+                )
+                for feature in range(min(x.shape[1], nb_image_max_par_couche)):
+                    imageConv = x[0, feature, :, :]
+                    try:
+                        axes[feature // 4, feature % 4].imshow(image_conv)
+                    except IndexError:
+                        axes[feature % 4].imshow(image_conv)
+
+                plt.show()

iidcourse/convolution/weights_init.py

@@ -0,0 +1,10 @@
+import torch
+from torch import nn
+
+
+def weights_init(m):
+    if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+        torch.nn.init.normal_(m.weight, 0.0, 0.02)
+    if isinstance(m, nn.BatchNorm2d):
+        torch.nn.init.normal_(m.weight, 0.0, 0.02)
+        torch.nn.init.constant_(m.bias, 0)

iidcourse/nlp/__init__.py

@@ -0,0 +1,4 @@
+# pylint: disable=wildcard-import
+from .evaluate import *
+from .data_transformer import *
+from .datasets import *

iidcourse/nlp/data_transformer.py

@@ -0,0 +1,104 @@
+from abc import abstractmethod, ABC
+
+
+class Transformer(ABC):
+    """
+    Abstract class for transformer over data.
+    """
+
+    def __init__(self):
+        self.__name__ = self.__class__.__name__
+
+    @abstractmethod
+    def transform(self, x):
+        """
+        Method to transform a text data.
+        :param x: (Union[str, List]) The data to be transform.
+        :return: (Union[str, List]) The transformed data.
+        """
+        pass
+
+    def fit(self, x):
+        """
+        Empty method to be compliant with Scikit-Learn interface.
+        """
+        return self
+
+    def __repr__(self):
+        return self.__name__
+
+
+class NewLineStrip(Transformer):
+    """
+    A filter to remove newline characters at the end of strings.
+    """
+
+    def transform(self, x):
+        return [i.strip('\n') for i in x]
+
+
+class EmptyLineRemoval(Transformer):
+    """
+    A filter to remove empty lines in a list.
+    """
+
+    def transform(self, x):
+        return list(filter(None, x))
+
+
+class WhiteSpaceStrip(Transformer):
+    """
+    A filter to remove whitespace characters at the end of strings.
+    """
+
+    def transform(self, x):
+        return [i.strip(' ') for i in x]
+
+
+class PunctuationStrip(Transformer):
+    """
+    A filter to remove punctuation characters at the end of strings.
+    """
+
+    def transform(self, x):
+        return [i.strip("""."',!?-""") for i in x]
+
+
+class StringRemove(Transformer):
+    """
+    A filter to remove punctuation characters in strings.
+    """
+
+    def __init__(self, characters):
+        super().__init__()
+        self.characters = characters
+
+    def transform(self, x):
+        return [i.replace(self.characters, "") for i in x]
+
+
+class PunctuationRemoval(StringRemove):
+    """
+    A filter to remove punctuation characters in strings.
+    """
+
+    def __init__(self):
+        super().__init__("!")
+
+
+class ThinSpaceRemoval(StringRemove):
+    """
+    A filter to remove punctuation characters in strings.
+    """
+
+    def __init__(self):
+        super().__init__("\u2009")
+
+
+class LowerCaser(Transformer):
+    """
+    A simple wrapper for lower case strings.
+    """
+
+    def transform(self, x):
+        return [i.lower() for i in x]

iidcourse/nlp/datasets.py

@@ -0,0 +1,30 @@
+from torch.utils.data import Dataset
+from torchtext.data.utils import get_tokenizer
+
+
+class TwentyNewsGroupDataset(Dataset):
+    def __init__(self, texts, labels, vectors):
+        tokenizer = get_tokenizer("spacy", language="en_core_web_sm")
+        self.texts = []
+        self.labels = []
+
+        for i in range(len(texts)):
+            # On tokenise le texte en éliminant d'abord les caractères d'espacement en trop au début et à la fin
+            tokens = tokenizer(texts[i].strip())
+            label = labels[i]
+            # Après le retrait des en-têtes, pieds de pages et citations, certains textes sont vides
+            # On ignore ces textes
+            if len(tokens) > 0:
+                self.texts.append(tokens)
+                self.labels.append(label)
+
+        # On conserve en mémoire la table de vecteurs
+        self.vectors = vectors
+
+    def __len__(self):
+        # On utilise la liste des textes pour déterminer le nombre d'exemples du jeu de données
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        # Pour obtenir la liste de vecteurs associé à un texte, on passe ses jetons à la table de vecteurs
+        return self.vectors.get_vecs_by_tokens(self.texts[idx]), self.labels[idx]

iidcourse/nlp/evaluate.py

@@ -0,0 +1,43 @@
+import time
+
+from sklearn.metrics import accuracy_score
+
+
+def evaluate(pipeline, train, test):
+    """
+    Cette fonction sera utilisée pour comparer la performance,
+    le temps d'entraînement et la taille du vocabulaire des différents pipelines
+    """
+    train_data, train_label = train
+    test_data, test_label = test
+
+    start_time = time.time()
+    pipeline.fit(train_data, train_label)
+    end_time = time.time()
+
+    predict_train = pipeline.predict(train_data)
+    predict_test = pipeline.predict(test_data)
+
+    accuracy_train = accuracy_score(predict_train, train_label)
+    accuracy_test = accuracy_score(predict_test, test_label)
+    train_time = end_time - start_time
+
+    return accuracy_train, accuracy_test, train_time
+
+
+def evaluate_20newsgroups(pipeline, train, test):
+    """
+    Une fonction pour évaluer sur 20newsgroup
+    """
+    return evaluate(
+        pipeline,
+        (train.data, train.target),
+        (test.data, test.target),
+    )
+
+
+def evaluate_weccr(pipeline, train, test):
+    """
+    Une fonction pour évaluer sur WECCR
+    """
+    return evaluate(pipeline, (train["text"], train["label"]), (test["text"], test["label"]))

iidcourse/resources/__init__.py

@@ -0,0 +1 @@
+from .files_setup import *

iidcourse/resources/files_setup.py

@@ -0,0 +1,99 @@
+import os
+import requests
+
+
+def setup_module(partie_id: int, module_id: int, course_name: str):
+    _download_dependencies(partie_id, module_id, course_name)
+
+    _download_module_files(partie_id, module_id, course_name)
+
+
+def _download_dependencies(partie_id: int, module_id: int, course_name: str):
+    requirements_path = (
+        f"formation/partie_{partie_id}/module_{module_id}/requirements.txt"
+    )
+
+    _download_github_file("iid-ulaval", course_name, requirements_path)
+
+
+def _download_module_files(partie_id: int, module_id: int, course_name: str):
+    folder_path = f"formation/partie_{partie_id}/module_{module_id}/fichiers"
+
+    _download_github_folder("iid-ulaval", course_name, folder_path)
+
+
+def _download_github_folder(
+    repo_owner, repo_name, folder_path, output_dir=".", branch="main"
+):
+    # GitHub API URL for repository contents
+    api_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/contents/{folder_path}?ref={branch}"
+
+    response = requests.get(api_url)
+
+    # We ignore 404 since some modules don't contain a resources folder
+    if response.status_code == 404:
+        return
+
+    if response.status_code != 200:
+        print(
+            f"Error: Unable to fetch folder contents. Status code: {response.status_code}"
+        )
+        print(response.json().get("message", ""))
+        return
+
+    items = response.json()
+
+    # Create the local target directory if it doesn't exist
+    local_folder_name = os.path.basename(folder_path.strip("/"))
+    target_dir = os.path.join(output_dir, local_folder_name)
+    os.makedirs(target_dir, exist_ok=True)
+
+    for item in items:
+        if item["type"] == "file":
+            file_name = item["name"]
+            download_url = item["download_url"]
+            file_path = os.path.join(target_dir, file_name)
+
+            _download_from_url(download_url, file_name, file_path)
+
+        elif item["type"] == "dir":
+            # Recursively handle subfolders
+            subfolder_path = f"{folder_path}/{item['name']}"
+            _download_github_folder(
+                repo_owner, repo_name, subfolder_path, target_dir, branch
+            )
+
+    print(f"Successfully downloaded folder to: {target_dir}")
+
+
+def _download_github_file(
+    repo_owner: str,
+    repo_name: str,
+    file_path: str,
+    output_dir: str = ".",
+    branch: str = "main",
+):
+    file_name = os.path.basename(file_path)
+
+    download_url = f"https://raw.githubusercontent.com/{repo_owner}/{repo_name}/{branch}/{file_path}"
+
+    file_path = os.path.join(output_dir, file_name)
+
+    _download_from_url(download_url, file_name, file_path)
+
+
+def _download_from_url(download_url: str, file_name: str, file_path: str):
+
+    file_response = requests.get(download_url)
+
+    if file_response.status_code == 200:
+        with open(file_path, "wb") as f:
+            f.write(file_response.content)
+
+        print(f"Downloaded: {file_name}...")
+
+    # We ignore 404 since some modules don't contain a requirements file
+    elif file_response.status_code == 404:
+        pass
+    else:
+        print(f"Failed to download file: {file_name}")