The Self-Organizing Map (SOM) is an unsupervised learning algorithm used for nonlinear dimensionality reduction and data clustering. In this lecture, we will explain the basic concepts of SOM, how it works, and how to implement it using Pytorch<\/strong>.<\/p>\n The Self-Organizing Map is a neural network originally developed by Teuvo Kohonen<\/strong>. SOM is used to map high-dimensional data into a lower-dimensional space (usually a 2D grid). In this process, data is organized into a map consisting of neighboring nodes that have similar characteristics.<\/p>\n SOM learns by calculating the distance between the input vector and the node vectors. Here are the typical learning steps of SOM:<\/p>\n All nodes are initialized randomly. Each node has a weight vector with the same dimension as the input data.<\/p>\n Randomly select a training sample. Each sample becomes an input to the SOM.<\/p>\n Find the node that is most similar to the selected input data. This node is called the Best Matching Unit (BMU)<\/strong>.<\/p>\n Update the weights of the BMU and its neighboring nodes to move closer to the input data. The process is as follows:<\/p>\n Where:<\/p>\n Repeat steps 2-4 for a sufficient number of epochs to gradually update the weights.<\/p>\n Now let’s implement SOM using Pytorch. Here we will show you how to build and visualize a basic SOM.<\/p>\n First, install the required libraries.<\/p>\n Next, we define the SOM class. This class includes functions for weight initialization, finding the BMU, and updating weights.<\/p>\n We will prepare appropriate data and train the SOM model. Here we will use randomly generated data.<\/p>\n We will visualize the weights of the trained SOM to check the distribution of the data.<\/p>\n In this lecture, we explored the basic principles of Self-Organizing Maps (SOM) and how to implement SOM using Pytorch. SOM is an effective unsupervised learning technique that is useful for identifying patterns in data and performing clustering. In the future, we can experiment with SOM’s application on more complex datasets or apply optimization techniques to enhance learning performance.<\/p>\n I hope this article has helped you explore the world of deep learning! If you have any questions or feedback, please leave a comment.<\/p>\n <\/body><\/p>\n","protected":false},"excerpt":{"rendered":"What is a Self-Organizing Map (SOM)?<\/h2>\n
Main Features of SOM<\/h3>\n
\n
How SOM Works<\/h2>\n
1. Initialization<\/h3>\n
2. Input Data Selection<\/h3>\n
3. Finding the Nearest Node<\/h3>\n
4. Weight Update<\/h3>\n
\nw_{i}(t+1) = w_{i}(t) + \u03b1(t) * h_{i,j}(t) * (x(t) - w_{i}(t))\n<\/code><\/pre>\n\n
w_{i}<\/code>: Weight vector of the node<\/li>\n\u03b1(t)<\/code>: Learning rate<\/li>\nh_{i,j}(t)<\/code>: Neighbor function of node i<\/code> regarding the BMU<\/li>\nx(t)<\/code>: Input vector<\/li>\n<\/ul>\n5. Iteration<\/h3>\n
Implementing SOM with Pytorch<\/h2>\n
Installing Required Libraries<\/h3>\n
!pip install torch numpy matplotlib<\/code><\/pre>\nDefining the Model Class<\/h3>\n
\nimport numpy as np\nimport torch\n\nclass SelfOrganizingMap:\n def __init__(self, m, n, input_dim, learning_rate=0.5, sigma=None):\n self.m = m # grid rows\n self.n = n # grid columns\n self.input_dim = input_dim\n self.learning_rate = learning_rate\n self.sigma = sigma if sigma else max(m, n) \/ 2\n\n # Initialize weight vectors\n self.weights = torch.rand(m, n, input_dim)\n\n def find_bmu(self, x):\n distances = torch.sqrt(torch.sum((self.weights - x) ** 2, dim=2))\n bmu_index = torch.argmin(distances)\n return bmu_index \/\/ self.n, bmu_index % self.n # return row, column\n\n def update_weights(self, x, bmu, iteration):\n learning_rate = self.learning_rate * np.exp(-iteration \/ 100)\n sigma = self.sigma * np.exp(-iteration \/ 100)\n\n for i in range(self.m):\n for j in range(self.n):\n h = self.neighbourhood(bmu, (i, j), sigma)\n self.weights[i, j] += learning_rate * h * (x - self.weights[i, j])\n\n def neighbourhood(self, bmu, point, sigma):\n distance = np.sqrt((bmu[0] - point[0]) ** 2 + (bmu[1] - point[1]) ** 2)\n return np.exp(-distance ** 2 \/ (2 * sigma ** 2))\n\n def train(self, data, num_iterations):\n for i in range(num_iterations):\n for x in data:\n bmu = self.find_bmu(x)\n self.update_weights(x, bmu, i)\n<\/code><\/pre>\nPreparing Data and Training the Model<\/h3>\n
\n# Generate random data\ndata = torch.rand(200, 3) # 200 samples, 3 dimensions\n\n# Create and train SOM\nsom = SelfOrganizingMap(10, 10, 3)\nsom.train(data, 100)\n<\/code><\/pre>\nVisualizing the Results<\/h3>\n
\nimport matplotlib.pyplot as plt\n\ndef plot_som(som):\n plt.figure(figsize=(8, 8))\n for i in range(som.m):\n for j in range(som.n):\n plt.scatter(som.weights[i, j, 0].item(), som.weights[i, j, 1].item(), c='blue')\n plt.title('Self Organizing Map')\n plt.xlabel('Dimension 1')\n plt.ylabel('Dimension 2')\n plt.show()\n\nplot_som(som)\n<\/code><\/pre>\nConclusion<\/h2>\n