पायथन में हेक्सागोनल सेल्फ-ऑर्गनाइजिंग मानचित्र

Question

मैं पाइथन पर हेक्सागोनलself-organizing map देख रहा हूं।

1. तैयार मॉड्यूल। यदि कोई मौजूद है। हेक्सागोनल सेल साजिश
2. रास्ता
3. एल्गोरिदम सरणी वरना ख़ाली रूप हेक्सागोनल कोशिकाओं के साथ काम करने के लिए

बारे: एक स्वयं के आयोजन मानचित्र (SOM) या (SOFM) आत्म आयोजन विशेषता मानचित्र कृत्रिम तंत्रिका नेटवर्क का एक प्रकार है जिसे कम-आयामी (आमतौर पर द्वि-आयामी)

Answer 1

का उत्पादन करने के लिए असुरक्षित शिक्षा का उपयोग करके प्रशिक्षित किया जाता है। मेरे पास बिंदु 1 का उत्तर नहीं है, लेकिन बिंदु 2 और 3 के लिए कुछ संकेत हैं। आपका संदर्भ, आप भौतिक 2 डी स्पेस को मॉडलिंग नहीं कर रहे हैं लेकिन एक सह 6 पड़ोसियों वाले टाइल्स के साथ अवधारणात्मक स्थान। इसे कॉलम में व्यवस्थित स्क्वायर टाइल्स के साथ मॉडलिंग किया जा सकता है, जिसमें अजीब कॉलम एक वर्ग के आधे आकार के लंबवत स्थानांतरित हो जाते हैं। मैं एक ASCII आरेख कोशिश करता हूँ:

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

आप आसानी से कि प्रत्येक वर्ग 6 पड़ोसियों है (बेशक किनारों पर लोगों को छोड़कर) देख सकते हैं। इसे आसानी से 2 डी सरणी के रूप में मॉडलिंग किया जाता है, और नियम (i, j) पर वर्ग के निर्देशांक की गणना करने के नियम, मैं पंक्ति और जे कॉलम काफी सरल हूं:

यदि जे भी है :

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

अगर जे अजीब है:

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

(4 पहले मामले एक जैसे हैं)

Answer 2

मैं जानता हूँ कि इस चर्चा के 4 साल पुराना है, हालांकि मैं एक संतोषजनक answe नहीं मिल रहा है वेब पर आर।

यदि आपके पास न्यूरॉन में इनपुट मैपिंग और प्रत्येक न्यूरॉन के लिए स्थान से संबंधित 2-डी सरणी के रूप में कुछ है।

उदाहरण के लिए कुछ इस तरह विचार करें:

:

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) 

अंत में मैं इस उत्पादन मिल गया:

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]]) 

तो इस का उपयोग कर एक निम्न विधि I'do

संपादित करें

https://stackoverflow.com/a/23811383/575734