Hexagonal Self-Organizing map in Python

I am looking for hexagonal self-organizing map on Python.

ready module. If one exists.
way to plot hexagonal cell
algorithms to work with hexagonal cells as array or smth else

About: A self-organizing map (SOM) or self-organizing feature map (SOFM) is a type of artificial neural network that is trained using unsupervised learning to produce a low-dimensional (typically two-dimensional)

I don't have an answer for point 1, but some hints for point 2 and 3. In your context, you're not modelling a physical 2D space but a conceptual space with tiles that have 6 neighbors. This can be modelled with square tiles arranged in columns with the odd colums shifted vertically by half the size of a square. I'll try an ASCII diagram:

 ___     ___     ___      |   |___|   |___|   |___ |___|   |___|   |___|   | |   |___|   |___|   |___| |___|   |___|   |___|   | |   |___|   |___|   |___| |___|   |___|   |___|   |     |___|   |___|   |___|

You can see easily that each square has 6 neighbors (except the ones on the edges of course). This gets easily modeled as a 2D array of squares, and the rules to compute the coordinates of the square at at position (i, j), i being the row and j the column are quite simple:

if j is even:

(i+1, j), (i-1, j), (i, j-1), (i, j+1), (i-1, j-1), (i+1, j-1)

if j is odd:

(i+1, j), (i-1, j), (i, j-1), (i, j+1), (i+1, j-1), (i+1, j+1)

(the 4 first terms are identical)

Fernando Ferreira

I know this discussion is 4 years old, however I haven't find a satisfactory answer over the web.

If you have something as a array mapping the input to the neuron and a 2-d array related to the location for each neuron.

For example consider something like this:

hits = array([1, 24, 14, 16,  6, 11,  8, 23, 15, 16, 15,  9, 20,  1,  3, 29,  4,               32, 22,  7, 26, 26, 35, 23,  7,  6, 11,  9, 18, 17, 22, 19, 34,  1,               36,  3, 31, 10, 22, 11, 21, 18, 29,  3,  6, 32, 15, 30, 27],              dtype=int32) centers = array([[ 1.5       ,  0.8660254 ],                  [ 2.5       ,  0.8660254 ],                  [ 3.5       ,  0.8660254 ],                  [ 4.5       ,  0.8660254 ],                  [ 5.5       ,  0.8660254 ],                  [ 6.5       ,  0.8660254 ],                  [ 1.        ,  1.73205081],                  [ 2.        ,  1.73205081],                  [ 3.        ,  1.73205081],                  [ 4.        ,  1.73205081],                  [ 5.        ,  1.73205081],                  [ 6.        ,  1.73205081],                  [ 1.5       ,  2.59807621],                  [ 2.5       ,  2.59807621],                  [ 3.5       ,  2.59807621],                  [ 4.5       ,  2.59807621],                  [ 5.5       ,  2.59807621],                  [ 6.5       ,  2.59807621],                  [ 1.        ,  3.46410162],                  [ 2.        ,  3.46410162],                  [ 3.        ,  3.46410162],                  [ 4.        ,  3.46410162],                  [ 5.        ,  3.46410162],                  [ 6.        ,  3.46410162],                  [ 1.5       ,  4.33012702],                  [ 2.5       ,  4.33012702],                  [ 3.5       ,  4.33012702],                  [ 4.5       ,  4.33012702],                  [ 5.5       ,  4.33012702],                  [ 6.5       ,  4.33012702],                  [ 1.        ,  5.19615242],                  [ 2.        ,  5.19615242],                  [ 3.        ,  5.19615242],                  [ 4.        ,  5.19615242],                  [ 5.        ,  5.19615242],                  [ 6.        ,  5.19615242]])

So I'do this using a the following method:

from matplotlib import collections, transforms from matplotlib.colors import colorConverter from matplotlib import cm import matplotlib.pyplot as plt import numpy as np  def plot_map(hits, n_centers, w=10):     """     Plot Map     """      fig = plt.figure(figsize=(w, .7 * w))     ax = fig.add_subplot(111)     hits_count = np.histogram(hits, bins=n_centers.shape[0])[0]     # Discover difference between centers     collection = RegularPolyCollection(         numsides=6, # a hexagon          rotation=0, sizes=( (6.6*w)**2 ,),         edgecolors = (0, 0, 0, 1),         array= hits_count,         cmap = cm.winter,         offsets = n_centers,         transOffset = ax.transData,     )     ax.axis('off')     ax.add_collection(collection, autolim=True)     ax.autoscale_view()     fig.colorbar(collection)     return ax  _ = plot_map(som_classif, matrix)

Finally I got this output: