SOM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ada/Desktop/SGX/.conda/lib/python3.11/site-packages/minisom.py:447: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  self._weights[i, j] = c1*pc[pc_order[0]] + \\\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from minisom import MiniSom\n",
    "from sklearn import datasets\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Create output directory for snapshots if it does not exist\n",
    "output_dir = \"som_snapshots\"\n",
    "if not os.path.exists(output_dir):\n",
    "    os.makedirs(output_dir)\n",
    "\n",
    "# -----------------------------\n",
    "# 1. Data Preparation: Load and standardize the Iris dataset\n",
    "# -----------------------------\n",
    "iris = datasets.load_iris()\n",
    "data = iris.data              # 4-dimensional features\n",
    "target = iris.target          # Classes: 0, 1, 2\n",
    "target_names = iris.target_names  # e.g., 'setosa', 'versicolor', 'virginica'\n",
    "\n",
    "scaler = StandardScaler()\n",
    "data_std = scaler.fit_transform(data)\n",
    "\n",
    "# -----------------------------\n",
    "# 2. Initialize SOM Parameters and the SOM\n",
    "# -----------------------------\n",
    "som_rows, som_cols = 20, 20         # Define the SOM grid dimensions\n",
    "input_len = data_std.shape[1]       # Number of features (4 for Iris)\n",
    "initial_sigma = 1.0                 # Initial neighborhood radius\n",
    "initial_learning_rate = 0.5         # Initial learning rate\n",
    "T = 1000                            # Total number of iterations\n",
    "snapshot_interval = 100             # Save a snapshot every 100 iterations\n",
    "\n",
    "# Initialize the SOM\n",
    "som = MiniSom(som_rows, som_cols, input_len,\n",
    "              sigma=initial_sigma, learning_rate=initial_learning_rate,\n",
    "              neighborhood_function='gaussian', random_seed=42)\n",
    "# Initialize weights using PCA for faster convergence\n",
    "som.pca_weights_init(data_std)\n",
    "\n",
    "# -----------------------------\n",
    "# 3. Manual Training Loop with Process Visualization\n",
    "# -----------------------------\n",
    "for t in range(T + 1):\n",
    "    # Select a random sample from the training set\n",
    "    x = data_std[np.random.randint(0, len(data_std))]\n",
    "    \n",
    "    # Find the Best Matching Unit (BMU) for the sample x\n",
    "    winner = som.winner(x)\n",
    "    \n",
    "    # Decay the learning rate and sigma over time\n",
    "    lr = initial_learning_rate * np.exp(-t / T)\n",
    "    sig = initial_sigma * np.exp(-t / T)\n",
    "    \n",
    "    # Update the weights of each neuron in the SOM grid\n",
    "    for i in range(som_rows):\n",
    "        for j in range(som_cols):\n",
    "            neuron_location = np.array([i, j])\n",
    "            # Compute squared Euclidean distance between the neuron and the BMU (in grid coordinates)\n",
    "            distance_sq = np.sum((neuron_location - np.array(winner)) ** 2)\n",
    "            # Gaussian neighborhood function:\n",
    "            h = np.exp(-distance_sq / (2 * (sig ** 2)))\n",
    "            # Update the neuron's weight vector:\n",
    "            som._weights[i, j, :] += lr * h * (x - som._weights[i, j, :])\n",
    "    \n",
    "    # Every 'snapshot_interval' iterations, visualize and save the current state of the SOM\n",
    "    if t % snapshot_interval == 0:\n",
    "        # Compute the U-Matrix from the current SOM weights.\n",
    "        # The U-Matrix reflects the average distance between a neuron and its neighbors.\n",
    "        u_matrix = som.distance_map()\n",
    "        \n",
    "        plt.figure(figsize=(12, 10))\n",
    "        # Plot the U-Matrix heatmap with a transparent background\n",
    "        plt.pcolor(u_matrix.T, cmap='coolwarm', alpha=0.9)\n",
    "        plt.colorbar(label='Average Distance')\n",
    "        plt.title(f'SOM Training Process at Iteration {t}', fontsize=16)\n",
    "        \n",
    "        # Define different markers and colors for the Iris classes\n",
    "        markers = ['o', 's', 'D']\n",
    "        colors = ['r', 'g', 'b']\n",
    "        \n",
    "        # Plot the BMU for each training sample on the SOM grid\n",
    "        for idx, sample in enumerate(data_std):\n",
    "            bmu = som.winner(sample)\n",
    "            # Offset by 0.5 to center the marker in the cell\n",
    "            plt.plot(bmu[0] + 0.5, bmu[1] + 0.5, markers[target[idx]],\n",
    "                     markerfacecolor='None', markeredgecolor=colors[target[idx]],\n",
    "                     markersize=12, markeredgewidth=2)\n",
    "        \n",
    "        # Add legend entries for each Iris class\n",
    "        for class_idx, name in enumerate(target_names):\n",
    "            plt.scatter([], [], marker=markers[class_idx],\n",
    "                        edgecolors=colors[class_idx], facecolors='None',\n",
    "                        s=100, label=name)\n",
    "        #plt.legend(loc='upper right')\n",
    "        \n",
    "        #plt.tight_layout()\n",
    "        # Save the snapshot with a transparent background\n",
    "        filename = os.path.join(output_dir, f'som_snapshot_{t:04d}.png')\n",
    "        plt.savefig(filename, transparent=True)\n",
    "        plt.close()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}