imicpe 0.0.9__py3-none-any.whl

imicpe/optim/__init__.py

@@ -0,0 +1,8 @@
+from .metrics import mse, snr
+from .operators import Id, D, Dt, L, Lt, generateDiff3D, generatePSF, A, At, S, St, opNorm, matNorm
+from .pnnDataset import BSDSDataset, NoisyDataset
+from .pnnTrainer import Trainer, Metrics
+from .pnnUtils import chooseDevice, torchImg2Numpy, getData
+
+import os
+cameraman = os.path.join(os.path.dirname(__file__), 'cameraman.tif')

imicpe/optim/metrics.py

@@ -0,0 +1,9 @@
+import numpy as np
+import torch
+
+def mse(I,ref):
+    return np.round(np.sum((I-ref)**2)/I.size,2)
+
+def snr(I,ref):
+    return np.round(10* np.log10(np.sum(ref**2)/np.sum((I-ref)**2)),2)
+

imicpe/optim/operators.py

@@ -0,0 +1,369 @@
+
+import numpy as np
+from scipy import ndimage
+import igl
+
+############################################################
+## identity operator
+############################################################
+def Id(x):
+    """
+    Id       Opérateur identité
+   
+    Args:
+        X (numpy.ndarray)               signal 1D
+                                    ou: image non vectorisée 2D
+                                
+    Returns: 
+        (numpy.ndarray)                  X 
+    """
+    
+    return x
+
+
+############################################################
+## differential forward and backward operators
+############################################################
+# gradient
+def D(x):
+    """
+    D       Calcule le gradient par différences finies à droite.
+    Autrement dit, D(x) calcule le produit matriciel Dx.
+   
+    Args:
+        X (numpy.ndarray)               signal 1D
+                                    ou: image non vectorisée 2D
+                                
+    Returns: 
+        (numpy.ndarray)                 Gradient de X 
+    """
+    
+    if x.ndim == 1:
+        grad = np.concatenate((x[1:] - x[:-1], [0]))/2.
+
+    elif x.ndim == 2:
+        sz = x.shape
+        Dx_im = np.concatenate((  x[:,1:] - x[:,:-1] , np.zeros((sz[0],1)) ), axis=1)/ 2.
+        Dy_im = np.concatenate((  x[1:,:] - x[:-1,:] , np.zeros((1,sz[1])) ), axis=0)/ 2.
+        
+        grad = np.array([Dx_im,Dy_im])
+    return grad
+
+def Dt(x):
+    """
+    Dt       Calcule l’adjoint gradient par différences finies à droite.
+    Autrement dit, Dt(x) calcule le produit matriciel D'x.
+   
+    Args:
+        X (numpy.ndarray)               signal 1D
+                                    ou: image non vectorisée 2D
+                                
+    Returns: 
+        (numpy.ndarray)                 Divergence de X 
+    """
+    
+    if x.ndim == 1:
+        div = - np.concatenate(([x[0]], x[1:-1] - x[:-2], [-x[-2]])) /2.
+
+    elif x.ndim == 3:
+        x1 = x[0]
+        x2 = x[1]
+        div = - np.concatenate((x1[:,[0]], x1[:,1:-1] - x1[:,:-2], -x1[:,[-2]]), axis=1) /2. \
+              - np.concatenate((x2[[0],:], x2[1:-1,:] - x2[:-2,:], -x2[[-2],:]), axis=0) /2.
+    return div
+
+# laplacian
+def L(x):
+    """
+    L        Calcule la dérivée seconde d’un signal, ou le laplacien dans le cas d’une image.
+    Autrement dit, L(x) calcule le produit matriciel Lx.
+   
+    Args:
+        X (numpy.ndarray)               signal 1D
+                                    ou: image non vectorisée 2D
+                                
+    Returns: 
+        (numpy.ndarray)                 Laplacien de X 
+    """
+    
+    if x.ndim == 1:
+        ker = np.array([1, -2, 1])
+        #lap = np.convolve(x,ker,'same')
+        lap = ndimage.convolve1d(x,ker,mode='nearest')
+    elif x.ndim == 2:
+        ker = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])    # V4
+        #ker = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]])    # V8
+        lap = ndimage.convolve(x,ker,mode='nearest')
+    return lap
+
+def Lt(x):
+    """
+    Lt       Calcule l’adjoint du laplacien.
+    Autrement dit, Lt(x) calcule le produit matriciel L'x.
+   
+    Args:
+        X (numpy.ndarray)               signal 1D
+                                    ou: image non vectorisée 2D
+                                
+    Returns: 
+        (numpy.ndarray)                 Adjoint du Laplacien de X 
+    """
+    
+    if x.ndim == 1:
+        ker = np.array([1, -2, 1])
+        #lap = np.correlate(x,ker,'same')
+        lap = ndimage.correlate1d(x,ker,mode='nearest')
+    elif x.ndim == 2:
+        ker = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])    # V4
+        #ker = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]])    # V8
+        lap = ndimage.correlate(x,ker,mode='nearest')
+    return lap
+
+def generateDiff3D(vert, faces, dtype):
+    """
+    generateDiff3D       Génère la matrice de différentiation de type DTYPE (ordre 1 ou 2) en 3D
+    
+    Args:
+        VERT (numpy.ndarray)            matrice Nx3 dont la i-ème ligne correspond au vecteur
+                                            de coordonnées (X,Y,Z) du i-ème point du maillage
+        FACES (numpy.ndarray)           matrice Nx3 dont la i-ème ligne donne les  numéros des
+                                            3 points composant un triangle du maillage
+        DTYPE(str)                      'gradient', 'laplacian'
+    
+    Returns:
+        (numpy.ndarray)                 matrice 3D de différentiation de type DTYPE
+    """
+    
+    if dtype == 'gradient':
+        matG = igl.grad(vert, faces)
+    elif dtype == 'laplacien':    
+        matG = igl.cotmatrix(vert, faces)
+    
+    return (matG/np.amax(matG)).toarray()
+
+
+
+############################################################
+## blurring operators
+############################################################
+def generatePSF(dim,blurtype,kernelSize):
+    """
+    generatePSF         Génère le noyau de convolution d’un flou de dimension DIM, de type BLURTYPE, 
+    et de taille KERNELSIZE.
+    
+    Args:
+        DIM (str)                       ’1D’ ou ’2D’
+        BLURTYPE (str)                  ’none’, ’gaussian’ ou ’uniform’
+        KERNELSIZE (int)                entier impair
+                                
+    Returns: 
+        (numpy.ndarray)                 Noyau de convolution
+    
+    -> voir les fonctions A(x,h) et At(x,h).
+    """
+
+    # compute kernel
+    if blurtype == 'none':
+        h = np.array([1.])
+
+    elif blurtype == 'gaussian':
+        std = kernelSize/6
+        x = np.linspace(-(kernelSize-1)/2, (kernelSize-1)/2, kernelSize)
+        arg = -x**2/(2*std**2)
+        h = np.exp(arg)
+
+    elif blurtype == 'uniform':
+        h = np.ones(kernelSize)
+    
+    # kernel normalization
+    h = h/sum(h)
+
+    # return kernel
+    if dim == '1D':
+        ker = h
+    elif dim == '2D':
+        ker = np.tensordot(h,h, axes=0)
+    
+    return ker 
+
+def A(x,psf):
+    """
+    A       Permet de flouter l’image X par un flou de noyau PSF.
+    Autrement dit, A(x,h) calcule le produit de convolution h*x, ou de manière équivalente, calcule
+    le produit matriciel Hx.
+
+    Args:
+        X (numpy.ndarray)               signal 1D
+                                    ou: image non vectorisée 2D
+        PSF (numpy.ndarray)             doit être générée à partir de la fonction generatePSF
+
+    Returns:
+        (numpy.ndarray)                 Convolution de X par le noyau PSF
+    """
+    
+    if x.ndim == 1:
+        b = np.convolve(x,psf,'same')
+    elif x.ndim == 2:
+        b = ndimage.convolve(x,psf,mode='nearest')
+
+    return b
+
+def At(x,psf):
+    """
+    At      Permet de flouter l’image X par un flou de noyau la transposée de PSF.
+    Autrement dit, A(x,h) calcule le produit de convolution h'*x, ou de manière équivalente, calcule
+    le produit matriciel H'x.
+
+    Args:
+        X (numpy.ndarray)               signal 1D
+                                    ou: image non vectorisée 2D
+        PSF (numpy.ndarray)             doit être générée à partir de la fonction generatePSF
+
+    Returns:
+        (numpy.ndarray)                 Correlation de X par le noyau PSF
+    """
+    
+    if x.ndim == 1:
+        b = np.correlate(x,psf,'same')
+    elif x.ndim == 2:
+        b = ndimage.correlate(x,psf,mode='nearest')
+
+    return b
+
+
+
+############################################################
+## TP3 - cartoon + texture decomposition operators (only 2D)
+############################################################
+def S(x):
+    """
+    S       Convolue X avec un noyau KER.
+   
+    Args:
+        X (numpy.ndarray)               image non vectorisée 2D
+                                
+    Returns: 
+        (numpy.ndarray)                 Convolution de X par le noyau KER
+    """
+    
+    h,w = x.shape
+    
+    ox = np.linspace(-w/2+1/2, w/2-1/2, w)
+    oy = np.linspace(-h/2+1/2, h/2-1/2, h)
+    X,Y = np.meshgrid(ox, oy)
+    dist  = np.sqrt(X**2/w**2 + Y**2/h**2);         # anisotropic distance
+    n  = 5
+    fc = 1/3                                        # in [0,1] since dist is normalized
+    ker  = 1./(1 + (dist/fc)**(2*n))
+
+    imf = np.real(np.fft.ifft2(np.fft.ifftshift(ker*np.fft.fftshift(np.fft.fft2(x)))))
+
+    return imf
+
+def St(x):   
+    """
+    S       Corrèle X avec un noyau KER.
+   
+    Args:
+        X (numpy.ndarray)               image non vectorisée 2D
+                                
+    Returns: 
+        (numpy.ndarray)                 Correlation de X par le noyau KER
+    """
+    
+    h,w = x.shape
+    
+    ox = np.linspace(-w/2+1/2, w/2-1/2, w)
+    oy = np.linspace(-h/2+1/2, h/2-1/2, h)
+    X,Y = np.meshgrid(ox, oy)
+    dist  = np.sqrt(X**2/w**2 + Y**2/h**2);         # anisotropic distance
+    n  = 5
+    fc = 1/3                                        # in [0,1] since dist is normalized
+    ker  = 1./(1 + (dist/fc)**(2*n))
+
+    imf = np.real(np.fft.ifft2(np.fft.ifftshift(np.conj(ker)*np.fft.fftshift(np.fft.fft2(x)))))
+
+    return imf
+
+
+
+############################################################
+## Operator and matrix norm
+############################################################
+def opNorm(op,opt,dim):
+    """
+    opNorm      Calcule la norme de l'opérateur OP, dont 
+    l'opérateur transposé est OPT, en dimension DIM
+
+    Args:
+        OP (function)                   opérateur direct
+        OPT (function)                  opérateur adjoint
+        DIM (str)                       '1D', '2D'
+        
+    Returns:
+        (float)                         norme de l'opérateur OP
+    """
+    
+    def T(x):
+        return opt(op(x))
+
+    if dim == '1D':  
+        xn = np.random.standard_normal((64))
+    elif dim == '2D':
+        xn = np.random.standard_normal((64,64))
+
+    xnn = xn
+
+    n = np.zeros((1000,),float)
+    n[1] = 1
+    tol  = 1e-4
+    rhon = n[1]+2*tol
+
+    k = 1
+    while abs(n[k]-rhon)/n[k] >= tol:
+        xn  = T(xnn)
+        xnn = T(xn)
+
+        rhon   = n[k]
+        n[k+1] = np.sum(xnn**2)/np.sum(xn**2)
+   
+        k = k+1
+
+    N = n[k-1] + 1e-16
+    return 1.01* N**(.25)              # sqrt(L) gives |||T|||=|||D'D||| ie |||D|||^2
+
+
+def matNorm(M):
+    """
+    matNorm      Calcule la norme de la matrice M
+
+    Args:
+        M (numpy.ndarray)               matrice dont on souhaite calculer la norme
+        
+    Returns:
+        (float)                         norme de la matrice M
+    """
+    
+    def T(x):
+        return np.dot(M.T, np.dot(M,x))
+
+    xn = np.random.standard_normal((M.shape[1]))
+    xnn = xn
+
+    n = np.zeros((1000,),float)
+    n[1] = 1
+    tol  = 1e-4
+    rhon = n[1]+2*tol
+
+    k = 1
+    while abs(n[k]-rhon)/n[k] >= tol:
+        xn  = T(xnn)
+        xnn = T(xn)
+
+        rhon   = n[k]
+        n[k+1] = np.sum(xnn**2)/np.sum(xn**2)
+   
+        k = k+1
+
+    N = n[k-1] + 1e-16
+    return 1.01* N**(.25)              # sqrt(L) gives |||T|||=|||D'D||| ie |||D|||^2

imicpe/optim/pnnDataset.py

@@ -0,0 +1,122 @@
+import torch
+from torch import Generator
+from torch.utils.data import Dataset, TensorDataset
+from torchvision.transforms import ToTensor
+
+from PIL import Image
+
+from pathlib import Path
+
+
+
+""" dataset classes """
+class BSDSDataset(Dataset):
+    def __init__(self, root_dir="data/bsds500", mode="train",
+                 image_size=(256, 256), image_cnt=None,
+                 gray=False, device="cpu"):
+        """ BSDS500 Dataset construction
+
+        Parameters
+        ----------
+        root_dir: str or Path object
+            Local path to the dataset
+        mode: str
+            Dataset type: "train", "val" or "test"
+        image_size: tuple of int
+            Crop the image to the given size
+        image_cnt: int
+            If specified, extract at most the given number of images
+        gray: bool
+            If True, convert images to grayscale
+        device: str or torch.device
+            Device where the dataset is created
+        """
+
+        # Properties
+        self.root_dir = Path(root_dir)
+        self.mode = mode
+        self.image_size = image_size
+        self.gray = gray
+        self.device = device
+
+        # Create the list of corresponding images (sorted for reprocibility purpose)
+        self.image_list = sorted((self.root_dir / self.mode).glob("*.jpg"))
+        if image_cnt is not None:
+            self.image_list = self.image_list[:image_cnt]
+            
+    def __repr__(self):
+        """ Nice representation when displaying the variable """
+        return f"BSDSDataset(mode={self.mode}, image_size={self.image_size})"
+
+    def __len__(self):
+        """ Number of samples """
+        return len(self.image_list)
+
+    def __getitem__(self, idx):
+        """ Reading a sample """
+
+        # set image path and id
+        image_path = self.image_list[idx]
+        image_id   = int(image_path.stem)
+
+        # load and crop clean image
+        clean_image = Image.open(image_path).convert('RGB')
+        i = max(0, (clean_image.size[0] - self.image_size[0]) // 2)
+        j = max(0, (clean_image.size[1] - self.image_size[1]) // 2)
+        clean_image = clean_image.crop([
+            i, j,
+            min(clean_image.size[0], i + self.image_size[0]),
+            min(clean_image.size[1], j + self.image_size[1]),
+        ])
+        clean_image = ToTensor()(clean_image).to(self.device) # move to the requested device
+
+        # optional conversion to grayscale
+        if self.gray:
+            clean_image = clean_image.mean(-3, keepdim=True)
+
+        return clean_image, image_id
+
+
+class NoisyDataset(Dataset):
+    def __init__(self, dataset, degradation_model, sigma=0.1, seed=None):
+        """ Noisy Dataset construction
+
+        Parameters
+        ----------
+        dataset: torch.utils.data.Dataset
+            Original BSDS dataset
+        degradation_model: function handle
+            Function modeling the degradation model
+        sigma: float
+            Standard deviation of the noise (default: 0.1)
+        seed: int
+            If specified, the whole dataset is reproductible with given seed.
+        """
+        self.dataset = dataset
+        self.degradation_model = degradation_model
+        self.sigma = sigma
+        self.seed = seed if seed is not None else Generator().seed()
+
+    def __repr__(self):
+        return f"NoisyDataset(dataset={self.dataset}, sigma={self.sigma})"
+
+    def __len__(self):
+        return len(self.dataset)
+
+    def __getitem__(self, idx):
+        clean_image, image_id = self.dataset[idx]
+
+        # generate noisy image
+        noisy_image = self.degradation_model(clean_image, self.sigma, seed=self.seed)
+
+        return noisy_image, clean_image, int(image_id)
+    
+
+    def toTensorDataset(self):
+        """ Store the whole dataset in memory """
+        noised_images, clean_images, images_id = zip(*self)
+        return TensorDataset(
+            torch.stack(noised_images),
+            torch.stack(clean_images),
+            torch.tensor(images_id),
+        )

imicpe/optim/pnnTrainer.py

@@ -0,0 +1,137 @@
+import torch
+from torch.utils.data import DataLoader
+
+from tqdm.notebook import tqdm
+import time
+
+
+""" Trainer class """
+class Trainer():
+    def __init__(self,
+                 model, optimizer, loss,
+                 batch_size,
+                 train_dataset, val_dataset=None, 
+                 check_val_every_n_epoch=1):
+        
+        self.model = model
+        self.optimizer = optimizer
+        self.loss = loss
+        self.batch_size = batch_size
+        self.train_dataloader = train_dataset
+        self.val_dataloader = val_dataset
+        self.check_val_every_n_epoch = check_val_every_n_epoch
+        self.metrics = Metrics()
+        self.history = {}
+        self.epoch = 0
+        
+        # dataloaders
+        self.train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) 
+        if self.val_dataloader is None:
+            self.val_dataloader = None
+        else:
+            self.val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True)
+
+    def run(self, num_epoch):
+        """ Run training until the given number of epochs is reached """
+        try:
+            # progress bar
+            training_pbar = tqdm(
+                iterable=range(self.epoch, num_epoch),
+                initial=self.epoch,
+                total=num_epoch,
+                desc="Training",
+                unit="epoch"
+            )
+
+            for _ in training_pbar:
+                self.training_epoch()
+                training_pbar.set_postfix(self.history["Training"][-1][1])
+                if self.epoch % self.check_val_every_n_epoch == 0:
+                    self.validation_epoch()
+                    epoch, metrics = self.history["Validation"][-1]
+                    print(f"Validation epoch {epoch:4d} | " + " | ".join((f"{k}: {v:.2e}" for k, v in metrics.items())))
+
+
+        except KeyboardInterrupt:
+            """ Stop training if Ctrl-C is pressed """
+            pass
+
+    def training_epoch(self):
+        """ Train for one epoch """
+        device = self.device
+        self.metrics.init()
+        for x, target, *_ in self.train_dataloader:
+            x = x.to(device)
+            target = target.to(device)
+
+            y = self.model(x)
+            loss = self.loss(y, target)
+            self.optimizer.zero_grad()
+            loss.backward()
+            self.optimizer.step()
+
+            self.metrics.accumulate(loss, x, y, target)
+
+        self.epoch += 1
+        self.log("Training", self.epoch, self.metrics.summarize())
+
+
+    def validation_epoch(self):
+        """ Run a validation step """
+        if self.val_dataloader is None:
+            return
+
+        device = self.device
+        self.metrics.init()
+        with torch.no_grad():
+            for x, target, *_ in self.val_dataloader:
+                x = x.to(device)
+                target = target.to(device)
+
+                y = self.model(x)
+                loss = self.loss(y, target)
+
+                self.metrics.accumulate(loss, x, y, target)
+
+        self.log("Validation", self.epoch, self.metrics.summarize())
+
+    def log(self, mode, epoch, metrics):
+        history = self.history.setdefault(mode, [])
+        history.append((epoch, metrics))
+        #print(f"{mode} epoch {epoch:4d} | " + " | ".join((f"{k}: {v:.2e}" for k, v in metrics.items())))
+
+    @property
+    def device(self):
+        """ Training device defined from the device of the first parameter of the model """
+        return next(self.model.parameters()).device
+
+
+
+
+class Metrics:
+    """ Compute metrics from training and validation steps """
+    def init(self):
+        self.metrics = dict()
+        self.cnt = 0
+        self.tic = time.perf_counter()
+
+    def accumulate(self, loss, x, y, target):
+        with torch.no_grad():
+            self.metrics["Loss"] = self.metrics.get("Loss", 0) + loss.item()
+            self.metrics["PSNR"] = self.metrics.get("PSNR", 0) + self.__PSNR__(y, target).mean().item()
+        self.cnt += 1
+
+    def summarize(self):
+        self.toc = time.perf_counter()
+        metrics = {k: v / self.cnt for k, v in self.metrics.items()}
+        metrics["Wall time"] = self.toc - self.tic
+        return metrics
+    
+    def __PSNR__(self, img1, img2):
+        # optional: get last 3 dimensions (CxNxM) to ensure compatibility with a single sample
+        dims = list(range(max(0, img1.ndim - 3), img1.ndim))
+        # otherwise:
+        #dims = list(range(1, img1.ndim))
+
+        # necessity to take the mean along only the last 3 dimensions
+        return 10 * torch.log10(1. / (img1 - img2).pow(2).mean(dims))

imicpe/optim/pnnUtils.py

@@ -0,0 +1,52 @@
+import torch
+
+
+def chooseDevice(device=None):
+    if device == None:
+        # setting device on GPU if available, else MPS (Apple M1) or CPU
+        if torch.cuda.is_available():
+            device = torch.device('cuda') # CUDA backend for NVIDIA or AMD graphic cards
+        else:
+            try:
+                if torch.backends.mps.is_available():
+                    device = torch.device('mps') # MPS for Apple M# processors
+                else:
+                    device = torch.device('cpu')
+            except AttributeError:
+                device = torch.device('cpu')
+    else:
+        device = torch.device(device)
+    
+    print('Using device:', device)
+    print()
+
+    # additional info when using cuda
+    if device.type == 'cuda':
+        print(torch.cuda.get_device_name(0))
+        print('Memory Usage:')
+        print('Allocated:', round(torch.cuda.memory_allocated(0)/1024**3,1), 'GB')
+        print('Cached:   ', round(torch.cuda.memory_reserved(0)/1024**3,1), 'GB')
+
+    return device
+
+
+
+def torchImg2Numpy(image):
+    # reorder dimensions (C, N, M) -> (M, N, C) and move to CPU
+    image = torch.moveaxis(image, [0, 1, 2], [2, 0, 1]).to('cpu')
+
+    if image.shape[-1] == 1:
+        image = image[..., 0]
+
+    return image.numpy()
+
+
+def getData(trainer, mode):
+    data = dict()
+    for epoch, record in trainer.history[mode]:
+        data.setdefault("epoch", []).append(epoch)
+        for metric, value in record.items():
+            data.setdefault(metric, []).append(value)
+
+    return data
+

imicpe-0.0.9.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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.

imicpe-0.0.9.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: imicpe
+Version: 0.0.9
+Summary: Toolbox for Maths,Signal,Image Teaching @ CPE
+Author-email: Marion Foare <marion.foare@cpe.fr>, Eric Van Reeth <eric.vanreeth@cpe.fr>, Arthur Gautheron <arthur.gautheron@cpe.fr>
+License: MIT License
+Project-URL: Homepage, https://www.cpe.fr
+Project-URL: Documentation, https://toolbox-imi-cpe-msi-1bcfcdd75992c038486502447f7f6937f3492f60127.pages.in2p3.fr/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+A toolbox used for practical sessions at [CPE Lyon](https://www.cpe.fr/).
+Developped and maintained for teaching usage only!
+
+# Installation
+
+## In a Jupyter Notebook
+
+```!pip install -i https://test.pypi.org/simple/ -U imicpe```
+
+## In a local environment
+
+```pip install -i https://test.pypi.org/simple/ -U imicpe```
+
+# Usage example
+
+The example below uses the kurtosis method available in the `tsa` subpackage of `msicpe`.
+It requires `numpy.randn` to generate a gaussian distribution of N points.
+
+```python
+import numpy as np
+from msicpe.tsa import kurtosis
+N=10000
+
+x=np.randn(1,N)
+kurt=kurtosis(x)
+
+print(kurt)
+```

imicpe-0.0.9.dist-info/RECORD

@@ -0,0 +1,12 @@
+imicpe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imicpe/optim/__init__.py,sha256=m3A1xTbMnHMqOx8EFWi71BRyVmlCdVL4qtNYWct0rjQ,360
+imicpe/optim/metrics.py,sha256=AHqudKDch1_jc7X2_9hz30RamEqfQ132GXr3qW81VPY,187
+imicpe/optim/operators.py,sha256=xYhXc4CSA6MN1mlsaS3LnvIIOBIu-OjY3uVA8liuTgc,10859
+imicpe/optim/pnnDataset.py,sha256=PFh5u0SXx761O6N6vVfWfEDmzmCm87eYzAL7mWHBRrw,3971
+imicpe/optim/pnnTrainer.py,sha256=3ygh9XwFJN7jMPsEG3LHLa8sgBbDd9Yu_QWg4ZtM_DM,4571
+imicpe/optim/pnnUtils.py,sha256=LXU7wRfuEi6t-2VG2NStPAOzu19OKTxzNNnbHESpC2U,1523
+imicpe-0.0.9.dist-info/LICENSE,sha256=ACwmltkrXIz5VsEQcrqljq-fat6ZXAMepjXGoe40KtE,1069
+imicpe-0.0.9.dist-info/METADATA,sha256=05KEy34rdvtqfn10vIYHe7wc9Aq-eP8G3hX3EImLN6M,1272
+imicpe-0.0.9.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
+imicpe-0.0.9.dist-info/top_level.txt,sha256=6_gSXCYolzjXHaIDeAsZ_M3nLXdqrMKt48XCz3reJc0,7
+imicpe-0.0.9.dist-info/RECORD,,

imicpe-0.0.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

imicpe-0.0.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+imicpe