from som import SOM
from plot import plot_neuron_chains, plot_loss, plot_routes
from opts import OPT
if __name__ == '__main__':
args = OPT().args()
if args.mode == 'run':
SOM(args)
else:
plot_loss(input_dir=args.out_dir)
plot_routes(input_dir=args.out_dir)
plot_neuron_chains(input_dir=args.out_dir)
parametros = None
with open('./parametros.txt', 'r') as inp:
parametros = inp.read().splitlines()
return parametros
if __name__ == "__main__":
pre_process = ProcessZoo()
animal_matrix = pre_process.get_original_matrix()
for parametros in le_parametros():
############################# SOM #############################
print(parametros)
_mapsize = int(parametros[0]) * 10
som = SOM(animal_matrix=animal_matrix,
mapsize=[_mapsize, _mapsize],
parametros=parametros)
# som.view2dpacked()
# som.train_som()
# som.view2dpacked()
# som.visualization_umatrix()
# som.interpolation()
############################# KMEANS #############################
kmeans = Kmeans(points=animal_matrix,
k_centroids=4,
n_iteracoes=100,
error=0.1)
kmeans.run_kmeans()
############################# POS PROCESSAMENTO #############################
def display_digit(num):
label = y_train[num].argmax(axis=0)
image = x_train[num].reshape([28, 28])
plt.title('Example: %d Label: %d' % (num, label))
plt.imshow(image, cmap=plt.get_cmap('gray_r'))
plt.show()
display_digit(ran.randint(0, x_train.shape[0]))
# Import som class and train into 30 * 30 sized of SOM lattice
from som import SOM
som = SOM(30, 30, x_train.shape[1], 200)
som.train(x_train)
# Fit train data into SOM lattice
mapped = som.map_vects(x_train)
mappedarr = np.array(mapped)
x1 = mappedarr[:, 0]
y1 = mappedarr[:, 1]
index = [np.where(r == 1)[0][0] for r in y_train]
index = list(map(str, index))
## Plots: 1) Train 2) Test+Train ###
plt.figure(1, figsize=(12, 6))
plt.subplot(121)
#Map colours to their closest neurons
mapped = som.map_vects(torch.Tensor(colors))
#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)
if iter_no % 5 == 0:
draw_som(som)
plt.pause(0.0001)
plt.clf()
print(f"Trained {iter_no} iterations")
plt.ioff()
draw_som(som)
plt.show()
[1., 1., 1.],
[.33, .33, .33],
[.5, .5, .5],
[.66, .66, .66]])
colors2 = np.array(
[[0., 0., 0.],
[0., 0., 1.],
[1., 1., 0.],
[1., 1., 1.],
[1., 0., 0.]])
color_names = \
['black', 'blue', 'darkblue', 'skyblue',
'greyblue', 'lilac', 'green', 'red',
'cyan', 'violet', 'yellow', 'white',
'darkgrey', 'mediumgrey', 'lightgrey']
s = SOM(colors2, [25, 25], alpha=0.3)
# Initial weights
plt.imshow(s.w_nodes)
plt.show()
# Learning to cluster the RGB colors
s.train(max_it=30)
# Trained weights
plt.imshow(s.w_nodes)
plt.show()
#Training inputs for RGBcolors
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(10, 10, 3, 400)
som.train(colors)
#Get output grid
image_grid = som.get_centroids()
#Map colours to their closest neurons
mapped = som.map_vects(colors)
#Plot
plt.imshow(image_grid)
plt.title('Color SOM')
for i, m in enumerate(mapped):
plt.text(m[1],
m[0],
sig = sig[:,[0,1,2,3,4,5,6,7]] # cuts the signal array to only include variables you want to train on
### PREPARE THE BACKGROUND ARRAY ###
bg = np.loadtxt('eta_mc_som_background_feb2019.txt') # convert to np array
np.random.shuffle(bg)
bg = bg[:2000,:]
bg2 = bg
backupbg = bg2
#bg = bg[:10000,:] # cut the np array to preferred size
flag_bg = bg[:,8] # array of zeros for background, flags each event as background
bg = bg[:,[0,1,2,3,4,5,6,7]] # cuts the background array to only include variables you want to train on
# finish preparing the final dataset (one big numpy array)
data = np.concatenate((sig,bg),axis=0) # concatenate the sig and bg numpy arrays into one big array
flags = np.concatenate((flag_sig, flag_bg), axis=0) # concatenates the flag arrays into one array, each entry corresponding to the entry of the data array
### TRAINING ###
#som = SOM(dimx, dimy, 8, 400) # Train a dimx X dimy SOM with 400 iterations, 8 is the number of variables in the data array
som = SOM(dimx, dimy, 8)
som.train(data) # trains on the dataset prepared
### THIS WILL TAKE AWHILE ###
### TO STORE THE TRAINING RESULTS INTERACTIVELY IN ipython DO:
### weightages = som._weightages
### %store weightages
### THEN TO RECOVER DO:
### %store -r
### som = SOM(dimx, dimy, 8, 400)
### som._weightages = weightages
### som._trained = True
print(str(datetime.datetime.now())) # print the time to observe how long the training will take
mapped = np.array(som.map_vects(data)) # map each datapoint to its nearest neuron
# post training manipulations to the final dataset (one big numpy array)
data = np.append(data,mapped,axis=1) # append the mapped neurons to data
data = np.column_stack((data,flags)) # append the flags to the dataset
import matplotlib.pyplot as plt
from som import SOM
inputs = [[1, 4], [6, 2], [1, 3], [5, 1], [4, 0], [0, 4]]
weights = [[5, 0], [-1, 4]]
sigma = 1
learning_rate = 1
sigma_decrease_rate = 0
som = SOM(inputs,
weights,
sigma=sigma,
learning_rate=learning_rate,
sigma_decrease_rate=sigma_decrease_rate,
epochs=10)
som.train(ignore_hk=True, display=True)
points = [[1, 4], [6, 2], [1, 3], [5, 1], [4, 0], [0, 4], [3, 4]]
predictions = som.predict(points, ignore_hk=True, display=True)
p, m = som.prediction_line(display=True)
def med(points, p, m):
y = []
for point in points:
y.append(m * (point - p[0]) + p[1])
return y
def SelfOrganizingMap(Feature_List, where):
if not os.path.exists(where):
os.makedirs(where)
som = SOM(SOM_LINES, SOM_COLS, len(Feature_List[0]), NUM_ITERATIONS)
som.train(Feature_List)
# Get output grid
image_grid = som.get_centroids()
#print 'Image grid shows weights for all the input features'
#print image_grid
# Get vector mappings
mapped = som.map_vects(Feature_List)
#print 'Mapping', mapped
# Visualization part
# Needs to be refactored to produce output for any number of clusters
avg_line = []
for i in range(NUM_CLUST):
avg_line.append(0)
avg_column = []
for i in range(NUM_CLUST):
avg_column.append(0)
for i in range(0, len(mapped), NUM_CLUST):
for j in range(NUM_CLUST):
avg_line[(i + j) % NUM_CLUST] += mapped[i + j][0]
avg_column[(i + j) % NUM_CLUST] += mapped[i + j][1]
for i in range(len(avg_line)):
avg_line[i] = avg_line[i] / (len(mapped) / NUM_CLUST)
for i in range(len(avg_column)):
avg_column[i] = avg_column[i] / (len(mapped) / NUM_CLUST)
'Average location'
print avg_line, avg_column
# Grayscale landscape
sorting_landscape = []
for i in range(NUM_CLUST):
sorting_landscape.append(np.zeros((SOM_LINES, SOM_COLS), np.float16))
for i in range(len(mapped)):
lin = mapped[i][0]
col = mapped[i][1]
sorting_landscape[i % NUM_CLUST][lin][col] += 0.05
if sorting_landscape[i % NUM_CLUST][lin][col] > 1.0:
sorting_landscape[i % NUM_CLUST][lin][col] = 1.0
for i in range(NUM_CLUST):
sorting_landscape[i][avg_line[i]][avg_column[i]] = 1.0
for i in range(NUM_CLUST):
io.imsave(where + str(i) + '_sorting_cluster.png',
sorting_landscape[i])
# Colored landscape
colored_landscape = np.zeros((SOM_LINES, SOM_COLS, 3), np.float16)
white = np.array([1.0, 1.0, 1.0])
# sorting
insertion_color = np.array([0.0, 0.0, 1.0]) # blue
bubble_color = np.array([0.0, 1.0, 0.0]) # green
heap_color = np.array([1.0, 0.0, 0.0]) # red
quick_color = np.array([1.0, 0.0, 1.0]) # magenta
random_color = np.array([1.0, 1.0, 0.0]) # yellow
# non-sorting
reverseSorted_color = np.array([0.0, 1.0, 1.0]) # cyan
intervalSwapSorted_color = np.array([1.0, 0.5, 0.0]) # orange
reverse_color = np.array([0.5, 1.0, 0.0]) # lime-green
intervalSwap_color = np.array([1.0, 0.0, 0.5]) # fuchsia
colored = [
insertion_color, bubble_color, heap_color, quick_color, random_color
]
#add_colored = [reverseSorted_color, intervalSwapSorted_color, reverse_color, intervalSwap_color]
#colored.extend(add_colored)
grad = 0.005
for i in range(len(mapped)):
lin = mapped[i][0]
col = mapped[i][1]
colored_landscape[lin][col] += grad * colored[i % NUM_CLUST]
#if colored_landscape[lin][col].any() > 1.0:
# colored_landscape[lin][col] -= 0.05*colored[i%NUM_CLUST]
for i in range(NUM_CLUST):
colored_landscape[avg_line[i]][
avg_column[i]] = 0.3 * white + 0.7 * colored[i]
io.imsave(where + 'all_sorting_clusters.png', colored_landscape)
#the samples with which the map will be trained, basically these are vectors representing RGB colors
training_samples = 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]])
#the color's corresponding names, to label the plot
color_names = \
['black', 'blue', 'darkblue', 'skyblue',
'greyblue', 'lilac', 'green', 'red',
'cyan', 'violet', 'yellow', 'white',
'darkgrey', 'mediumgrey', 'lightgrey']
som = SOM(60, 100, 3)
start = time.time()
scaling_factor = 1e2
som.train(training_samples, 400, 0.8, scaling_factor, 20, scaling_factor)
end = time.time()
total_time = end - start
print("Elapsed time: {}".format(total_time))
pl.imshow(som.som, origin='lower')
#label each weight with its corresponding name
for i in range(len(training_samples)):
bmu = som.get_bmu(training_samples[i])
pl.text(bmu[1],
bmu[0],
color_names[i],
ha='center',
return X, Y
if __name__ == "__main__":
with open('wine.data', 'r', encoding='utf-8') as f:
data = f.read()
data = data.split('\n')[:-1]
X, Y = make_XY(data)
X = feature_normalization(X)
# exit()
FEATURE_COUNT = len(X[0])
CLASS_COUNT = len(list(set(Y)))
print('FEATURE_COUNT:%d' % FEATURE_COUNT)
print('CLASS_COUNT:%d' % CLASS_COUNT)
som = SOM(8, 8) # initialize the SOM
som.fit(X, 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
# now visualize the learned representation with the class labels
som.plot_point_map(X,
Y, ['Class %d' % (l + 1) for l in range(CLASS_COUNT)],
filename='images/som.png')
for i in range(CLASS_COUNT):
som.plot_class_density(X,
Y,
t=i,
name='Class %d' % (i + 1),
filename='images/class_%d.png' % (i + 1))
sig = sig[:10000,:] # cut the np array to preferred size flag_sig = sig[:,35] # array of ones for signal, flags each event as signal sig = sig[:,[24,25,26,29,30,31,32,34]] # cuts the signal array to only include variables you want to train on ### PREPARE THE BACKGROUND ARRAY ### bg = np.array(bgroot.tolist()) # convert to np array np.random.shuffle(bg) bg2 = bg backupbg = bg2 bg = bg[:10000,:] # cut the np array to preferred size flag_bg = bg[:,35] # array of zeros for background, flags each event as background bg = bg[:,[24,25,26,29,30,31,32,34]] # cuts the background array to only include variables you want to train on # finish preparing the final dataset (one big numpy array) data = np.concatenate((sig,bg),axis=0) # concatenate the sig and bg numpy arrays into one big array flags = np.concatenate((flag_sig, flag_bg), axis=0) # concatenates the flag arrays into one array, each entry corresponding to the entry of the data array ### TRAINING ### som = SOM(dimx, dimy, 8, 400) # Train a dimx X dimy SOM with 400 iterations, 8 is the number of variables in the data array som.train(data) # trains on the dataset prepared ### THIS WILL TAKE AWHILE ### ### TO STORE THE TRAINING RESULTS INTERACTIVELY IN ipython DO: ### weightages = som._weightages ### %store weightages ### THEN TO RECOVER DO: ### %store -r ### som = SOM(dimx, dimy, 8, 400) ### som._weightages = weightages ### som._trained = True print(str(datetime.datetime.now())) # print the time to observe how long the training will take mapped = np.array(som.map_vects(data)) # map each datapoint to its nearest neuron # post training manipulations to the final dataset (one big numpy array) data = np.append(data,mapped,axis=1) # append the mapped neurons to data data = np.column_stack((data,flags)) # append the flags to the dataset
colors = np.append(
colors,
np.array([[random.random(),
random.random(),
random.random()]]),
axis=0)
#array to tensor
data = torch.Tensor(colors)
#hyper parameters
row = 40
col = 40
total_epoch = 1000
#som
som = SOM(3, (row, col))
for iter_no in range(total_epoch):
som.self_organizing(data, iter_no, total_epoch)
#get weights (map)
weight = som.weight.reshape(3, row, col).numpy()
weight = np.transpose(weight, (
1,
2,
0,
))
#plot
plt.title('Color SOM')
plt.imshow(weight)
plt.show()
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('movimento: ', r)
[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(20, 30, 3, 400)
som.train(colors)
#Get output grid
image_grid = som.get_centroids()
#Map colours to their closest neurons
#mapped = som.map_vects(colors)
#Plot
plt.imshow(image_grid)
plt.title('Color SOM')
'''
for i, m in enumerate(mapped):
plt.text(m[1], m[0], color_names[i], ha='center', va='center',
bbox=dict(facecolor='white', alpha=0.5, lw=0))
def main():
st.set_option('deprecation.showfileUploaderEncoding', False)
activities = ['Description', 'Explore Data', 'EDA', 'Model Selection']
choice = st.sidebar.selectbox('Select Activity', activities)
html_temp = """
<div style="background-color:tomato;padding:10px">
<h2 style="color:white;text-align:center;">Parkinson Disease Classification</h2>
</div>
"""
st.markdown(html_temp, unsafe_allow_html=True)
st.markdown("""<br><span>Made by </span><span style='color: #FF0000;'>Suraj Patil</span>""", unsafe_allow_html=True)
# dataset = st.file_uploader('Upload Dataset', type= 'csv')
# if dataset is not None:
dataset = pd.read_csv('pd_speech_features.csv')
if choice == 'Explore Data':
exploreData(dataset)
elif choice == 'EDA':
eda(dataset)
elif choice == 'Model Selection':
features, target = divide(dataset)
if st.sidebar.checkbox('Features Selection'):
# select = st.sidebar.radio('Select Methods', ('SelectKBest', 'Standardization'))
# if select == 'SelectKBest':
st.write('Features Selection using SelectKBest')
k = st.sidebar.slider('Set number of top features to select', min_value=5, max_value=50)
st.sidebar.write('you selected', k)
features = selectkBest(k, features, target)
if st.sidebar.checkbox('Standardization'):
# if select == 'Standardization':
st.write('Standardization')
st.write(features.shape)
features = Standardscaler(features)
st.write(features)
X_train, X_test, y_train, y_test = train_split_data(features, target)
# st.subheader('Model Building')
model = st.sidebar.selectbox('Select ML Algorithms', ['MultiLayer Perceptron', 'Support Vector Machine', 'Self Organizing Maps', 'Learning Vector Quantization'])
if model == 'MultiLayer Perceptron':
st.subheader('MultiLayer Perceptron')
st.sidebar.subheader("Model Hyperparameters")
hidden_layers = st.sidebar.slider('Hidden Layers', min_value=100, max_value=500, step=100)
max_iter = st.sidebar.slider('No. of Iterations', min_value=100, max_value=1000, step=100)
activation_func = st.sidebar.selectbox('Select Activation Function', ['identity', 'logistic', 'relu', 'tanh'])
solver = st.sidebar.selectbox('Select Solver', ['adam', 'sgd'])
if st.sidebar.button('Apply', 'mlp'):
MLP(X_train, X_test, y_train, y_test, hidden_layers, activation_func, solver, max_iter)
elif model == 'Support Vector Machine':
st.subheader('Support Vector Machine')
st.sidebar.subheader("Model Hyperparameters")
start = st.sidebar.number_input('From', min_value=1.0, max_value=1000.0, step=1.0)
end = st.sidebar.number_input('To', min_value=1.0, max_value=1000.0, step=1.0)
C = np.arange(start, end+1)
kernel = st.sidebar.multiselect('Select Kernels', ['linear', 'poly', 'rbf', 'sigmoid'])
if st.sidebar.button('Apply', 'svm'):
SVM(X_train, X_test, y_train, y_test, C, kernel)
elif model == 'Self Organizing Maps':
st.subheader('Self Organizing Maps')
st.sidebar.subheader("Model Hyperparameters")
epoch = st.sidebar.slider('Set epoch', min_value=50.0, max_value=1500.0, step=50.0)
neighbor_fun = st.sidebar.selectbox('Select Neighborhood Function', ['gaussian', 'triangle'])
if st.sidebar.button('Apply', 'som'):
SOM(X_train, X_test, y_train, y_test, k, epoch, neighbor_fun)
else:
st.subheader('Learning Vector Quantization')
epoch = st.sidebar.slider('Set epoch', min_value=50.0, max_value=1500.0, step=50.0)
learn_rate = st.sidebar.number_input('Set Learning Rate', min_value=0.1, max_value=1.1, step=0.1)
if st.sidebar.button('Apply', 'lvq'):
LVQ(X_train, X_test, y_train, y_test, epoch, learn_rate)
# else:
# st.write('Upload dataset first!!!')
else:
st.markdown(describe(), unsafe_allow_html=True)
import numpy as np import pandas as pd from som import SOM from sklearn.datasets import load_boston from sklearn.preprocessing import StandardScaler # read in data boston = load_boston().data # standard scale data ss = StandardScaler() X = ss.fit_transform(boston) # instantiate SOM som = SOM(X, 3, 3, 1, 100, 0.01) # train model tree, weights, winners, distances = som.train(X) # print data # print(weights) print(set(winners)) dist, ind = som.predict(X, tree) print(set([x[0] for x in ind]))
# generate some virtual peptide sequences
libnum = 1000 # 1000 sequences per sublibrary
h = Helices(seqnum=libnum)
r = Random(seqnum=libnum)
n = AMPngrams(seqnum=libnum, n_min=4)
h.generate_sequences()
r.generate_sequences(proba='AMP')
n.generate_sequences()
# calculate molecular descirptors for the peptides
d = PeptideDescriptor(seqs=np.hstack((h.sequences, r.sequences, n.sequences)), scalename='pepcats')
d.calculate_crosscorr(window=7)
# train a som on the descriptors and print / plot the training error
som = SOM(x=12, y=12)
som.fit(data=d.descriptor, epochs=100000, decay='hill')
print("Fit error: %.4f" % som.error)
som.plot_error_history(filename="som_error.png")
# load known antimicrobial peptides (AMPs) and transmembrane sequences
dataset = load_AMPvsTM()
d2 = PeptideDescriptor(dataset.sequences, 'pepcats')
d2.calculate_crosscorr(7)
targets = np.array(libnum*[0] + libnum*[1] + libnum*[2] + 206*[3])
names = ['Helices', 'Random', 'nGrams', 'AMP']
# plot som maps with location of AMPs
som.plot_point_map(np.vstack((d.descriptor, d2.descriptor[206:])), targets, names, filename="peptidesom.png")
som.plot_density_map(np.vstack((d.descriptor, d2.descriptor)), filename="density.png")
som.plot_distance_map(colormap='Reds', filename="distances.png")
import numpy as np
from som import SOM
# 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, 2000) # fit the SOM for 2000 epochs
targets = 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 1', 'class 2'], filename='som.png')
som.plot_class_density(data,
targets,
1, ['class 1', 'class 2'],
filename='class_0.png')
# For plotting the images
from __future__ import absolute_import
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()
data0 = json.load(f)
f.close()
f = open('appdata.json', 'r')
applist = json.load(f)
applist = applist['applist']['apps']
f.close()
f = open('tagDATA2.json', 'r')
tag = json.load(f)
f.close()
data2 = []
for i in data0:
data2.append(data0[i]['gameplay'])
data = np.array(data2)
# Train a 20x30 SOM with 400 iterations
som = SOM(5, 2, 10, 100) # My parameters
som.train(data)
cnn0 = load_model('model0.h5')
cnn1 = load_model('model1.h5')
cnn2 = load_model('model2.h5')
cnn3 = load_model('model3.h5')
cnn4 = load_model('model4.h5')
cnn5 = load_model('model5.h5')
cnn6 = load_model('model6.h5')
cnn7 = load_model('model7.h5')
cnn8 = load_model('model8.h5')
cnn9 = load_model('model9.h5')
def gameRecommendation(id):
id = str(id)
def __init__(self,
act=None,
pool=None,
with_memory=True,
summ=None,
residual=True,
log=False,
name="model"):
super(Model, self).__init__(name=name)
self._with_memory = with_memory
self._summ = summ
self._residual = residual
self._num_blocks = 6
self._log = log
with self._enter_variable_scope():
self._act = Activation(act, verbose=True)
self._pool = Pooling(pool, padding='VALID', verbose=True)
if self._residual:
self._convs = [
snt.Conv2D(eval("FLAGS.num_outputs_block_%d" % (i + 1)),
FLAGS.filter_size,
padding=snt.VALID,
use_bias=False) for i in range(self._num_blocks)
]
self._sepconvs = [
snt.SeparableConv2D(
eval("FLAGS.num_outputs_block_%d" % (i + 1)),
1,
FLAGS.filter_size,
padding=snt.SAME,
use_bias=False) for i in range(self._num_blocks)
]
else:
self._sepconvs = [
snt.SeparableConv2D(
eval("FLAGS.num_outputs_block_%d" % (i + 1)),
1,
FLAGS.filter_size,
padding=snt.VALID,
use_bias=False) for i in range(self._num_blocks)
]
self._seq = snt.Sequential([
snt.Linear(output_size=FLAGS.num_outputs_dense), tf.nn.relu,
snt.Linear(output_size=FLAGS.num_classes)
])
if self._with_memory:
print("Model with memory enabled")
config = \
{
"height": FLAGS.memory_height,
"width": FLAGS.memory_width,
"input_size": 32, # very dangeous, hard-coded
"num_iters": FLAGS.num_iterations,
"learning_rate": FLAGS.lr_som
}
self._som = SOM(**config)
drop_last=False,# 不同fold测试数据不完全一样了，没关系但是不用model还是用了同样数据
worker_init_fn=worker_init_fn)#if worker_init_fn=None, it use the torch.initial seed()
test=[]
test_lab=[]
test_lab_list=[]
for b in test_dataloader:
test.extend(b['mol_fp'])
test_lab_list.extend(b['labels'])#todo considring multi_lab in feature
for b in test_lab_list:
test_lab.extend(b)
#print(f'len(test)={len(test)},test[0]={len(test[1])},{test[1]}')
#print(f'len(test_lab)={len(test_lab)},test[0]={len(test_lab[1])},{test_lab[1]}')
#todo add train func,predict func,合并 nepy sofm and here
input_dim=args.input_dim
som = SOM(input_size=input_dim, out_size=args.map)
som = som.to(device)
if train == True:
losses = list()
for epoch in tqdm(range(total_epoch)):
running_loss = 0
start_time = time.time()
for idx, b in enumerate(train_dataloader):
X=torch.FloatTensor(b['mol_fp'])
#print(f'X.size{X.size()}')
X = X.view(-1, input_dim).to(device) # flatten
loss = som.self_organizing(X, epoch, total_epoch) # train som
running_loss += loss
losses.append(running_loss)
print('epoch = %d, loss = %.2f, time = %.2fs' % (epoch + 1, running_loss, time.time() - start_time))
if epoch % 100 == 0:
rbmfile.write('{};{};{}\n'.format(
counter,
rbm.labels[counter],
value))
counter += 1
print('Saved as rbm_{}epochs_{}hidden_{}.csv\n'.format(
args.rbmepochs,
args.rbmhiddenneurons,
filename))
elif args.method in ('som', 'all'):
from som import SOM
som = SOM(filename,
pathname,
args.somepochs,
args.somgrid,
args.somgrid,
args.delimiter)
print('----------')
print('SOM results on data set {}:'.format(filename))
print('----------')
print('Number of dimensions: {}'.format(som.dimensions_count))
print('Number of data objects: {}'.format(som.objects_count))
print('Number of outliers: {}'.format(som.outlier_count))
print('----------')
print('ROC AUC: {}'.format(som.roc_auc))
print('PR AUC: {}'.format(som.pr_auc))
print('F1 Score: {}'.format(som.f1_score))
print('----------\n')
if save_rankings:
inputFilename = 'myo_raw_data.csv'
header = '% qx, qy, qz, qw, ax, ay, az, gx, gy, gz\n'
try:
f = open(inputFilename, 'r')
except Exception as error:
print("ERROR: Couldn't read from {}".format(inputFilename))
else:
with f:
reader = csv.reader(f)
for row in reader:
if row[0][0] is not '%':
myo_data.append(row)
print myo_data[0]
#Training inputs for Myo data (quat, accel, gyro)
som_data = np.array(myo_data)
#Train a 20x30 SOM with 400 iterations
som = SOM(SOM_X, SOM_Y, MYO_DATA_DIM, SOM_ITER)
som.train(som_data)
#Get output grid
image_grid = som.get_centroids()
#Plot
plt.imshow(image_grid)
plt.title('Myo SOM')
plt.show()
for col in range(1, num_cols):
col_values.append(input_sheet.col_values(col)[1:])
x = np.array(col_values, dtype='|S4')
y = x.astype(np.float)
maxs = [max(y[col]) for col in range(0, num_cols - 1)]
mins = [min(y[col]) for col in range(0, num_cols - 1)]
data_points = []
for row in range(1, num_rows):
values = []
for col in range(1, num_cols):
values.append(
(float(input_sheet.cell(row, col).value) - mins[col - 1]) /
(maxs[col - 1] - mins[col - 1]))
d = DataPoint(values, int(output_sheet.cell(row, 0).value))
data_points.append(d)
print(num_rows - 1, " points with dimesion=", num_cols - 1, " are added")
return data_points
data_points = load_data("722.xlsx")
s = SOM(2, 8, 27)
s.load_input_data(data_points)
s.fit(2, 0.1)
v = LVQ(2, 6, 5)
v.load_data(data_points)
v.train(5, 0.01, 2)
s.predict(data_points)
v.predict(data_points)
r.next() # skip header
data = []
# parse data
for row in r:
l = []
n = row[0]
v = map(float, row[1:])
v = map(lambda x: x / max(v), v)
l.append(n)
for x in v:
l.append(x)
data.append(l)
# create SOM & train
s = SOM()
results = s.train(data)
# restart if only one node (growth threshold not triggered)
while len(results) == 1:
print 'Only one node, restarting...'
s = SOM()
results = s.train(data)
print """
Parameters summary:
Epochs: {epochs}
Cluster Threshold: >={threshold}
Radius: {radius}
Radius Decay Rate: {radius_decay}
Rate: {rate}
projection = {
'_id': False,
'title': True,
'runtime': True,
'metacritic': True,
'tomato.rating': True,
'year': True,
'awards.wins': True
}
brute_data = conn.find_docs(collec='movieDetails', f=filtro, p=projection)
print("...Recuperados datos en bruto...")
# Limpia y estandariza la data
clean_data = cleaner(brute_data)
data = [list(map(standarize, lst)) for lst in clean_data]
print("...Creando una SOM...")
topo = len(data[0])
red = SOM(100, 100, topo)
print("...Entrenando la red...")
red.train(clean_data, L0=0.8, lam=1e2, sigma0=10)
print("...Construyendo gráfico en 2D...")
for p in red.som:
build_JSON_coor(p, 'son_map')
print("...Calculando el error de cálculo...")
print(red.quant_err())
from som import SOM
from hcsr04 import HCSR04
from servo_motor import Servo
from rodas import Rodas
import time
rodas = Rodas()
sf = Servo(14)
som = SOM()
sensorD = HCSR04(trigger_pin=12, echo_pin=13)
amostra = [0,0,0]
# Ângulos de posições: direita, frontal e esquerda
angles = [10,90,170]
for i in range(10):
contI = 2
for a in angles:
sf.setAngle(a)
time.sleep_ms(500)
d = sensorD.distance_cm()
if d > 70:
d = 70
amostra[contI] = d
time.sleep_ms(10)
contI -= 1
print('Amostra:', amostra)
acao = som.melhorReposta(amostra)
from som import SOM
import pandas as pd
import numpy as np
input_data = pd.read_csv("C:/Users/KHT/Desktop/hw2out.csv")
som_net = SOM(10, 10, 2)
coor_data = input_data.iloc[np.random.permutation(len(input_data))]
trunc_data = coor_data[["x", "y"]]
print(trunc_data.values)
# print(trunc_data.values.shape[0])
som_net.train(trunc_data.values, num_epochs=1000, init_learning_rate=0.1)
"""
def predict(df):
bmu, bmu_idx = som_net.find_bmu(df.values)
df['bmu'] = bmu
df['bmu_idx'] = bmu_idx
return df
clustered_df = trunc_data.apply(predict, axis=1)
result_array = clustered_df.to_records().tolist()
print("ID number {0}".format(result_array[0][0]))
print("X Coordinate on topological map {0}".format(result_array[0][4][0]))
print("Y Coordinate on topological map {0}".format(result_array[0][4][1]))
"""
