Spaces:
Runtime error
Runtime error
| import numpy as np | |
| class DynamicalSOM: | |
| def __init__(self, input_dim, map_dim): | |
| self.input_dim = input_dim | |
| self.map_dim = map_dim | |
| self.weights = np.random.rand(map_dim[0], map_dim[1], input_dim) | |
| self.cluster_labels = np.zeros(map_dim) | |
| self.cluster_centers = np.zeros((0, input_dim)) | |
| self.num_clusters = 0 | |
| def find_best_matching_unit(self, input_vector): | |
| distances = np.linalg.norm(self.weights - input_vector, axis=-1) | |
| bmu_index = np.unravel_index(np.argmin(distances), distances.shape) | |
| return bmu_index | |
| def update_weights(self, input_vector, bmu_index, learning_rate): | |
| for i in range(self.map_dim[0]): | |
| for j in range(self.map_dim[1]): | |
| distance_to_bmu = np.linalg.norm(np.array([i, j]) - np.array(bmu_index)) | |
| neighborhood_function = np.exp(-(distance_to_bmu**2) / (2 * learning_rate**2)) | |
| self.weights[i, j] += neighborhood_function * learning_rate * (input_vector - self.weights[i, j]) | |
| def train(self, input_data, num_epochs, initial_learning_rate): | |
| for epoch in range(num_epochs): | |
| learning_rate = initial_learning_rate * np.exp(-epoch / num_epochs) | |
| np.random.shuffle(input_data) | |
| for input_vector in input_data: | |
| bmu_index = self.find_best_matching_unit(input_vector) | |
| self.update_weights(input_vector, bmu_index, learning_rate) | |
| def cluster_neurons(self): | |
| # Initialize cluster centers with the first neuron's weight vector | |
| self.cluster_centers = np.expand_dims(self.weights[0, 0], axis=0) | |
| # Assign all neurons to the first cluster | |
| self.cluster_labels[:] = 0 | |
| for i in range(self.map_dim[0]): | |
| for j in range(self.map_dim[1]): | |
| # Calculate the distance between the current neuron and each cluster center | |
| distances_to_clusters = np.linalg.norm(self.weights[i, j] - self.cluster_centers, axis=-1) | |
| # Find the closest cluster center | |
| closest_cluster_index = np.argmin(distances_to_clusters) | |
| # Assign the neuron to the closest cluster | |
| self.cluster_labels[i, j] = closest_cluster_index | |
| # Update cluster centers based on the mean of neurons in each cluster | |
| for cluster_index in range(self.num_clusters): | |
| cluster_neurons_indices = np.where(self.cluster_labels == cluster_index) | |
| cluster_neurons = self.weights[cluster_neurons_indices] | |
| cluster_center = np.mean(cluster_neurons, axis=0) | |
| self.cluster_centers[cluster_index] = cluster_center | |
| def introduce_fox_neuron(self): | |
| if self.num_clusters > 1: | |
| # Calculate distances between cluster centers | |
| distances = np.linalg.norm(self.cluster_centers[:, np.newaxis, :] - self.cluster_centers, axis=-1) | |
| # Find the indices of the two closest clusters | |
| closest_clusters_indices = np.unravel_index(np.argpartition(distances, 1, axis=None)[:2], distances.shape) | |
| # Average the two cluster centers to get the fox neuron | |
| fox_neuron = np.mean(self.cluster_centers[closest_clusters_indices], axis=0) | |
| # Add the fox neuron to the map | |
| self.weights = np.append(self.weights, np.expand_dims(fox_neuron, axis=(0, 1)), axis=0) | |
| self.num_clusters += 1 | |
| # Update cluster labels with the new neuron | |
| self.cluster_labels = np.append(self.cluster_labels, np.full((1, self.map_dim[1]), self.num_clusters - 1), axis=0) | |
| def summary(self): | |
| print("Dynamical Self-Organizing Map Summary:") | |
| print("Input Dimension:", self.input_dim) | |
| print("Map Dimension:", self.map_dim) | |
| print("Number of Neurons:", self.map_dim[0] * self.map_dim[1]) | |
| print("Number of Clusters:", self.num_clusters) | |
| # Example usage: | |
| input_data = np.random.rand(1000, 100) | |
| map_dimensions = (10, 10) | |
| som = DynamicalSOM(input_dim=100, map_dim=map_dimensions) | |
| num_epochs = 100 | |
| initial_learning_rate = 0.1 | |
| som.train(input_data, num_epochs, initial_learning_rate) | |
| som.cluster_neurons() | |
| som.introduce_fox_neuron() | |
| som.summary() | |