imicpe 0.0.9.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

imicpe/_version.py

@@ -1 +1 @@
-__version__="0.0.9.5"
+__version__="1.0.0"

imicpe/cs/__init__.py

@@ -0,0 +1,9 @@
+from .metrics import mse, snr
+from .operators import fwt, iwt, fwt2, iwt2
+from .tikhonov import tikhonov
+from .l1 import l1
+from .shepp_logan_phantom import phantom_shepp_logan
+from .masks import mat2mask, starPattern, getAcquisitionImage  #, sub2ind, ind2sub
+
+import os
+cameraman = os.path.join(os.path.dirname(__file__), 'cameraman.tif')

imicpe/cs/l1.py

@@ -0,0 +1,111 @@
+
+import numpy as np
+from scipy import ndimage
+
+from .operators import *
+from tqdm import tqdm_notebook as tqdm
+
+def l1(opreg,A,At,z,x0,lam):
+    """
+    l1       Algorithme Forward-Backward pour résoudre le problème
+                xhat = argmin  ||Hx-z||_2^2 + lam.||Gx||_1
+                        x
+    
+    en particulier : 
+    - le modèle LASSO si G = Id,
+    - le modèle TV si G = D (gradient) ou L (laplacien),
+   
+    Args:
+        opreg (string)              nom de l'opérateur G sur lequel opère la contrainte de parcimonie {'id', 'gradient', 'laplacien'}
+        A (fonction)    
+        At (fonction)
+        z
+        x0 (numpy.ndarray)
+        lam (float)
+                                
+    Returns: 
+        xhat (numpy.ndarray)        solution du problème
+        loss (numpy.ndarray)        évolution de la fonction de coût au cours des itérations
+    """
+    
+    print('Running l1 model with ' +opreg+ ' sparsity constraint...\n\t')
+    
+    ### init ###
+    dim = x0.ndim
+    match opreg:
+        case 'id':
+            G = Id
+            Gt = Id
+        case 'gradient':
+            G = D
+            Gt = Dt
+        case 'laplacien':
+            G = L
+            Gt = Lt
+    
+    # operator norms
+    lipA = opNorm(A,At,dim,x0)
+    lipG = opNorm(G,Gt,dim,x0)   
+
+    # cost functions
+    def f(x):           # data fidelity
+        return np.sum(x**2)/2
+
+    def R(x):           # regularization
+        return np.sum(np.abs(x))
+    
+    def E(x,lam):       # total cost
+        return f(A(x)-z) + lam*R(G(x))
+
+    # proximity operator
+    def proxl1(x,gam):
+        return x - np.maximum(np.minimum(x,gam*np.ones(x.shape)),-gam*np.ones(x.shape))
+
+    ### Algo ###
+    niter       = 1e3;                                  # max number of iterations
+    # model hyperparameters
+    mu    = 5;                                          # Bregman parameter (in [1,10], should not vary)
+    
+    # algo hyperparameters
+    gamx  = .9/(lipA**2 + mu*lipG**2); #.5e-1;          # gradient descent step (x subproblem)
+    gamu  = 1/mu;                                       # proximal descent step (y subproblem)
+    
+    # initialize variables
+    En = np.zeros((int(niter+1),),float) * np.nan
+    xn = x0   #np.random.standard_normal((z.shape))
+    un = G(xn)                                          # splitting variable
+    bn = np.zeros(un.shape,float)                       # Bregman variable
+    
+    En[0] = E(xn,lam)
+
+    # loop parameters
+    k         = 0
+    tol       = 1e-10
+    stop_crit = En[0]
+    
+  
+    with tqdm(total=niter) as pbar: 
+        while (k < niter) and (stop_crit > tol):
+            # yn subproblem
+            Gxn = G(xn)
+            un = proxl1(un - gamu*mu*(un-Gxn-bn/mu) , lam*gamu)
+            
+            # xn subproblem (relaxed): gradient descent step instead of GS iteration
+            xn = xn - gamx*( At(A(xn)-z) - mu*Gt(un-Gxn-bn/mu) )
+
+            # bn subproblem
+            bn = bn - mu*(un-G(xn))
+            
+            # compute loss
+            En[k+1] = E(xn,lam)
+            
+            # update loop parameters
+            stop_crit = (En[k] - En[k+1])/En[k]
+            k += 1
+            pbar.update(1)
+    
+    pbar.close()
+    xhat = xn
+    loss = En
+    
+    return xhat, loss

imicpe/cs/masks.py

@@ -0,0 +1,80 @@
+
+import numpy as np
+from scipy import ndimage
+import pywt
+
+
+mat2mask = lambda mat, H, W, M:  np.reshape(mat.T, (H, W, M))
+
+    
+def starPattern(N, M):
+    """
+    starPattern       Génère un masque de taille NxN en étoile (tomographie) correspondant à M mesures.
+
+    Args:
+    N (int)                    Taille du masque
+    M (int)                    Nombre de mesures
+
+    Returns: 
+    Amat (numpy.ndarray)       Matrice d'acquisition
+    mask (numpy.ndarray)       Masque 
+    """
+    
+
+    mask2mat = lambda mask: np.reshape(mask,  (M, N**2))  
+     
+    H = int(N)
+    W = int(N)
+    
+    n = int(N)
+    r = np.linspace(-1, 1, 3*n)*n
+
+    nrho = 2**4
+    R = np.round(np.linspace(-n/2, n/2, nrho))#.astype(int)
+
+    ntheta = M//nrho
+    T = np.linspace(0, np.pi, ntheta+1, endpoint=False)
+
+    mask = np.zeros((H, W, ntheta, nrho))
+    for itt in range(ntheta):
+        theta = T[itt]
+            
+        for itr in range(nrho):
+            rho = R[itr]
+                
+            x = np.round(r*np.cos(theta) + n/2 - rho*np.sin(theta))#.astype(int)
+            y = np.round(r*np.sin(theta) + n/2 + rho*np.cos(theta))#.astype(int)
+
+            valid = np.where((x >= 0) & (x < n) & (y >= 0) & (y < n))
+            x = x[valid].astype(int)
+            y = y[valid].astype(int)
+
+            tmpM = np.zeros((H, W))
+            tmpM[y, x] = 1
+ 
+            mask[:, :, itt, itr] = tmpM
+
+    mask = mask.reshape((H, W, M))
+    Amat = mask2mat(mask)
+        
+    return Amat, mask
+        
+        
+def getAcquisitionImage(x,mask):
+    _, _, Nmeasures = mask.shape
+    
+    zim = np.sum(mask * np.tile(x[..., None], (1, 1, Nmeasures)), axis=2)
+    zim = zim / np.max(zim)
+    
+    return zim
+
+
+
+# def sub2ind(array_shape, rows, cols):
+#     ind = rows*array_shape[1] + cols
+#     return ind.astype(int)
+
+# def ind2sub(array_shape, ind):
+#     rows = (ind.astype('int') / array_shape[1])
+#     cols = (ind.astype('int') % array_shape[1]) # or numpy.mod(ind.astype('int'), array_shape[1])
+#     return (int(rows), int(cols))

imicpe/cs/metrics.py

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

imicpe/cs/operators.py

@@ -0,0 +1,298 @@
+
+import numpy as np
+from scipy import ndimage
+import pywt
+
+
+############################################################
+## 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
+
+
+############################################################
+## Wavelet transforms
+############################################################
+def fwt(x,wavelet,level):
+    """
+    P       Calcule la transformée en ondelettes directe 1D.
+
+    Args:
+    x (numpy.ndarray)               signal 1D
+
+    Returns: 
+    (numpy.ndarray)                 Vecteur des coefficients de la décomposition en ondelettes de x
+    """
+
+    dim = x.ndim
+
+    coeffs = pywt.wavedec(x, wavelet, level=level, mode="periodization")
+    coeff_arr, _, _ = pywt.ravel_coeffs(coeffs)
+            
+    return coeff_arr
+
+
+def iwt(x,wavelet,level,coeffs_slices=None,coeffs_shapes=None,):
+    """
+    P       Calcule la transformée en ondelettes inverse 1D.
+
+    Args:
+    x (numpy.ndarray)               Vecteur des coefficients d'ondelettes                                          
+
+    Returns: 
+    (numpy.ndarray)                 Signal correspondant aux coefficients d'ondelettes donnés par x
+    """
+
+    J = level
+    N = len(x)
+    
+    if coeffs_shapes is None:
+        # compute coeffs size at each level
+        sizes = [N // (2**j) for j in range(J, 0, -1)] + [N // (2**J)]
+
+        # coefficients splitting
+        start = 0
+        coeffs = []
+        for size in reversed(sizes):
+            coeffs.append(x[start:start + size])
+            start += size
+    else:
+        coeffs = pywt.unravel_coeffs(x, coeffs_slices, coeffs_shapes, output_format='wavedec')
+
+    # reconstruct corresponding signal
+    signal = pywt.waverec(coeffs, wavelet, mode="periodization")
+            
+    return signal
+
+
+def fwt2(x,wavelet,level):
+    """
+    P       Calcule la transformée en ondelettes directe 2D.
+
+    Args:
+    x (numpy.ndarray)               image NON vectorisée 2D
+
+    Returns: 
+    (numpy.ndarray)                 Vecteur des coefficients de la décomposition en ondelettes de x
+    """
+
+    coeffs = pywt.wavedec2(x, wavelet, level=level, mode="periodization")
+    coeff_arr, _, _ = pywt.ravel_coeffs(coeffs)
+
+    return coeff_arr
+
+def iwt2(x,wavelet,level,coeffs_slices,coeffs_shapes):
+    """
+    P       Calcule la transformée en ondelettes inverse 2D.
+
+    Args:
+    x (numpy.ndarray)               Vecteur des coefficients d'ondelettes                                          
+
+    Returns: 
+    (numpy.ndarray)                 Image correspondante aux coefficients d'ondelettes donnés par x
+    """
+
+    J = level
+    N = len(x)
+    
+    coeffs = pywt.unravel_coeffs(x, coeffs_slices, coeffs_shapes,
+                                      output_format='wavedec2')
+    
+    # reconstruct corresponding signal
+    image = pywt.waverec2(coeffs, wavelet, mode="periodization")
+
+    return image
+
+
+############################################################
+## Operator and matrix norm
+############################################################
+def opNorm(op,opt,dim,xn):
+    """
+    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 (int)                       1 or 2
+        
+    Returns:
+        (float)                         norme de l'opérateur OP
+    """
+    
+    def T(x):
+        return opt(op(x))
+
+    # match dim:
+    #     case 1:  
+    #         xn = np.random.standard_normal((64))
+    #     case 2:
+    #         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/cs/shepp_logan_phantom.py

@@ -0,0 +1,21 @@
+
+import numpy as np
+
+from skimage.data import shepp_logan_phantom
+from skimage.transform import rescale, resize
+
+def phantom_shepp_logan(N):
+    """
+    phantom_shepp_logan       Génère le phantom de Shepp-Logan 2D de taille NxN.
+
+    Args:
+    N (int)                    Taille du phantom
+
+    Returns: 
+    (numpy.ndarray)           Image du phantom
+    """
+    p = shepp_logan_phantom()
+    p = resize(p, (int(N),int(N)), anti_aliasing=False)
+    p[p<1e-10] = .1
+    
+    return p

imicpe/cs/tikhonov.py

@@ -0,0 +1,95 @@
+
+import numpy as np
+from scipy import ndimage
+
+from .operators import *
+from tqdm import tqdm_notebook as tqdm
+
+def tikhonov(opreg,A,At,z,x0,lam):
+    """
+    tikhonov   Algorithme de descente de gradient pour résoudre le problème
+                xhat = argmin  ||Hx-z||_2^2 + lam.||Gx||_2^2
+                        x
+    
+   
+    Args:
+        opreg (string)              nom de l'opérateur G sur lequel opère la contrainte de parcimonie {'id', 'gradient', 'laplacien'}
+        A (fonction)    
+        At (fonction)
+        z
+        x0 (numpy.ndarray)
+        lam (float)
+                                
+    Returns: 
+        xhat (numpy.ndarray)        solution du problème
+        loss (numpy.ndarray)        évolution de la fonction de coût au cours des itérations
+    """
+    
+    print('Running Tikhonov model with ' +opreg+ ' sparsity constraint...\n\t')
+    
+    ### init ###
+    dim = x0.ndim
+    match opreg:
+        case 'id':
+            G = Id
+            Gt = Id
+        case 'gradient':
+            G = D
+            Gt = Dt
+        case 'laplacien':
+            G = L
+            Gt = Lt
+    
+    # operator norms
+    lipA = opNorm(A,At,dim,x0)
+    lipG = opNorm(G,Gt,dim,x0)   
+
+    # cost functions
+    def f(x):           # data fidelity
+        return np.sum(x**2)/2
+
+    def R(x):           # regularization
+        return np.sum(x**2)/2
+    
+    def E(x,lam):       # total cost
+        return f(A(x)-z) + lam*R(G(x))
+
+    # proximity operator
+    def proxl1(x,gam):
+        return x - np.maximum(np.minimum(x,gam*np.ones(x.shape)),-gam*np.ones(x.shape))
+
+    ### Algo ###
+    niter       = 1e3;                                  # max number of iterations
+    
+    # algo hyperparameters
+    gam  = .9/(2*lipA**2 + 2*lam*lipG**2);            # gradient descent step
+
+    # initialize variables
+    En = np.zeros((int(niter+1),),float) * np.nan
+    xn = x0   #np.random.standard_normal((z.shape))
+    
+    En[0] = E(xn,lam)
+
+    # loop parameters
+    k         = 0
+    tol       = 1e-10
+    stop_crit = En[0]
+    
+    with tqdm(total=niter) as pbar: 
+        while (k < niter) and (stop_crit > tol):
+            # xn subproblem
+            xn = xn - 2*gam*(At(A(xn)-z) + lam*Gt(G(xn)))
+                
+            # compute loss
+            En[k+1] = E(xn,lam)
+                
+            # update loop parameters
+            stop_crit = (En[k] - En[k+1])/En[k]
+            k += 1
+            pbar.update(1)
+    
+    pbar.close()
+    xhat = xn
+    loss = En
+    
+    return xhat, loss

{imicpe-0.0.9.5.dist-info → imicpe-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imicpe
-Version: 0.0.9.5
+Version: 1.0.0
 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
@@ -18,6 +18,8 @@ Requires-Dist: plotly
 Requires-Dist: torch
 Requires-Dist: torchvision
 Requires-Dist: tqdm
+Requires-Dist: PyWavelets
+Requires-Dist: scikit-image
 
 
 A toolbox used for practical sessions at [CPE Lyon](https://www.cpe.fr/).
@@ -36,7 +38,6 @@ Developped and maintained for teaching usage only!
 # Usage example
 
 The example below uses the mse method available in the `optim.metrics` subpackage of `imicpe`.
-It requires `numpy.randn` to generate a gaussian distribution of N points.
 
 ```python
 import numpy as np

imicpe-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+imicpe/__init__.py,sha256=WjDmvecyDIyJLYp4rCV9vsSYbQDc4L1EpYqORvEXliI,33
+imicpe/_version.py,sha256=xZawFFh80uj7MHMJJXWFcuzkX29fVkHuS5NT5dJMCf8,20
+imicpe/cs/__init__.py,sha256=fLe1o5jNvrB4qEVBE6amEV9i3NFwM3E_uGiiiHXrph0,339
+imicpe/cs/l1.py,sha256=3Bq3Ryk1mRAvti0lVR4u6Lj7aq2zr_Qxye0_doO8n_0,3266
+imicpe/cs/masks.py,sha256=5ehQ-QnYY4trBt7BIx0Pp8DUa3x5KApkc7TPp9LA9Pc,2030
+imicpe/cs/metrics.py,sha256=DuUYpW7s1LkZTDV32D5K4wdSRXpH1Ymunjp2vq6kzfA,148
+imicpe/cs/operators.py,sha256=r11Zvote0q4zcn_r_wRwcboKCNBNYwHY7wKrNcrfF30,8379
+imicpe/cs/shepp_logan_phantom.py,sha256=_RDHimZI6R8uyAwXNyB3BldYjCiNDRorDmPYoJR0T6Q,485
+imicpe/cs/tikhonov.py,sha256=6msVAXrzRBVHMIdh1mK6pf1zRjhnsdhDAQwEOpA-PuU,2518
+imicpe/optim/__init__.py,sha256=rkguPFq7gdmBgm_Xrry2yr1oquEIxE00On2emjRMgZE,344
+imicpe/optim/metrics.py,sha256=AHqudKDch1_jc7X2_9hz30RamEqfQ132GXr3qW81VPY,187
+imicpe/optim/operators.py,sha256=BbyqE9ARZF-q8EkxyDOv1V8Rlz52t9sbo2gI22zQAzA,10648
+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-1.0.0.dist-info/LICENSE,sha256=ACwmltkrXIz5VsEQcrqljq-fat6ZXAMepjXGoe40KtE,1069
+imicpe-1.0.0.dist-info/METADATA,sha256=mlyMGSScoX_Y8oN3l7Gp6u32-6J5Dpvynk6ao1qD29o,1317
+imicpe-1.0.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+imicpe-1.0.0.dist-info/top_level.txt,sha256=6_gSXCYolzjXHaIDeAsZ_M3nLXdqrMKt48XCz3reJc0,7
+imicpe-1.0.0.dist-info/RECORD,,

{imicpe-0.0.9.5.dist-info → imicpe-1.0.0.dist-info}/WHEEL

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

imicpe-0.0.9.5.dist-info/RECORD

@@ -1,13 +0,0 @@
-imicpe/__init__.py,sha256=WjDmvecyDIyJLYp4rCV9vsSYbQDc4L1EpYqORvEXliI,33
-imicpe/_version.py,sha256=jrzhItrMTlop270sQHhvNJ5msaGXzNktYThtUK1YOEA,22
-imicpe/optim/__init__.py,sha256=rkguPFq7gdmBgm_Xrry2yr1oquEIxE00On2emjRMgZE,344
-imicpe/optim/metrics.py,sha256=AHqudKDch1_jc7X2_9hz30RamEqfQ132GXr3qW81VPY,187
-imicpe/optim/operators.py,sha256=BbyqE9ARZF-q8EkxyDOv1V8Rlz52t9sbo2gI22zQAzA,10648
-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.5.dist-info/LICENSE,sha256=ACwmltkrXIz5VsEQcrqljq-fat6ZXAMepjXGoe40KtE,1069
-imicpe-0.0.9.5.dist-info/METADATA,sha256=KFIxIFaw_r0M9qZEbbWIN_hjARFtSh6_j1qAjr0DkEw,1340
-imicpe-0.0.9.5.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-imicpe-0.0.9.5.dist-info/top_level.txt,sha256=6_gSXCYolzjXHaIDeAsZ_M3nLXdqrMKt48XCz3reJc0,7
-imicpe-0.0.9.5.dist-info/RECORD,,