def main(): #Load .xls .xlsx file file_name = raw_input('File name: ') work_book = load_workbook(file_name) #Load sheet print (work_book.get_sheet_names()) sheet_name = raw_input('\nSheet name: ') work_sheet = work_book.get_sheet_by_name(sheet_name) #Select workspace in sheet begin_position = raw_input('Begin position: ') end_position = raw_input('End position: ') workspace = work_sheet[begin_position : end_position] #Workspace(begin, end) #Load data training_set = [] for row in workspace: class_name = row[0].value # first column is class name for item in row[1:]: # skip first column inputs = np.array([item.value]) training_set.append((inputs, class_name)) #Create SOM ANN som_ann = SOM((1, 4, 4)) #Train network print 'Wait, I\'m traning...' som_ann.train([i[0] for i in training_set], 200, -1, 'quadratic') somplot(som_ann, training_set)
def som(self, m, n, dim, iterations): # step 4 trainData = numpy.zeros((len(self.contrastPoints), 1)) for i in range(len(self.contrastPoints)): trainData[i] = [self.contrastPoints[i]] som = SOM(m, n, dim, iterations) som.train(trainData) mapped = som.map_vects(trainData) d0 = 0 d1 = 0 d2 = 0 for d, m in zip(trainData, mapped): mapv = m[0] + m[1] if (d0 == 0 and mapv == 0): d0 = d[0] if d0 < d[0] else d0 if (d1 == 0 and mapv == 1): d1 = d[0] if d1 < d[0] else d1 if (d2 == 0 and mapv == 2): d2 = d[0] if d2 < d[0] else d2 least = 0 if d0 < d1 and d0 < d2 else (1 if d1 < d0 and d1 < d2 else (2 if d2 < d1 and d2 < d0 else 0)) most = 0 if d0 > d1 and d0 > d2 else (1 if d1 > d0 and d1 > d2 else (2 if d2 > d1 and d2 > d0 else 0)) mean = 0 if d0 > d1 and d0 < d2 else (1 if d1 > d0 and d1 < d2 else (2 if d2 > d1 and d2 < d0 else 0)) print(d0, d1, d2) print(least, most, mean) self.mappingDict = {'least': least, 'mean': mean, 'most': most} self.blocksMapping = mapped
def call_som(m, n, dim, input_data, weight_after_insertion=None, alpha=None, sigma=None): # get the shape of input data inorder to calc iternumber in SOM iter_no = input_data.shape[0]*10 som = SOM(m, n, dim, weight_after_insertion, n_iterations= iter_no) trained_weight = som.train(input_data) mapped = som.map_vects(input_data) result = np.array(mapped) return trained_weight, result
def on_clicked_train(self, widget): print("train") som = SOM(self.net_size_x_sb.get_value_as_int(), self.net_size_y_sb.get_value_as_int(), self.standar_diviison_sb.get_value() / 10, self.learning_rate_sb.get_value() / 10, self.training_times_sb.get_value_as_int(), self.status_flag) som.net_init() thread = threading.Thread(target=som.training(self.training_set[0], self.draw_function)) thread.daemon = True thread.start() # som.printnet() self.draw_function(som.get_net()) print("end")
def call_som(m, n, dim, input_data, weight_after_insertion=None, alpha=None, sigma=None): som = SOM(m, n, dim, weight_after_insertion) trained_weight = som.train(input_data) mapped = som.map_vects(input_data) result = np.array(mapped) return trained_weight, result
def solve_tsp(filename: str): # Parse problem from txt file problem = parse_tsp_problem(filename) cases = problem[:, 1:] # Initialize self organizing map som = SOM(cases=cases) # Train som.train() # Use Som weights to generate a solution for tsp problem solution = create_tsp_solution(som.cases, som.weights) visualize_tsp(solution, som.weights)
def __init__(self, dataset, nodes, sigma_0, learn_rate_0, total_iterations, scaler, sigma_timeconst, learn_t, plot_interval): SOM.__init__(self, dataset, nodes, sigma_0=sigma_0, learn_rate_0=learn_rate_0, total_iterations=total_iterations, sigma_timeconst=sigma_timeconst, learn_timeconst=learn_t, plot_interval=plot_interval, graphics=TSPGraphics()) self.scaler = scaler
def SortingSelfOrganizingMap(Feature_List): # Train a SS_LINES x SS_COLS self-organizing map using NUM_ITERATIONS iterations som = SOM(SS_LINES, SS_COLS, len(Feature_List[0]), NUM_ITERATIONS) som.train(Feature_List) mapped = som.map_vects(Feature_List) # Grayscale landscape sorting_landscape = np.zeros((SS_LINES, SS_COLS), np.float16) for i in range(len(mapped)): lin = mapped[i][0] col = mapped[i][1] sorting_landscape[lin][col] = Feature_List[i][0] io.imsave('sorted_landscape.png', sorting_landscape)
def __init__(self, train_x, train_y, test_x, test_y, nodes, sigma_0, learn_rate_0, total_iterations, learn_rate_timeconst, scaler, sigma_timeconst, plot_interval): SOM.__init__(self, train_x, nodes, sigma_0, learn_rate_0, sigma_timeconst, learn_rate_timeconst, total_iterations, plot_interval=plot_interval, graphics=MNISTGraphics()) self.scaler = scaler self.train_y = train_y self.test_x = test_x self.test_y = test_y
def som_plot(img, som_dim): # Method for creating a small Kohonen Self-Organizing Map (SOM) of the image and # plotting the SOM on the screen. RGB values of the colors are printed on the screen. # Select small amount of random pixels from the image. n_pixels = 500 colors = shuffle(img.reshape((img.shape[0] * img.shape[1], 3)))[:n_pixels] print('\n') print('=' * 80) print('Self-Organized Map of {} randomly picked colors:'.format(som_dim * som_dim)) # Train the SOM model with small amount of iterations. som = SOM(som_dim, som_dim, 3, 10) som.train(colors) #Get output grid from the SOM. This is plotted as color palette. image_grid = som.get_centroids() plt.figure(figsize=(5, 5)) plt.imshow(image_grid) plt.title('Color map') plt.show() # Create RGB palette values from the image_grid. grid = np.array(image_grid) grid *= 255 grid = grid.astype(np.int) rgb_df = pd.DataFrame(np.zeros((som_dim, som_dim))) hex_df = pd.DataFrame(np.zeros((som_dim, som_dim))) for i in range(som_dim): for j in range(som_dim): rgb_df.iloc[i, j] = str(grid[i, j]) hex_color = '#{:02x}{:02x}{:02x}'.format(grid[i, j, 0], grid[i, j, 1], grid[i, j, 2]) hex_df.iloc[i, j] = hex_color print('RGB values:') print(rgb_df) print('\n') print('HEX color values:') print(hex_df)
def max_dist(som): """calculate maximum distance between code vectors""" max_distance = 0 for q in som.nodes: for i in som.nodes: d = SOM.vector_distance(q.weights, i.weights) if d > max_distance: max_distance = d return max_distance
def main(): ''' Create and train a SOM with the XOR problem SOM settings ------------ The SOM used in this test works in a 2D space with a map's weights of 2x2 Train settings --------------- The SOM will be trained with the XOR problem, this training will run in 2000 iterations. In the weights adjustment function, a zero neighborhood radius, that mean that only the winner neuron's weights will be updated. ''' som_ann = SOM((2, 2, 2)) training_set = [ np.array([1, 0]), np.array([0, 1]), np.array([1, 1]), np.array([0, 0]), ] #Train network converged, epochs = som_ann.train(training_set, 2000, -1, 'zero') if not converged: print 'SOM didn\'t converge with the minimum learning rate\n' else: print 'SOM converged in {0} epochs\n'.format(epochs) #Mapping values for entry in training_set: class_name = som_ann.map(entry) print 'The object {0} belongs to class: {1}'.format(entry, class_name) #Get the full mapped classes print '' elements = som_ann.get_mapped_classes() print elements
def main(): img_list = glob.glob(join(in_path, '*.jpg')) vectors = np.empty((0, 64 * 48 * 3), int) for i, _file in enumerate(img_list): print(_file) try: np_img, raw = read_img(_file) except OSError as e: print(e.strerror) continue vectors = np.append(vectors, np_img, axis=0) #if i > 100: # break N = 200 som = SOM(vectors, N=N, seed=10) # learn som.learn(vectors) with open('som.pickle', mode='wb') as f: pickle.dump(som, f) print(som.W.shape)
def SelfOrganizingMap(Feature_List): som = SOM(SOM_LINES, SOM_COLS, len(Feature_List[0]), SOM_ITERATIONS) som.train(Feature_List) image_grid = som.get_centroids() mapped = som.map_vects(Feature_List) return mapped, image_grid
def main(): # FIT THE LDA lda = TagsLDA(skip=10) theta, beta = lda.train(ntopics=30, niter=300, seed=42) # TRAIN THE SOM dist_func = lambda p, q: divergence(p, q) som = SOM(grid_shape=(20, 20), ndims=lda.nterms, dist_func=dist_func) # len(dictionary) = len(dictionary.token2id) som.train(lda.beta, nepochs=10) # PLOT labels = [lda.topic_representatives(i, topn=3, show_scores=False) for i in range(lda.ntopics)] areas = np.array([30*2*np.pi*score**2 for score in lda.topic_significances()]) areas_top, top_indices = zip(*sorted([(a, i) for i, a in enumerate(areas)], reverse=True)[:10]) locations = som.get_locations(vecs=lda.beta[top_indices, :], labels=labels) # print(locations) labels, data = zip(*locations.items()) x, y = zip(*data) plt.scatter(x, y, s=areas_top, alpha=0.5) for l, x, y in zip(labels, x, y): plt.annotate(l, xy=(x, y), textcoords='offset points', xytext=(0, 20), horizontalalignment='center') plt.show()
def SelfOrganizingMap(feature_list): no_features = len(feature_list[0]) print('Clustering', no_features, 'features') som = SOM(SOM_LINES, SOM_COLS, no_features, SOM_ITERATIONS, alpha=ALPHA, sigma=SIGMA) som.train(feature_list) image_grid = som.get_centroids() mapped = som.map_vects(feature_list) return mapped, image_grid
def load_som(net_name): """ loads som from directory net_name """ global som if not os.path.exists(net_name): print("No such som") return weightages = np.load(net_name + output_weightages + ".npy") locations = np.load(net_name + output_locations + ".npy") with open(net_name + output_properties_file) as input: properties = json.load(input) som = SOM(properties["m"], properties["n"], properties["dim"], properties["n_iterations"], properties["alpha"], properties["sigma"], properties["trained_iterations"], weightages, locations, properties["trained"])
def main(in_file, out_file, x, y, epochs, ref=None, test=False, verbose=0): if test: df = pd.DataFrame(in_file, columns=range(in_file.shape[1])) else: df = pd.read_table(in_file, sep='\t', low_memory=True, index_col=0) s = df.shape[0] df.dropna(axis=0, how='any', inplace=True) sn = df.shape[0] if s != sn: logger.warning('%d rows dropped due to missing values' % (s - sn)) s = df.shape[1] df = df.select_dtypes(include=[np.number]) sn = df.shape[1] if s != sn: logger.warning('%d columns dropped due to non-numeric data type' % (s - sn)) basedir = os.path.dirname(os.path.abspath(__file__)) som = SOM(x, y) if ref == 'IRCI': som = som.load('/SOM.pkl') embedding = som.winner_neurons(df.values) else: som.fit(df.values, epochs, verbose=verbose) embedding = som.winner_neurons(df.values) if ref == 'Create': som.save(basedir + '/SOM.pkl') emb_df = pd.DataFrame({'ID': df.index}) emb_df['X'] = embedding[:, 1] emb_df['Y'] = embedding[:, 0] if test: return emb_df else: emb_df.to_csv(out_file, index=False, sep='\t')
def main(): # Training inputs for RGBcolors credits_data = pd.read_csv("testdata/credit_train.csv", header=None) columns = credits_data.columns train_data = credits_data[columns[:-1]].copy().values label_data = credits_data[columns[-1]].copy().values train_data_scale = preprocessing.scale(train_data) # colors = np.array( # [[0., 0., 0.], # [0., 0., 1.], # [0., 0., 0.5], # [0.125, 0.529, 1.0], # [0.33, 0.4, 0.67], # [0.6, 0.5, 1.0], # [0., 1., 0.], # [1., 0., 0.], # [0., 1., 1.], # [1., 0., 1.], # [1., 1., 0.], # [1., 1., 1.], # [.33, .33, .33], # [.5, .5, .5], # [.66, .66, .66]]) # color_names = \ # ['black', 'blue', 'darkblue', 'skyblue', # 'greyblue', 'lilac', 'green', 'red', # 'cyan', 'violet', 'yellow', 'white', # 'darkgrey', 'mediumgrey', 'lightgrey'] # Train a 20x30 SOM with 400 iterations som = SOM(1, 2, len(columns) - 1, 400) som.train(train_data_scale) # Get output grid image_grid = som.get_centroids() # Map colours to their closest neurons mapped = som.map_vects(train_data_scale) # Plot plt.imshow(image_grid) plt.title('Color SOM') for i, m in enumerate(mapped): plt.text(m[1], m[0], label_data[i], ha='center', va='center', bbox=dict(facecolor='white', alpha=0.5, lw=0)) plt.show()
def run(data, musics): som = SOM(30, 30) # initialize the SOM som.fit(data, 20000) # fit the SOM for 2000 epochs #targets = len(data) * [0] # create some dummy target values # vizualizando as paradas, ver se pego o que eu precido # som.plot_point_map(data, targets, ['class 1', 'class 2'], filename='./results/som.png') # som.plot_class_density(data, targets, 0, filename='./results/class_0.png', names=['a', 'b', 'c'], mode) # som.plot_density_map(data, filename='som1.png') #preparando para clusterizar, denovo winners = som.winner_map(data) #plt.imshow(winners, interpolation='nearest', extent=(0.5,10.5,0.5,10.5)) #plt.colorbar() #plt.show() points = [] for i in range(0, len(winners)): for j in range(0, len(winners[0])): points.append([i, j, winners[i][j]]) # create dendrogram para imprimir #dendrogram = sch.dendrogram(sch.linkage(points, method='ward')) # create clusters hc = AgglomerativeClustering(n_clusters=6, affinity='euclidean', linkage='ward') # save clusters for chart y_hc = hc.fit_predict(points) for j in range(0, len(y_hc)): point = points[j] winners[point[0], point[1]] = y_hc[j] #vizualizando a qualidade da clusterizacao #plt.matshow(winners) #plt.show() for music in musics: winner = som.winner(music.toObject()['valor']) music.setGroupKon(winners[winner[0]][winner[1]])
def tensorSOM(): import numpy as np from som import SOM import tensorflow as tf sess = tf.InteractiveSession() map_size = 30 s = SOM(input_shape=(num_features, ), map_size_n=map_size, num_expected_iterations=epochs, session=sess) sess.run(tf.initialize_all_variables()) #Training inputs for i in range(10): print('Epoch: {0}'.format(i)) rnd_ind = np.random.randint(0, len(X)) s.train(X[rnd_ind, :]) print(np.reshape(s.get_weights(), [map_size, map_size, num_features])) print(np.array(y) * s.get_weights())
def som3(self, m, n, dim, iterations): # step 4 trainData = numpy.zeros((len(self.contrastPoints), 3)) for i in range(len(self.contrastPoints)): trainData[i] = [self.diagonalContrast[i], self.verticalContrast[i], self.horizontalContrast[i]] som = SOM(m, n, dim, iterations) som.train(trainData) mapped = som.map_vects(trainData) d0 = 0 d1 = 0 d2 = 0 for d, m in zip(trainData, mapped): mapv = m[0] + m[1] if (d0 == 0 and mapv == 0): d0 = d[0] if d0 < d[0] else d0 if (d1 == 0 and mapv == 1): d1 = d[0] if d1 < d[0] else d1 if (d2 == 0 and mapv == 2): d2 = d[0] if d2 < d[0] else d2 arr = numpy.array([d0, d1, d2]) most = numpy.argmax(arr) numpy.delete(arr, most, 0) least = numpy.argmin(arr) numpy.delete(arr, least, 0) mean = 0 if (arr[most] == d1 or arr[most] == d2) and (arr[least] == d1 or arr[least] == d2) else (1 if (arr[most] == d0 or arr[most] == d2) and (arr[least] == d0 or arr[least] == d2) else 2) self.mappingDict = {'least': least, 'mean': mean, 'most': most} self.blocksMapping = mapped self.neuronsMap = som.get_centroids()
def test_across_root(self): new = '/home/user/firefox/bookmarks' original = '/var/log/gnome' distance = SOM.path_distance(original, new) self.assertEqual(distance, 7)
[0., 1., 0.], [1., 0., 0.], [0., 1., 1.], [1., 0., 1.], [1., 1., 0.], [1., 1., 1.], [.33, .33, .33], [.5, .5, .5], [.66, .66, .66]]) color_names = \ ['black', 'blue', 'darkblue', 'skyblue', 'greyblue', 'lilac', 'green', 'red', 'cyan', 'violet', 'yellow', 'white', 'darkgrey', 'mediumgrey', 'lightgrey'] data = list() for i in range(colors.shape[0]): data.append(torch.FloatTensor(colors[i, :])) #Train a 20x30 SOM with 100 iterations n_iter = 100 som = SOM(m, n, 3, n_iter) for iter_no in range(n_iter): #Train with each vector one by one for i in range(len(data)): som(data[i], iter_no) #Store a centroid grid for easy retrieval later on centroid_grid = [[] for i in range(m)] weights = som.get_weights() locations = som.get_locations() for i, loc in enumerate(locations): centroid_grid[loc[0]].append(weights[i].numpy()) #Get output grid image_grid = centroid_grid
from som import SOM s = SOM() # teste do método distância euclidiana d = s.distancia([2, 1, 1], [4, 2, 3]) print(d, ' = 3') posM = s.melhorNeuronio([17, 13, 22]) print(posM) print(s.matrizNeuronios[posM[0]][posM[1]]) r = s.melhorReposta([17, 13, 22]) print(r)
train_data = datasets.FashionMNIST(DATA_DIR, train=True, download=True, transform=transform) train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True) else: print('Please set specify dataset. --mnist, --fashion_mnist') exit(0) train_data.train_data = train_data.train_data[:5000] train_data.train_labels = train_data.train_labels[:5000] print('Building Model...') som = SOM(input_size=28 * 28 * 1, out_size=(row, col)) if os.path.exists('%s/som.pth' % MODEL_DIR): som.load_state_dict(torch.load('%s/som.pth' % MODEL_DIR)) print('Model Loaded!') else: print('Create Model!') som = som.to(device) if train == True: losses = list() for epoch in range(total_epoch): running_loss = 0 start_time = time.time() for idx, (X, Y) in enumerate(train_loader): X = X.view(-1, 28 * 28 * 1).to(device) # flatten loss = som.self_organizing(X, epoch, total_epoch) # train som
def main(): # generate some random data with 36 features data1 = np.random.normal(loc=-.25, scale=0.5, size=(500, 36)) data2 = np.random.normal(loc=.25, scale=0.5, size=(500, 36)) data = np.vstack((data1, data2)) som = SOM(10, 10) # initialize the SOM som.fit(data, 10000, save_e=True, interval=100 ) # fit the SOM for 10000 epochs, save the error every 100 steps som.plot_error_history( filename='images/som_error.png') # plot the training error history targets = np.array(500 * [0] + 500 * [1]) # create some dummy target values # now visualize the learned representation with the class labels som.plot_point_map(data, targets, ['Class 0', 'Class 1'], filename='images/som.png') som.plot_class_density(data, targets, t=0, name='Class 0', filename='images/class_0.png') som.plot_distance_map(filename='images/distance_map.png' ) # plot the distance map after training
colors = np.append(colors, np.array([[0, 0, 0]]), axis=0) colors = np.append(colors, np.array([[1, 1, 1]]), axis=0) for i in range(10): colors = np.append(colors, np.array([[0, 0, random.random()]]), axis=0) colors = np.append(colors, np.array([[0, random.random(), 0]]), axis=0) colors = np.append(colors, np.array([[random.random(), 0, 0]]), axis=0) colors = np.append(colors, np.array([[1, 1, random.random()]]), axis=0) colors = np.append(colors, np.array([[1, random.random(), 1]]), axis=0) colors = np.append(colors, np.array([[random.random(), 1, 1]]), axis=0) colors = np.append(colors, np.array([[0, random.random(), random.random()]]), axis=0) colors = np.append(colors, np.array([[random.random(), random.random(), 0]]), axis=0) colors = np.append(colors, np.array([[1, random.random(), random.random()]]), axis=0) colors = np.append(colors, np.array([[random.random(), random.random(), 1]]), axis=0) colors = np.append(colors, np.array([[random.random(), random.random(), random.random()]]), axis=0) data = torch.Tensor(colors) row = 40 col = 40 total_epoch = 1000 som = SOM(3, (row, col)) for iter_no in range(total_epoch): som.self_organizing(data, iter_no, total_epoch) weight = som.weight.reshape(3, row, col).numpy() weight = np.transpose(weight, (1, 2, 0,)) plt.title('Color SOM') plt.imshow(weight) plt.show()
#Plot plt.imshow(image_grid) plt.title('Color SOM') for i, map_ in enumerate(mapped): plt.text(map_[1], map_[0], color_names[i], ha='center', va='center', bbox=dict(facecolor='white', alpha=0.5, lw=0)) #Train a 20x30 SOM with 100 iterations n_iter = 100 som = SOM(m, n, 3, n_iter) for iter_no in range(n_iter): #Train with each vector one by one som(data_t, iter_no) mapped = som.map_vects(torch.Tensor(colors)) def infer(som, color_rgb): required = som.get_bmu_loc(torch.Tensor(color_rgb)) dists = som.pdist(torch.stack([required for i in range(len(mapped))]), torch.stack(mapped)) min_dist, min_dist_index = torch.min(dists, 0)
def normalized_distance(n1, n2, max_dist): return SOM.vector_distance(n1.weights, n2.weights) * MAX_NORMALIZED_DISTANCE / max_dist
def test_same(self): original = '/home/user/test.txt' new = '/home/user/test.txt' distance = SOM.path_distance(original, new) self.assertEqual(distance, 0)
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with sompy. If not, see <http://www.gnu.org/licenses/>. """ import random from som import SOM from distance_functions import euclidean from damping_functions import exponentional_damping from neighbourhood_functions import mexican_hat_with_sigma from fill_functions import random_fill som = SOM(n = 4, dimensions = 5, fill = random_fill) samples = [[random.gauss(m, 0.1) for e in range(0, 5)] for m in range(0, 20) for sample in range(0,10)] # training for index in range(0, len(samples)): # learn_rate as a factor of how much the weight vectors are # pulled to the target vector. learn_rate = exponentional_damping(\ start = 1.0, end = 0.1,\ t = float(index), tmax = len(samples)) # sigma influences neighbourhood radius
def test_down_file(self): new = '/home/user/doc.pdf' original = '/home/user' distance = SOM.path_distance(original, new) self.assertEqual(distance, 1)
def test_down_folder(self): new = '/home/user/typography/doc.pdf' original = '/home/user' distance = SOM.path_distance(original, new) self.assertEqual(distance, 2)
#For plotting the images from matplotlib import pyplot as plt import numpy as np from som import SOM colors = np.array( [[0., 0., 1.], [0., 0., 0.95], [0., 0.05, 1.], [0., 1., 0.], [0., 0.95, 0.], [0., 1, 0.05], [1., 0., 0.], [1., 0.05, 0.], [1., 0., 0.05], [1., 1., 0.]]) som = SOM(4, 4, 3) som.train(colors) plt.imshow(som.centroid_grid) plt.show()