ksom 0.9.1__tar.gz

ksom-0.9.1/.gitignore

@@ -0,0 +1,2 @@
+*~
+__pycache__

ksom-0.9.1/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mathieu d'Aquin
+
+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.

ksom-0.9.1/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.3
+Name: ksom
+Version: 0.9.1
+Summary: Self Organising Maps in pytorch
+Project-URL: Homepage, https://github.com/mdaquin/ksom
+Project-URL: Issues, https://github.com/mdaquin/ksom/issues
+Author-email: Mathieu d'Aquin <mathieu.daquin.w+ksom@gmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# KSOM - Simple, but relatively efficient, pytorch-based self organising map
+
+This is a simple implementation of self-organising map training in python, using pytorch for efficiency. Check ``test-img.py`` for a simple use case creating a square color map of an image. To use, try
+```
+pip install -r requirements.txt
+```
+and then
+```
+python test/test_img.py chica.jpg 6
+```
+This shoud show an updating 6x6 map of the colours in the ``chica.jpg`` image. Change the image or the size of the map by changing the corresponding parameters.
+
+Another example is included in the ``test_cheese.py`` creating a map of cheeses based on various binary attributes.

ksom-0.9.1/README.md

@@ -0,0 +1,13 @@
+# KSOM - Simple, but relatively efficient, pytorch-based self organising map
+
+This is a simple implementation of self-organising map training in python, using pytorch for efficiency. Check ``test-img.py`` for a simple use case creating a square color map of an image. To use, try
+```
+pip install -r requirements.txt
+```
+and then
+```
+python test/test_img.py chica.jpg 6
+```
+This shoud show an updating 6x6 map of the colours in the ``chica.jpg`` image. Change the image or the size of the map by changing the corresponding parameters.
+
+Another example is included in the ``test_cheese.py`` creating a map of cheeses based on various binary attributes.

ksom-0.9.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ksom"
+version = "0.9.1"
+authors = [
+  { name="Mathieu d'Aquin", email="mathieu.daquin.w+ksom@gmail.com" },
+]
+description = "Self Organising Maps in pytorch"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/mdaquin/ksom"
+Issues = "https://github.com/mdaquin/ksom/issues"

ksom-0.9.1/src/ksom/__init__.py

@@ -0,0 +1,217 @@
+# Self-organising map pytroch model.
+# Author: Mathieu d'Aquin
+
+import torch
+from torch.nn import CosineSimilarity
+from torchmetrics.functional import pairwise_cosine_similarity
+import math
+import numpy as np
+
+def euclidean_distance(x,y):
+    """returns a distance matrix between the elements of
+    the tensor x and the ones of the tensor y"""
+    return torch.cdist(x,y,2)
+
+def cosine_distance(x,y):
+    """returns a distance matrix between the elements of 
+    the tensor x and the ones of the tensor y"""
+    return 1 - pairwise_cosine_similarity(x,y)
+
+# TODO: #13 this does not seem to work...
+def nb_ricker(node, dims, coord, nb):
+    """
+    Ricker wavelet (mexican hat) neighborhood weights between between node (x,y) 
+    and all the coordinates in the tensor coord ([(x,y)]) assuming
+    it follow the dimensions in dims (height, width).
+    nb is the neighborhood radius (i.e. the distance after which 
+    the function returns 0).
+    """
+    # if nb < 1.0: nb = 1.0 # seem to make no difference...
+    nodes = node.repeat(dims[0]*dims[1], 1)
+    dist = torch.nn.functional.pairwise_distance(nodes, coord)
+    dist[int(node[0]*dims[0])+node[1]%dims[0]] = 0.0
+    FM = (math.sqrt(6)/(math.pi*(2*nb)))/math.sqrt(3)
+    fbit = (1-2*math.pi**2*FM**2*dist**2)
+    sbit = -math.pi**2*FM**2*dist**2
+    return fbit*torch.exp(sbit)
+
+def nb_gaussian(node, dims, coord, nb):
+    """
+    Gaussian neighborhood weights between between node (x,y) 
+    and all the coordinates in the tensor coord ([(x,y)]) assuming
+    it follow the dimensions in dims (height, width).
+    nb is the neighborhood radius (i.e. the distance after which 
+    the function returns 0).    
+    """
+    # exp(-(x/(nb/2))**2)
+    nodes = node.repeat(dims[0]*dims[1], 1)
+    dist = torch.nn.functional.pairwise_distance(nodes, coord)
+    dist[int(node[0]*dims[0])+node[1]%dims[0]] = 0.0
+    ret = torch.exp(-(dist/(nb/2))**2)
+    ret[ret < 0] = 0.0
+    return ret    
+
+def nb_linear_o(node1, node2, nb):
+    """deprecated non-batch versoin of the linear
+    neighborhood function"""
+    if node1[0] == node2[0] and node1[1] == node2[1]: return 1.0
+    dist = euclidean_distance(node1.view(-1, 2).to(torch.float32),
+                              node2.view(-1, 2).to(torch.float32))[0][0]
+    return max(0,1-(dist/nb))
+
+def nb_linear(node, dims, coord, nb):
+    """linear neighborhood distances between node (x,y) 
+    and all the coordinates in the tensor coord ([(x,y)]) assuming
+    it follow the dimensions in dims (height, width).
+    nb is the neighborhood radius (i.e. the distance after which 
+    the function returns 0)."""
+    nodes = node.repeat(dims[0]*dims[1], 1)
+    dist = torch.nn.functional.pairwise_distance(nodes, coord)
+    dist[int(node[0]*dims[0])+node[1]%dims[0]] = 0.0
+    ret = 1-(dist/nb)
+    ret[ret < 0] = 0.0
+    return ret
+
+class SOM(torch.nn.Module):
+    """
+    Model for a self-organising map (Kohonen map), which is trained by adding data points that will make the map adapt. The general principle for the training is that each point is matched to the closest unit (using the euclidean distance). The weights of this best matching unit (BMU) are then updated to move closer to the input data point (to a rate dependent on the learning rate, alpha). Neighboring units are also updated, to a lesser extent, depending on the neighborhood function and radius. The learning rate and the neighborhood radius decay over time (provided input points). 
+
+Parameters:
+-----------
+
+xs: vertical size of the map
+
+ys: horizontal size of the map
+
+dist (default: ksom.euclidean_distance): the fonction to identify the best matching unit (BMU). This takes two 2D vectors and returns a 2D matrix of the distances between them. Two options are available as part of ksom: euclidean_distance and consine_distance.
+
+zero_init (default: False): Whether the map is initialised randomly, or by zero vectors. 
+
+alpha_init (default: 1e-3): initial value of learning rate.
+
+alpha_drate (default: 1e-6): decay rate of the learning rate. The learning rate (alpha) decreases linearly based on this rate for each new data point, until it reaches the valyue of alpha_drate. 
+
+neightborgood_init (default: half of the smallest dimension of the map): the initial radius of the neighborhood.
+
+neighborhood_fct (default: ksom.nb_gaussian, other values: nb_linear, nb_ricker): the function to get the neighborhood rate depending on the neighborhood rate and the euclidean distance between units. 
+
+neighborhood_drate (default: 1e-6): rate of decay of the neigtborhood radius. This will decrease linearly from neighborhood_init to neighborhood_drate depending on neighborhood_drate.
+
+Example:  
+--------
+
+See https://github.com/mdaquin/KSOM/blob/main/test_img.py for an example of the use of KSOM to build a map of the pixel colors of an image. 
+    """
+    
+    def __init__(self, xs, ys, dim,
+                 dist=euclidean_distance, zero_init=False, sample_init=None,
+                 alpha_init=1e-2, alpha_drate=1e-6,
+                 neighborhood_init=None, neighborhood_fct=nb_gaussian, neighborhood_drate=1e-6, 
+                 minval=None, maxval=None, device="cpu"):
+        if type(xs) != int or type(ys) != int or type(dim) != int: raise TypeError("size and dimension of SOM should be int")
+        if alpha_init <= alpha_drate: raise ValueError("Decay rate of learning rate (alpha_drate) should be smaller than initial value (alpha_init)")
+        if neighborhood_init is None: self.neighborhood_init = min(xs,ys)/2 # start with half the map
+        else: self.neighborhood_init = neighborhood_init
+        if self.neighborhood_init <= neighborhood_drate: raise ValueError("Neighborhood radius decay rate should (neighborhood_drate) should be smaller than initial value (neighborhood_init)")
+        super(SOM, self).__init__()
+        self.somap = torch.randn(xs*ys, dim).to(device)
+        if minval is not None and maxval is not None:
+            self.somap = (self.somap + minval) * (maxval - minval)
+        self.minval = minval
+        self.maxval = maxval
+        if zero_init: self.somap = torch.zeros((xs*ys, dim), dtype=torch.float).to(device)
+        if sample_init is not None: 
+            if sample_init.shape == self.somap.shape: self.somap = sample_init
+            else: raise ValueError("Number of samples provided for initialisation should be the same as number of cells in map;")
+        self.xs = xs
+        self.ys = ys
+        self.dim = dim
+        self.dist = dist
+        self.step = 0
+        self.neighborhood_drate = neighborhood_drate
+        self.neighborhood_fct = neighborhood_fct
+        self.alpha_init  = alpha_init
+        self.alpha_drate = alpha_drate
+        lx = torch.arange(xs).repeat(ys).view(-1, ys).T.reshape(xs*ys)
+        ly = torch.arange(ys).repeat(xs)
+        self.coord = torch.stack((lx,ly), -1).to(device)
+
+    def to(self, device):
+        super(SOM, self).to(device)
+        self.somap = self.somap.to(device)
+        self.coord = self.coord.to(device)
+        
+    def forward(self, x):
+        """
+        Identifies the best matching unit for the data points in x in the current map.
+
+        Parameter:
+        ----------
+
+        x: 2D tensor (N, dim) corresponding to N data points of dimension dim. 
+
+        Returns:
+        --------
+
+        Returns a tuple including the coordinates of the bmu in the current map and the distance matrix used to find it.
+        """
+        if type(x) != torch.Tensor: raise TypeError("x should be a tensor of shape (N,dim)")
+        if len(x.size()) != 2: raise ValueError("x should be a tensor of shape (N,dim)")
+        if x.size()[1] != self.dim: raise ValueError("x should be a tensor of shape (N,dim)")
+        dists = self.dist(self.somap, x)
+        bmu_ind = dists.min(dim=0).indices
+        bmu_ind_x = (bmu_ind/self.xs).to(torch.int32)
+        bmu_ind_y = bmu_ind%self.xs
+        return torch.stack((bmu_ind_x, bmu_ind_y), -1), dists
+
+    def __1DIndexTo2DIndex(self, ind):
+        return torch.Tensor([int(ind/self.xs), ind%self.xs])
+    
+    def add(self, x):
+        """
+        Add the data points in x to the current map and update the map to those points (training). 
+
+        Parameters:
+        -----------
+
+        x: 2D tensor (N, dim) corresponding to N data points of dimension dim. 
+
+        Returns:
+        --------
+
+        Returns the euclidean distance of the SOM's matrix before and after training. Gives an indication of the impact of the added training points on the map.
+        """
+        if type(x) != torch.Tensor: raise TypeError("x should be a tensor of shape (N,dim)")
+        if len(x.size()) != 2: raise ValueError("x should be a tensor of shape (N,dim)")
+        if x.size()[1] != self.dim: raise ValueError("x should be a tensor of shape (N,dim)")
+        prev_som = self.somap.clone().detach()
+        count = 0
+        for x_k in x:
+            if x_k.isnan().any() or x_k.isinf().any(): continue # do not try to add vector containing nans ! 
+            count+=1
+            # decreases linearly...
+            nb = max(self.neighborhood_drate, self.neighborhood_init - (self.step*self.neighborhood_drate))
+            alpha = max(self.alpha_drate, self.alpha_init - (self.step*self.alpha_drate))
+            self.step += 1
+            bmu = self(x_k.view(-1, x_k.size()[0]))[0][0]
+            theta = self.neighborhood_fct(bmu, (self.xs, self.ys), self.coord, nb)
+            ntheta = theta.view(-1, theta.size(0)).T
+            # TODO: print(ntheta) prob is that neg ones get to quickly neg and then go to infinity...
+            self.somap = self.somap + ntheta*(alpha*(x_k-self.somap))
+            if torch.isnan(self.somap).any() or torch.isinf(self.somap).any(): 
+                print("*** Nan! ***")
+                print("bmu", bmu)
+                print("theta", theta.min(), theta.max(), theta.mean(), theta.isnan().any())
+                print("ntheta", ntheta.min(), ntheta.max(), ntheta.mean(), ntheta.isnan().any())
+                print("alpha", alpha)
+                print("x_k", x_k.min(), x_k.max(), x_k.mean(), x_k.isnan().any())
+            # old non batch (slow) version
+            # batch here means calculating the whole map at once,
+            # not having a batch of values treated at once. 
+            # for i, w_i in enumerate(self.somap):
+            #      i2 = self.__1DIndexTo2DIndex(i)
+            #      theta = self.neighborhood_fct(bmu, i2, nb)                
+            #      self.somap[i] = w_i + theta*alpha*(x_k-w_i)
+            # print("o nsomap", self.somap)
+                #  wij' = wij + ( n_fct(bmu,ni,nb(s)) * alpha(s) * (x_k - wij) )
+        return float(torch.nn.functional.pairwise_distance(prev_som, self.somap).mean()), count

ksom-0.9.1/src/ksom/ksom.py

@@ -0,0 +1,217 @@
+# Self-organising map pytroch model.
+# Author: Mathieu d'Aquin
+
+import torch
+from torch.nn import CosineSimilarity
+from torchmetrics.functional import pairwise_cosine_similarity
+import math
+import numpy as np
+
+def euclidean_distance(x,y):
+    """returns a distance matrix between the elements of
+    the tensor x and the ones of the tensor y"""
+    return torch.cdist(x,y,2)
+
+def cosine_distance(x,y):
+    """returns a distance matrix between the elements of 
+    the tensor x and the ones of the tensor y"""
+    return 1 - pairwise_cosine_similarity(x,y)
+
+# TODO: #13 this does not seem to work...
+def nb_ricker(node, dims, coord, nb):
+    """
+    Ricker wavelet (mexican hat) neighborhood weights between between node (x,y) 
+    and all the coordinates in the tensor coord ([(x,y)]) assuming
+    it follow the dimensions in dims (height, width).
+    nb is the neighborhood radius (i.e. the distance after which 
+    the function returns 0).
+    """
+    # if nb < 1.0: nb = 1.0 # seem to make no difference...
+    nodes = node.repeat(dims[0]*dims[1], 1)
+    dist = torch.nn.functional.pairwise_distance(nodes, coord)
+    dist[int(node[0]*dims[0])+node[1]%dims[0]] = 0.0
+    FM = (math.sqrt(6)/(math.pi*(2*nb)))/math.sqrt(3)
+    fbit = (1-2*math.pi**2*FM**2*dist**2)
+    sbit = -math.pi**2*FM**2*dist**2
+    return fbit*torch.exp(sbit)
+
+def nb_gaussian(node, dims, coord, nb):
+    """
+    Gaussian neighborhood weights between between node (x,y) 
+    and all the coordinates in the tensor coord ([(x,y)]) assuming
+    it follow the dimensions in dims (height, width).
+    nb is the neighborhood radius (i.e. the distance after which 
+    the function returns 0).    
+    """
+    # exp(-(x/(nb/2))**2)
+    nodes = node.repeat(dims[0]*dims[1], 1)
+    dist = torch.nn.functional.pairwise_distance(nodes, coord)
+    dist[int(node[0]*dims[0])+node[1]%dims[0]] = 0.0
+    ret = torch.exp(-(dist/(nb/2))**2)
+    ret[ret < 0] = 0.0
+    return ret    
+
+def nb_linear_o(node1, node2, nb):
+    """deprecated non-batch versoin of the linear
+    neighborhood function"""
+    if node1[0] == node2[0] and node1[1] == node2[1]: return 1.0
+    dist = euclidean_distance(node1.view(-1, 2).to(torch.float32),
+                              node2.view(-1, 2).to(torch.float32))[0][0]
+    return max(0,1-(dist/nb))
+
+def nb_linear(node, dims, coord, nb):
+    """linear neighborhood distances between node (x,y) 
+    and all the coordinates in the tensor coord ([(x,y)]) assuming
+    it follow the dimensions in dims (height, width).
+    nb is the neighborhood radius (i.e. the distance after which 
+    the function returns 0)."""
+    nodes = node.repeat(dims[0]*dims[1], 1)
+    dist = torch.nn.functional.pairwise_distance(nodes, coord)
+    dist[int(node[0]*dims[0])+node[1]%dims[0]] = 0.0
+    ret = 1-(dist/nb)
+    ret[ret < 0] = 0.0
+    return ret
+
+class SOM(torch.nn.Module):
+    """
+    Model for a self-organising map (Kohonen map), which is trained by adding data points that will make the map adapt. The general principle for the training is that each point is matched to the closest unit (using the euclidean distance). The weights of this best matching unit (BMU) are then updated to move closer to the input data point (to a rate dependent on the learning rate, alpha). Neighboring units are also updated, to a lesser extent, depending on the neighborhood function and radius. The learning rate and the neighborhood radius decay over time (provided input points). 
+
+Parameters:
+-----------
+
+xs: vertical size of the map
+
+ys: horizontal size of the map
+
+dist (default: ksom.euclidean_distance): the fonction to identify the best matching unit (BMU). This takes two 2D vectors and returns a 2D matrix of the distances between them. Two options are available as part of ksom: euclidean_distance and consine_distance.
+
+zero_init (default: False): Whether the map is initialised randomly, or by zero vectors. 
+
+alpha_init (default: 1e-3): initial value of learning rate.
+
+alpha_drate (default: 1e-6): decay rate of the learning rate. The learning rate (alpha) decreases linearly based on this rate for each new data point, until it reaches the valyue of alpha_drate. 
+
+neightborgood_init (default: half of the smallest dimension of the map): the initial radius of the neighborhood.
+
+neighborhood_fct (default: ksom.nb_gaussian, other values: nb_linear, nb_ricker): the function to get the neighborhood rate depending on the neighborhood rate and the euclidean distance between units. 
+
+neighborhood_drate (default: 1e-6): rate of decay of the neigtborhood radius. This will decrease linearly from neighborhood_init to neighborhood_drate depending on neighborhood_drate.
+
+Example:  
+--------
+
+See https://github.com/mdaquin/KSOM/blob/main/test_img.py for an example of the use of KSOM to build a map of the pixel colors of an image. 
+    """
+    
+    def __init__(self, xs, ys, dim,
+                 dist=euclidean_distance, zero_init=False, sample_init=None,
+                 alpha_init=1e-2, alpha_drate=1e-6,
+                 neighborhood_init=None, neighborhood_fct=nb_gaussian, neighborhood_drate=1e-6, 
+                 minval=None, maxval=None, device="cpu"):
+        if type(xs) != int or type(ys) != int or type(dim) != int: raise TypeError("size and dimension of SOM should be int")
+        if alpha_init <= alpha_drate: raise ValueError("Decay rate of learning rate (alpha_drate) should be smaller than initial value (alpha_init)")
+        if neighborhood_init is None: self.neighborhood_init = min(xs,ys)/2 # start with half the map
+        else: self.neighborhood_init = neighborhood_init
+        if self.neighborhood_init <= neighborhood_drate: raise ValueError("Neighborhood radius decay rate should (neighborhood_drate) should be smaller than initial value (neighborhood_init)")
+        super(SOM, self).__init__()
+        self.somap = torch.randn(xs*ys, dim).to(device)
+        if minval is not None and maxval is not None:
+            self.somap = (self.somap + minval) * (maxval - minval)
+        self.minval = minval
+        self.maxval = maxval
+        if zero_init: self.somap = torch.zeros((xs*ys, dim), dtype=torch.float).to(device)
+        if sample_init is not None: 
+            if sample_init.shape == self.somap.shape: self.somap = sample_init
+            else: raise ValueError("Number of samples provided for initialisation should be the same as number of cells in map;")
+        self.xs = xs
+        self.ys = ys
+        self.dim = dim
+        self.dist = dist
+        self.step = 0
+        self.neighborhood_drate = neighborhood_drate
+        self.neighborhood_fct = neighborhood_fct
+        self.alpha_init  = alpha_init
+        self.alpha_drate = alpha_drate
+        lx = torch.arange(xs).repeat(ys).view(-1, ys).T.reshape(xs*ys)
+        ly = torch.arange(ys).repeat(xs)
+        self.coord = torch.stack((lx,ly), -1).to(device)
+
+    def to(self, device):
+        super(SOM, self).to(device)
+        self.somap = self.somap.to(device)
+        self.coord = self.coord.to(device)
+        
+    def forward(self, x):
+        """
+        Identifies the best matching unit for the data points in x in the current map.
+
+        Parameter:
+        ----------
+
+        x: 2D tensor (N, dim) corresponding to N data points of dimension dim. 
+
+        Returns:
+        --------
+
+        Returns a tuple including the coordinates of the bmu in the current map and the distance matrix used to find it.
+        """
+        if type(x) != torch.Tensor: raise TypeError("x should be a tensor of shape (N,dim)")
+        if len(x.size()) != 2: raise ValueError("x should be a tensor of shape (N,dim)")
+        if x.size()[1] != self.dim: raise ValueError("x should be a tensor of shape (N,dim)")
+        dists = self.dist(self.somap, x)
+        bmu_ind = dists.min(dim=0).indices
+        bmu_ind_x = (bmu_ind/self.xs).to(torch.int32)
+        bmu_ind_y = bmu_ind%self.xs
+        return torch.stack((bmu_ind_x, bmu_ind_y), -1), dists
+
+    def __1DIndexTo2DIndex(self, ind):
+        return torch.Tensor([int(ind/self.xs), ind%self.xs])
+    
+    def add(self, x):
+        """
+        Add the data points in x to the current map and update the map to those points (training). 
+
+        Parameters:
+        -----------
+
+        x: 2D tensor (N, dim) corresponding to N data points of dimension dim. 
+
+        Returns:
+        --------
+
+        Returns the euclidean distance of the SOM's matrix before and after training. Gives an indication of the impact of the added training points on the map.
+        """
+        if type(x) != torch.Tensor: raise TypeError("x should be a tensor of shape (N,dim)")
+        if len(x.size()) != 2: raise ValueError("x should be a tensor of shape (N,dim)")
+        if x.size()[1] != self.dim: raise ValueError("x should be a tensor of shape (N,dim)")
+        prev_som = self.somap.clone().detach()
+        count = 0
+        for x_k in x:
+            if x_k.isnan().any() or x_k.isinf().any(): continue # do not try to add vector containing nans ! 
+            count+=1
+            # decreases linearly...
+            nb = max(self.neighborhood_drate, self.neighborhood_init - (self.step*self.neighborhood_drate))
+            alpha = max(self.alpha_drate, self.alpha_init - (self.step*self.alpha_drate))
+            self.step += 1
+            bmu = self(x_k.view(-1, x_k.size()[0]))[0][0]
+            theta = self.neighborhood_fct(bmu, (self.xs, self.ys), self.coord, nb)
+            ntheta = theta.view(-1, theta.size(0)).T
+            # TODO: print(ntheta) prob is that neg ones get to quickly neg and then go to infinity...
+            self.somap = self.somap + ntheta*(alpha*(x_k-self.somap))
+            if torch.isnan(self.somap).any() or torch.isinf(self.somap).any(): 
+                print("*** Nan! ***")
+                print("bmu", bmu)
+                print("theta", theta.min(), theta.max(), theta.mean(), theta.isnan().any())
+                print("ntheta", ntheta.min(), ntheta.max(), ntheta.mean(), ntheta.isnan().any())
+                print("alpha", alpha)
+                print("x_k", x_k.min(), x_k.max(), x_k.mean(), x_k.isnan().any())
+            # old non batch (slow) version
+            # batch here means calculating the whole map at once,
+            # not having a batch of values treated at once. 
+            # for i, w_i in enumerate(self.somap):
+            #      i2 = self.__1DIndexTo2DIndex(i)
+            #      theta = self.neighborhood_fct(bmu, i2, nb)                
+            #      self.somap[i] = w_i + theta*alpha*(x_k-w_i)
+            # print("o nsomap", self.somap)
+                #  wij' = wij + ( n_fct(bmu,ni,nb(s)) * alpha(s) * (x_k - wij) )
+        return float(torch.nn.functional.pairwise_distance(prev_som, self.somap).mean()), count

ksom-0.9.1/tests/test_cheese.py

@@ -0,0 +1,114 @@
+import math
+import time
+import pandas as pd
+import pygame
+from sklearn.decomposition import PCA
+import ksom
+import torch
+import sys
+
+def remspace(x): return x.replace(", ", ",") if type(x) == str else x
+
+def onehotencode(df, col):
+    return pd.concat([df, df[col].apply(remspace).str.get_dummies(sep=",")], axis=1).drop(col, axis=1)
+
+def findLabel(i, map, labels):
+     idx = abs(map.mean(dim=0)-map[i]).argmax()
+     lab = labels[idx]
+     if map.mean(dim=0)[idx] > map[i][idx]: lab = "not "+lab
+     return lab
+
+def display(map, xoffset=0, labels=None, label_offset=0):
+    if map.shape[1] > 3:
+        pca = PCA(n_components=3)
+        somap = pca.fit_transform(map)
+    else: somap = map
+    for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()
+    unit = int(screen_size/smodel.xs)
+    for i,cs in enumerate(somap):
+        x = int(i/smodel.xs)
+        y = i%smodel.xs
+        x = (x*unit)+xoffset
+        y = y*unit
+        try : 
+            color = (max(min(255, int(cs[0]*255)), 0),
+                     max(min(255, int(cs[1]*255)), 0),
+                     max(min(255, int(cs[2]*255)), 0))
+        except: 
+            print(cs*255)
+            sys.exit(-1)
+        pygame.draw.rect(surface,
+                         color,
+                         pygame.Rect(x, y, unit, unit))
+        if labels is not None:
+             lab = findLabel(i, map, labels)
+             cp = surface.get_at((int(x+label_offset+unit/20),y+int(unit/5)))
+             cl = (200, 200, 200)
+             if cp[0] > 100 : cl = (0, 0, 0)
+             texts = font.render(lab, False, cl)
+             surface.blit(texts, (x+label_offset+unit/20,y+int(unit/5)))
+
+    pygame.display.flip()
+    pygame.display.update()
+
+df = pd.read_csv("https://raw.githubusercontent.com/rfordatascience/tidytuesday/refs/heads/main/data/2024/2024-06-04/cheeses.csv", index_col=0)
+df = df.drop(["url", "producers", "alt_spellings", "synonyms", "fat_content", "calcium_content", "vegetarian", "vegan"], axis=1)
+print(df.columns)
+df = onehotencode(df, "milk")
+df = onehotencode(df, "country")
+df = onehotencode(df, "region")
+df = onehotencode(df, "family")
+df = onehotencode(df, "type")
+df = onehotencode(df, "texture")
+df = onehotencode(df, "rind")
+df = onehotencode(df, "color")
+df = onehotencode(df, "flavor")
+df = onehotencode(df, "aroma")
+
+#print(df.aroma.apply(remspace).str.get_dummies(sep=","))
+#df["vegetarian"] = df.vegetarian.apply(lambda x: int(x) if type(x)==bool else x)
+#df["vegan"] = df.vegan.apply(lambda x: int(x) if type(x)==bool else x)
+df = df.dropna()
+
+screen_size=600 # size of screen 
+pygame.init()
+surface = pygame.display.set_mode((screen_size*2,screen_size))
+
+NBEPOCH = 10
+BATCHSIZE = 100
+SOMSIZE = 6
+DIST = ksom.cosine_distance
+
+pygame.font.init()
+font = pygame.font.SysFont('Courrier',int((screen_size/6)/5))
+
+smodel = ksom.SOM(SOMSIZE, SOMSIZE, 
+                  len(df.T), 
+                  zero_init=True, 
+                  # sample_init=torch.Tensor(df.sample(SOMSIZE*SOMSIZE).to_numpy()),
+                  dist=DIST)
+
+for epoch in range(NBEPOCH):
+    for b in range(math.ceil(len(df)/BATCHSIZE)):
+        dist,count = smodel.add(torch.Tensor(df.iloc[b*BATCHSIZE:(b+1)*BATCHSIZE].to_numpy()))
+        print(f"{epoch+1:02d}.{b:02d}: distance {dist:.4f} out of {count} objects")
+        freqmap = torch.zeros(SOMSIZE*SOMSIZE)
+        bmu,dists = smodel(torch.Tensor(df.to_numpy()))
+        for i in bmu: freqmap[i[0]*SOMSIZE+i[1]] += 1
+        freqmap = (freqmap - freqmap.min())/(freqmap.max()-freqmap.min())
+        freqmap = freqmap.view(len(freqmap), 1).repeat((1,3))
+        display(freqmap, xoffset=screen_size)
+        display(smodel.somap, labels=list(df.columns), label_offset=screen_size)
+
+# continue to keep the display alive
+while True:
+    for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()    
+    time.sleep(0.1)
+    pygame.display.flip()    
+    pygame.display.update()

ksom-0.9.1/tests/test_dist.py

@@ -0,0 +1,30 @@
+import torch
+from ksom import euclidean_distance, cosine_distance
+from scipy.spatial import distance
+
+som_size = 10
+dim = 128
+batch_size = 256
+
+som = torch.randn(som_size*som_size, 128)
+batch = torch.randn(batch_size, dim)
+
+euc1 = euclidean_distance(batch, som)
+euc2 = []
+
+cos1 = cosine_distance(batch, som)
+cos2 = []
+
+for s in batch:
+    seuc = []
+    scos = []
+    for c in som:
+        seuc.append(distance.euclidean(s, c))
+        scos.append(distance.cosine(s, c))
+    euc2.append(torch.Tensor(seuc))
+    cos2.append(torch.Tensor(scos))
+euc2 = torch.cat(euc2).view(batch_size, som_size*som_size)
+cos2 = torch.cat(cos2).view(batch_size, som_size*som_size)
+
+print("euclidean distance:", float(abs(euc1-euc2).mean()))
+print("cosine distance:", float(abs(cos1-cos2).mean()))

ksom-0.9.1/tests/test_img.py

@@ -0,0 +1,91 @@
+import sys
+
+if len(sys.argv) < 3:
+     print("No image or map size provided, default parameters (chica.jpg, 6) will be used.")
+     img = "chica.jpg"
+     som_size = 6
+else: 
+    img = sys.argv[1]
+    if not sys.argv[2].isnumeric():
+        print("Second argument should be a number.")
+        sys.exit(-1)
+    som_size = int(sys.argv[2])
+disp = True
+if len(sys.argv) >=4: disp = sys.argv[3] != "nodisplay"
+    
+from PIL import Image
+from torchvision import transforms
+from ksom import SOM, cosine_distance, nb_linear, nb_gaussian, nb_ricker
+if disp: import pygame
+import torch
+import time
+
+# init display screen and function to display map
+if disp:
+  screen_size=600 # size of screen 
+  pygame.init()
+  surface = pygame.display.set_mode((screen_size,screen_size))
+
+def display(smodel):
+    for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()
+    unit = int(screen_size/som_size)
+    for i,cs in enumerate(smodel.somap):
+        x = int(i/som_size)
+        y = i%som_size
+        x = x*unit
+        y = y*unit
+        try : 
+            color = (max(min(255, int(cs[0]*255)), 0),
+                     max(min(255, int(cs[1]*255)), 0),
+                     max(min(255, int(cs[2]*255)), 0))
+        except: 
+            print(cs*255)
+            sys.exit(-1)
+        pygame.draw.rect(surface,
+                         color,
+                         pygame.Rect(x, y, unit, unit))
+    pygame.display.flip()
+    pygame.display.update()
+
+# open image, transform into tensor, and create shuffle index
+im= Image.open(img)
+x= transforms.ToTensor()(im)
+x = x[:-1] if x.size(0) == 4 else x # remove alpha layer if there is one
+x = x.view(-1, x.size()[1]*x.size()[2]).transpose(0,1)
+perm = torch.randperm(x.size(0))
+
+# init SOM model
+samples = x[perm[-(som_size*som_size):]]
+smodel = SOM(som_size, som_size, 3, sample_init=samples, # zero_init=False,
+             dist=cosine_distance,
+             alpha_init=0.01, alpha_drate=1e-7,
+             neighborhood_fct=nb_gaussian, neighborhood_init=som_size, neighborhood_drate=0.0001)
+
+device = "cpu"
+if torch.cuda.is_available():
+    device = "cuda:0"
+    x = x.to(device)
+    smodel.to(device)
+    print("Running on CUDA")
+
+# train (1 pass through all the pixels) by batches of 1000 pixels
+for i in range(int(x.size()[0]/1000)):
+    idx = perm[i*1000:(i+1)*1000]
+    time1 = time.time()
+    dist,count = smodel.add(x[idx])
+    print(f"{(i+1):06d}K - {dist:.4f} - {(time.time()-time1)*1000:05.2f}ms")
+    if disp: display(smodel)
+    
+# continue to keep the display alive
+if display: 
+  while True:
+    for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                pygame.quit()
+                sys.exit()    
+    time.sleep(0.1)
+    pygame.display.flip()    
+    pygame.display.update()

ksom-0.9.1/tests/test_nb_fct.py

@@ -0,0 +1,62 @@
+import sys
+import torch
+import time
+
+if len(sys.argv) < 4:
+    print("Provide the name of the neighborhood function to test and the size (N) of map (NxN) and radius of neighborhood function, using default params for now (ricker,20,6)")
+    sys.argv.append("ricker")
+    sys.argv.append("20")
+    sys.argv.append("6")        
+if not sys.argv[2].isnumeric():
+    print("Second argument should be a number.")
+    sys.exit(-1)
+if not sys.argv[3].isnumeric():
+    print("Third argument should be a number.")
+    sys.exit(-1)
+
+from ksom import SOM, nb_linear, nb_gaussian, nb_ricker
+
+if sys.argv[1] == "linear":
+    fct = nb_linear
+elif sys.argv[1] == "gaussian":
+    fct = nb_gaussian
+elif sys.argv[1] == "ricker":
+    fct = nb_ricker      
+else:
+    print("Neighboorhood function should be linear, gaussian or ricker")
+    sys.exit(-1)
+
+import pygame
+
+# init display screen and function to display map
+screen_size=600 # size of screen 
+pygame.init()
+surface = pygame.display.set_mode((screen_size,screen_size))
+
+def display(distmatrix):
+    unit = int(screen_size/som_size)
+    for i,cs in enumerate(distmatrix):
+        x = int(i/som_size)
+        y = i%som_size
+        x = x*unit
+        y = y*unit
+        color = (max(min(255, int(-cs*255)), 0),
+                 max(min(255, int(cs*255)), 0),
+                 max(min(255, int(cs*255)), 0))
+        pygame.draw.rect(surface,
+                         color,
+                         pygame.Rect(x, y, unit, unit))
+        pygame.display.flip()
+
+# init SOM model
+som_size = int(sys.argv[2]) # size of som (square, so som_size x som_size)
+smodel = SOM(som_size, som_size, 3)
+
+node = (int(som_size/2), int(som_size/2))
+
+distmtx = fct(torch.tensor(node), (som_size, som_size), smodel.coord, int(sys.argv[3]))
+display(distmtx)
+
+# continue to keep the display alive
+while True: time.sleep(10)  
+