def run(self):
self.emit(QtCore.SIGNAL("update()"))
self.mfcc.frame_size = int(self.par.frameSizeVal.currentText())
self.mfcc.overlap = self.mfcc.frame_size / 2
speaker_correct = 0
speaker_word_correct = 0
for index, file_audio in enumerate(self.audio_files):
file_audio = str(file_audio)
self.audio_signal, self.audio_fs = FileReader.read_audio(
file_audio)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(
file_audio)
self.num_frames, self.framed_signal = self.mfcc.frame_blocking(
self.silenced_signal)
self.windowed_signal = self.mfcc.hamm_window(self.framed_signal)
self.fft_signal = self.mfcc.calc_fft(self.windowed_signal)
self.log_energy, self.fbank = self.mfcc.fbank(
self.fft_signal, self.audio_fs)
self.features = self.mfcc.features(self.log_energy)
self.lvq = LVQ(str(self.par.databaseSelect.currentText()))
# result = self.lvq.test_data(self.features[:, 1:14])
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19]
result = self.lvq.test_data(
self.features[:, [1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]])
print "vote for file " + str(index) + " : " + str(result)
# full = str(result[1][0]) if len(result) >= 2 else str(result[0][0])
full = str(result[0][0])
speaker = full[:full.rfind('-')] if full.rfind('-') != -1 else full
word = full[full.rfind('-') + 1:] if full.rfind('-') != -1 else "-"
self.par.featuresTbl.setItem(index, 2,
QtGui.QTableWidgetItem(speaker))
self.par.featuresTbl.setItem(index, 3,
QtGui.QTableWidgetItem(word))
if speaker == self.par.featuresTbl.item(index, 0).text():
speaker_correct += 1
if speaker == self.par.featuresTbl.item(
index, 0).text() and word == self.par.featuresTbl.item(
index, 1).text():
speaker_word_correct += 1
self.par.speaker_word_acc = (speaker_word_correct /
float(len(self.audio_files))) * 100
self.par.speaker_only_acc = (speaker_correct /
float(len(self.audio_files))) * 100
self.emit(QtCore.SIGNAL("update()"))
self.emit(QtCore.SIGNAL("finish()"))
def identify_speaker(self):
self.lvq = LVQ(str(self.databaseSelect.currentText()))
# result = self.lvq.test_data(self.features[:, 1:14])
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19]
result = self.lvq.test_data(self.features[:,[1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]])
print "vote : "+str(result)
if result[0][0].find('-') != -1:
self.speakerVal.setText(": "+str(result[0][0][:result[0][0].find('-')]))
self.wordVal.setText(": "+str(result[0][0][result[0][0].find('-')+1:]))
else:
self.speakerVal.setText(": " + str(result[0][0]))
self.wordVal.setVisible(False)
self.wordLbl.setVisible(False)
class TestingThread(QtCore.QThread):
def __init__(self, parent, audio_files):
QtCore.QThread.__init__(self, parent)
self.audio_files = audio_files
self.mfcc = MFCC()
self.par = parent
def run(self):
self.emit(QtCore.SIGNAL("update()"))
self.mfcc.frame_size = int(self.par.frameSizeVal.currentText())
self.mfcc.overlap = self.mfcc.frame_size/2
speaker_correct = 0
speaker_word_correct = 0
for index,file_audio in enumerate(self.audio_files):
file_audio = str(file_audio)
self.audio_signal, self.audio_fs = FileReader.read_audio(file_audio)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(file_audio)
self.num_frames, self.framed_signal = self.mfcc.frame_blocking(self.silenced_signal)
self.windowed_signal = self.mfcc.hamm_window(self.framed_signal)
self.fft_signal = self.mfcc.calc_fft(self.windowed_signal)
self.log_energy, self.fbank = self.mfcc.fbank(self.fft_signal, self.audio_fs)
self.features = self.mfcc.features(self.log_energy)
self.lvq = LVQ(str(self.par.databaseSelect.currentText()))
# result = self.lvq.test_data(self.features[:, 1:14])
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19]
result = self.lvq.test_data(self.features[:, [1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]])
print "vote for file " + str(index) + " : " + str(result)
# full = str(result[1][0]) if len(result) >= 2 else str(result[0][0])
full = str(result[0][0])
speaker = full[:full.rfind('-')] if full.rfind('-') != -1 else full
word = full[full.rfind('-')+1:] if full.rfind('-') != -1 else "-"
self.par.featuresTbl.setItem(index, 2, QtGui.QTableWidgetItem(speaker))
self.par.featuresTbl.setItem(index, 3, QtGui.QTableWidgetItem(word))
if speaker == self.par.featuresTbl.item(index,0).text():
speaker_correct += 1
if speaker == self.par.featuresTbl.item(index,0).text() and word == self.par.featuresTbl.item(index,1).text():
speaker_word_correct += 1
self.par.speaker_word_acc = (speaker_word_correct / float(len(self.audio_files))) * 100
self.par.speaker_only_acc = (speaker_correct / float(len(self.audio_files))) * 100
self.emit(QtCore.SIGNAL("update()"))
self.emit(QtCore.SIGNAL("finish()"))
def train_data(self):
self.lvq = LVQ(str(self.databaseSelect.currentText()))
self.trainDataBtn.setDisabled(True)
self.iterVal.setDisabled(True)
self.learningRDecrVal.setDisabled(True)
self.learningRVal.setDisabled(True)
self.minAlpha.setDisabled(True)
self.n = 0
#self.trainProgress.setRange(0,0)
trainingThread = LVQTrainThread(self, self.lvq, self.iterVal,
self.learningRVal,
self.learningRDecrVal, self.minAlpha,
str(self.databaseSelect.currentText()))
trainingThread.start()
trainingThread.taskFinished.connect(self.finish_training)
QtCore.QObject.connect(trainingThread, QtCore.SIGNAL("update()"),
self.update_progress)
return (factors[0], factors[0])
return find_middle(factors)
# seed(1)
learn_rate = 0.3
n_epochs = 300
n_codebooks = 9
print("learning rate: " + str(learn_rate))
print("epoch: " + str(n_epochs))
print("class: " + str(n_codebooks))
print()
train_beats = LVQ()
train_beats.set_n_codebooks(n_codebooks)
# load and prepare data train
filename = 'train_three.csv'
train_beats.load_csv(filename, 'train')
for i in range(len(train_beats.data_train[0]) - 1):
if i != 5:
train_beats.min_max_normalize(train_beats.data_train, i, 0, 50)
else:
train_beats.min_max_normalize(train_beats.data_train, i, 0, 30)
# load and prepare data test
filename = 'test_three.csv'
train_beats.load_csv(filename, 'test')
for i in range(len(train_beats.data_test[0]) - 1):
if number % i == 0:
factors.append(i)
i += 1
count += 1
if count == 0:
return (num, 1)
return findMiddle(factors)
seed(1)
learn_rate = 0.01
n_epochs = 400
n_codebooks = 3
train_beats = LVQ()
train_beats.set_n_codebooks(n_codebooks)
# load and prepare data
filename = 'train_beats.csv'
train_beats.load_csv(filename, 'train')
train_beats.train_codebooks(learn_rate, n_epochs)
for c in train_beats.codebooks:
print(c[-1])
score, wrong_data = train_beats.accuracy_metric('train')
print(score)
print(wrong_data)
class TestingWindow(QtGui.QMainWindow, testingWindow.Ui_TestWdw):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
self.mfcc = MFCC()
self.player = audioPlayer.AudioPlayer(self.volumeSlider,
self.seekSlider,
self.lcdNumber,
self.audioPlayBtn,
self.audioPauseBtn,
self.audioStopBtn)
self.init_ui()
self.init_databases()
self.canvas = None
self.actionTest_Data.setDisabled(True)
self.actionExit.triggered.connect(self.close)
self.actionTraining_Data.triggered.connect(self.open_train_wdw)
self.actionBatch_Testing.triggered.connect(self.open_batch_wdw)
self.actionAbout_Qt.triggered.connect(QtGui.qApp.aboutQt)
self.actionAbout.triggered.connect(self.about)
self.openAudioBtn.clicked.connect(self.show_open_dialog)
self.extractSaveBtn.clicked.connect(self.extract_features)
self.identifyBtn.clicked.connect(self.identify_speaker)
def init_ui(self):
palette = QtGui.QPalette()
palette.setBrush(QtGui.QPalette.Light, QtCore.Qt.darkGray)
self.audioPlayBtn.setDisabled(True)
self.audioPauseBtn.setDisabled(True)
self.audioStopBtn.setDisabled(True)
self.extractSaveBtn.setDisabled(True)
self.lcdNumber.display("00:00")
self.lcdNumber.setPalette(palette)
def init_databases(self):
self.database_list = [f[:len(f) - 3] for f in listdir('database/') if isfile(join('database/', f))]
self.databaseSelect.addItems(QtCore.QStringList(self.database_list))
def open_batch_wdw(self):
self.batch_wdw = batch_test.BatchTestWindow()
self.batch_wdw.show()
def identify_speaker(self):
self.lvq = LVQ(str(self.databaseSelect.currentText()))
# result = self.lvq.test_data(self.features[:, 1:14])
# [31, 28, 29, 30, 27, 26, 25, 24, 23, 22, 20, 21, 19]
result = self.lvq.test_data(self.features[:,[1, 2, 3, 4, 5, 7, 6, 9, 8, 10, 11, 12, 13]])
print "vote : "+str(result)
if result[0][0].find('-') != -1:
self.speakerVal.setText(": "+str(result[0][0][:result[0][0].find('-')]))
self.wordVal.setText(": "+str(result[0][0][result[0][0].find('-')+1:]))
else:
self.speakerVal.setText(": " + str(result[0][0]))
self.wordVal.setVisible(False)
self.wordLbl.setVisible(False)
def extract_features(self):
self.mfcc.frame_size = int(self.frameSizeVal.currentText())
self.mfcc.overlap = self.mfcc.frame_size/2
# frame blocking
self.num_frames, self.framed_signal = self.mfcc.frame_blocking(self.silenced_signal)
fig = Figure()
self.framedSignalPlot = fig.add_subplot(111)
self.framedSignalPlot.plot(self.framed_signal.ravel(1))
self.add_figure(fig, self.framedPlotLyt)
# windowing
self.windowed_signal = self.mfcc.hamm_window(self.framed_signal)
fig = Figure()
self.windowedSignalPlot = fig.add_subplot(111)
self.windowedSignalPlot.plot(self.windowed_signal.ravel(1))
self.add_figure(fig, self.windowedPlotLyt)
# hitung FFT
self.fft_signal = self.mfcc.calc_fft(self.windowed_signal)
fig = Figure()
self.fftSignalPlot = fig.add_subplot(111)
self.fftSignalPlot.plot(self.fft_signal[:, :self.mfcc.frame_size/2].ravel(1))
self.add_figure(fig, self.fftPloyLyt)
# hitung filter bank
self.log_energy, self.fbank = self.mfcc.fbank(self.fft_signal, self.audio_fs)
fig = Figure()
self.melwrapPlot = fig.add_subplot(111)
for i in xrange(self.mfcc.num_filter):
self.melwrapPlot.plot(self.fbank[i, :])
self.add_figure(fig, self.melPlotLyt)
# features
self.features = self.mfcc.features(self.log_energy)
fig = Figure()
self.mfccPlot = fig.add_subplot(111)
for i in xrange(self.features.shape[0]):
self.mfccPlot.plot(self.features[i, :])
self.add_figure(fig, self.mfccPlotLyt)
# write features to table
self.testDataTab.setCurrentIndex(len(self.testDataTab)-1)
self.featuresTbl.setRowCount(self.features.shape[0])
for i in xrange(self.features.shape[0]):
for j in xrange(1,14):
isi_feature = QtGui.QTableWidgetItem(str(self.features[i,j]))
# print "i: "+str(i)+" j: "+str(j)+" isi: "+str(isi_feature)
self.featuresTbl.setItem(i,j-1,isi_feature)
def add_figure(self, fig, container):
# if self.canvas is not None:
# container.removeWidget(self.canvas)
self.clearLayout(container)
self.canvas = FigureCanvas(fig)
container.addWidget(self.canvas)
self.canvas.draw()
def open_train_wdw(self):
self.hide()
self.mainWdw = twc.MainWindow()
self.mainWdw.show()
def show_open_dialog(self):
self.audioFile = QtGui.QFileDialog.getOpenFileName(self, 'Open audio file',
'',
"Audio Files (*.wav)",
None, QtGui.QFileDialog.DontUseNativeDialog)
if self.audioFile != "":
fileName = str(self.audioFile)
self.audio_signal, self.audio_fs = FileReader.read_audio(fileName)
self.silenced_signal, self.audio_fs = self.mfcc.remove_silence(fileName)
self.fsValLbl.setText(": " + str(self.audio_fs) + " Hz")
self.sampleValLbl.setText(
": " + str(len(self.audio_signal)) + " | " + str(len(self.silenced_signal)) + " (silenced)")
self.audioFilenameLbl.setText(": " + fileName[fileName.rfind('/') + 1:len(fileName)])
self.audioPlayBtn.setDisabled(False)
self.clear_all_layout()
fig = Figure()
self.origSignalPlot = fig.add_subplot(111)
self.origSignalPlot.plot(self.audio_signal)
self.add_figure(fig, self.originalPlotLyt)
self.extractSaveBtn.setDisabled(False)
self.player.set_audio_source(self.audioFile)
self.testDataTab.setCurrentIndex(0)
def about(self):
QtGui.QMessageBox.information(self, "Text Dependent Speaker Verification",
"Text Dependent Speaker Verification - the "
"Final project software to identify and verify Speaker based on their speech.\n\n"
"\xa9 Sukoreno Mukti - 1112051 \n Informatics Engineering Dept. ITHB")
def clear_all_layout(self):
[self.clearLayout(layout) for layout in
[self.fftPloyLyt, self.framedPlotLyt, self.melPlotLyt, self.mfccPlotLyt, self.originalPlotLyt,
self.windowedPlotLyt]]
def clearLayout(self, layout):
while layout.count():
child = layout.takeAt(0)
if child.widget() is not None:
child.widget().deleteLater()
elif child.layout() is not None:
self.clearLayout(child.layout())
def closeEvent(self, event):
reply = QtGui.QMessageBox.question(self, 'Message',
"Are you sure to quit?", QtGui.QMessageBox.Yes |
QtGui.QMessageBox.No, QtGui.QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
event.accept()
else:
event.ignore()
def k_fold(self, k):
"""Calcula a acurácia sobre os erros encontrados em k iterações.
O método de validação cruzada denominado k-fold consiste em dividir o
conjunto total de dados em k subconjuntos mutuamente exclusivos do
mesmo tamanho e, a partir disto, um subconjunto é utilizado para teste
e os k-1 restantes são utilizados para estimação dos parâmetros e
calcula-se a acurácia do modelo.
Atributos:
fold (dict): Variável de chave-valor que armazena as k divisões do
arquivo. Onde chave é o número da divisão, que vai de 1 à k, e
o valor é uma matriz (i por j), o i são as linhas do arquivo e
j é as colunas.
line_qtty (int): Calcula a quantidade total de linhas no arquivo.
hits (dict): Estrutura de dados chave-valor usado para calcular a
quantidade de acertos em cada uma k rodadas.
test_fold (list): Armazena o conjunto de dados, 1/k, usado para a
rodada de teste da vez.
trainning (list): ...
Args:
k (int): Quantidade de sublistas a ser dividido.
No Longer Returned:
"""
self.fold = {}
line_qtty = sum(1 for row in self.data_set)
# print(row_qtty) # colocando com parentesis pra mantes a compatibilidade com outras versoes do python
aux = 1
for index in range(0, line_qtty):
if aux == k + 1:
aux = 1
if str(aux) not in self.fold:
self.fold[str(aux)] = []
self.fold[str(aux)].append(self.data_set[index])
aux += 1
aux = 0
hits = {}
test_fold = None
erro_amostral = []
for index in range(1, 11):
test_fold = self.fold[str(index)]
trainning = []
file_lenght = 0
self.classes = []
for key, sublist in self.fold.iteritems():
if int(key) == index:
continue
else:
for line in sublist:
trainning.append(line)
file_lenght += 1
if line[self.metric_column] not in self.classes:
self.classes.append(line[self.metric_column])
if self.method == 'kNN':
knn_obj = KNN(
self.__get_neighbour_qtd(self.iter_count, file_lenght),
trainning)
elif self.method == 'LVQ':
lvq_obj = LVQ(trainning, self.file_obj.get('classes_qtd'), 1,
self.file_obj.get('attr_qtd'),
self.file_obj.get('skippable') or [],
self.file_obj.get('metric') or -1)
matrix = lvq_obj.train()
for jndex, test in enumerate(test_fold):
if self.method == 'kNN':
knn_obj.find_knn(test,
metric=self.metric_column,
skippable_indexes=self.skippable_indexes)
test_predict = knn_obj.get_prediction()
elif self.method == 'LVQ':
help_obj = KNN(1, matrix)
help_obj.find_knn(test,
metric=self.metric_column,
skippable_indexes=self.skippable_indexes)
test_predict = help_obj.get_prediction()
if str(index) not in hits:
length = len(self.classes)
hits[str(index)] = [[0 for x in range(length)]
for y in range(length)]
else:
predicted_class = self.get_class_int_value(
test_predict['class'])
real_class = self.get_class_int_value(
float(test_fold[jndex][self.metric_column]))
hits[str(index)][real_class][predicted_class] += 1
aux += 1
qtty_test = len(test_fold)
qtty_correct = 0
for i in range(
len(self.classes)
): # sempre a matriz vai ter self.classes x self.classes
# os acertos sao sempre os valores onde os indices da matriz sao iguais
qtty_correct += hits[str(index)][i][i]
# Erro amostral = qnt de erros / pela qnt de instancias de teste
erro_amostral.append(
(qtty_test - qtty_correct) / round(qtty_test, 5))
print(hits)
self.matrix = hits
return erro_amostral # array de erro amostral por fold
import numpy as np
from lvq import LVQ
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from neuralnet import Neural
from layer import Layer
df = pd.read_csv("iris.csv")
mms = MinMaxScaler()
df['species'] = df['species'].map({'setosa':0,'versicolor':1,'virginica':2})
m = LVQ(n_class=3,input_shape=4,distance='euclidean')
X = mms.fit_transform(df.iloc[:, :4].values)
y = df.iloc[:,-1].values
#TTS
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25,random_state=42)
nn = Neural(3)
nn.add_layer(Layer(4,5,'relu'))
nn.add_layer(Layer(5,3,'sigmoid'))
angka = [[4,5,6,7],[10,20,30,40],[12,76,34,23],[5,5,5,8]]
angka = np.array(angka)
print(angka.shape)
print(nn.predict(angka))
nn.fit(X_train,y_train,epochs=90,learn_rate=0.1,eval_set=(X_test,y_test))
#nn.fit(X_train,y_train,epochs=2,learn_rate=100,eval_set=(X_test,y_test))
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)
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)
def train_beats(**kwargs):
# ============================================================= #
# ======================== TRAINING BEATS ===================== #
# ============================================================= #
extraction = kwargs.get('extraction', 'pixel')
max_normalize = kwargs.get('max_normalize', 255)
learn_rate = kwargs.get('learning_rate', 0.05)
n_epochs = kwargs.get('max_epoch', 100)
n_codebooks = kwargs.get('n_codebooks', 3)
print("learning rate: " + str(learn_rate))
print("epoch: " + str(n_epochs))
print("class: " + str(n_codebooks))
print()
train_beats = LVQ()
train_beats.set_n_codebooks(n_codebooks)
# load and prepare data train
filename = 'train_beats.csv'
train_beats.load_csv(filename, 'train')
if extraction == 'pixel':
for i in range(len(train_beats.data_train[0]) - 1):
train_beats.min_max_normalize(train_beats.data_train, i, 0, 255)
else:
for i in range(len(train_beats.data_train[0]) - 1):
train_beats.min_max_normalize(train_beats.data_train, i, 0, 50)
# Training process
start_time = time.time()
train_beats.train_codebooks(learn_rate, n_epochs)
duration = time.time() - start_time
print("\nclass codebooks: ", end="")
print([row[-1] for row in train_beats.codebooks])
score, wrong_data, actual, predictions = train_beats.accuracy_metric(
'train')
print("===============train beats==============")
print("Waktu proses pembelajaran: %s detik ---" % (duration))
print("score: " + str(round(score, 3)) + "%\n")
print("wrong data: ", end="")
print(wrong_data)
train_beats.export_codebooks("beats_codebooks")
beats, beats_test, dataset_path = create_dataset.group_data_beats()
# Show wrong data image
# helper.show_wrong_data(wrong_data, predictions, beats, dataset_path)
# exit()
return score, duration
def train_pitch(**kwargs):
# ============================================================= #
# ======================== TRAINING PITCH ===================== #
# ============================================================= #
identifier = kwargs.get('identifier', 'quarter')
extraction = kwargs.get('extraction', 'paranada')
max_normalize = kwargs.get('max_normalize', 255)
learn_rate = kwargs.get('learning_rate', 0.05)
n_epochs = kwargs.get('max_epoch', 100)
n_codebooks = kwargs.get('n_codebooks', 9)
show_wrong_data = kwargs.get('show_wrong_data', False)
print("learning rate: " + str(learn_rate))
print("epoch: " + str(n_epochs))
print("class: " + str(n_codebooks))
print()
train_pitch = LVQ()
train_pitch.set_n_codebooks(n_codebooks)
# load and prepare data train
filename = 'train_' + identifier + '.csv'
train_pitch.load_csv(filename, 'train')
if extraction == 'paranada':
for i in range(len(train_pitch.data_train[0]) - 1):
if i != 5: # difference normalization for average value
train_pitch.min_max_normalize(train_pitch.data_train, i, 0, 50)
else:
train_pitch.min_max_normalize(train_pitch.data_train, i, 0, 30)
elif extraction == 'pixel':
for i in range(len(train_pitch.data_train[0]) - 1):
train_pitch.min_max_normalize(train_pitch.data_train, i, 0, 255)
else:
for i in range(len(train_pitch.data_train[0]) - 1):
train_pitch.min_max_normalize(train_pitch.data_train, i, 0, 30)
# load and prepare data test
# filename = 'test_whole.csv'
# train_pitch.load_csv(filename, 'test')
# for i in range(len(train_pitch.data_test[0])-1):
# if i != 5:
# train_pitch.min_max_normalize(train_pitch.data_test, i, 0, 50)
# else:
# train_pitch.min_max_normalize(train_pitch.data_test, i, 0, 30)
# Training process
start_time = time.time()
train_pitch.train_codebooks(learn_rate, n_epochs)
duration = time.time() - start_time
print("class codebooks: ", end="")
print([row[-1] for row in train_pitch.codebooks])
score, wrong_data, actual, predictions = train_pitch.accuracy_metric(
'train')
# score_test, wrong_data_test, actual_test, predictions_test = train_pitch.accuracy_metric('test')
print("===============train " + identifier + "==============")
print("score: " + str(round(score, 3)) + "%")
print("\n")
print("wrong data: ", end="")
print(wrong_data)
# print("\n===============test===============")
# print("score test: " + str(round(score_test, 3)) + "%")
# print("\n")
# print("wrong data test: ", end="")
# print(wrong_data_test)
train_pitch.export_codebooks(identifier + "_codebooks")
pitch, pitch_test, dataset_path = helper.get_dataset_info(
identifier, "train")
# print(pitch)
# print()
# print(pitch_test)
# print()
# print(dataset_path)
# exit()
# Show wrong data train image
if show_wrong_data:
helper.show_wrong_data(wrong_data, predictions, pitch, dataset_path)
# exit()
# Show wrong data test image
# helper.show_wrong_data(wrong_data_test, predictions_test, whole_test, dataset_path)
# exit()
return score, duration
type='train')
# ============================================================= #
# ======================== TRAINING WHOLE ===================== #
# ============================================================= #
learn_rate = 0.05
n_epochs = 2000
n_codebooks = 9
print("learning rate: " + str(learn_rate))
print("epoch: " + str(n_epochs))
print("class: " + str(n_codebooks))
print()
train_whole = LVQ()
train_whole.set_n_codebooks(n_codebooks)
# load and prepare data train
filename = 'train_whole.csv'
train_whole.load_csv(filename, 'train')
for i in range(len(train_whole.data_train[0]) - 1):
if i != 5: # difference normalization for average value
train_whole.min_max_normalize(train_whole.data_train, i, 0, 50)
else:
train_whole.min_max_normalize(train_whole.data_train, i, 0, 30)
# load and prepare data test
# filename = 'test_whole.csv'
# train_whole.load_csv(filename, 'test')
# for i in range(len(train_whole.data_test[0])-1):
from flask import Flask,jsonify,request
from flask_cors import CORS
from lvq import LVQ
from neuralnet import Neural
from layer import Layer
import numpy as np
import json
app = Flask(__name__)
CORS(app)
pcp = Neural(4)
L = Layer(81,4,'sigmoid')
pcp.add_layer(L)
lvq = LVQ(n_class=4,input_shape=81,distance='euclidean')
mlp = Neural(4)
mlp.add_layer(Layer(81,20,'relu'))
mlp.add_layer(Layer(20,10,'relu'))
mlp.add_layer(Layer(10,4,'sigmoid'))
@app.route('/')
def root():
print("GET")
return jsonify({'hello': 'world'})
@app.route("/train",methods=["POST"])
def train():
print("POST")
content = request.json
data = np.array(content['data'])
label = np.array(content['label'])
import threading
import itertools
import create_dataset
import helper
from lvq import LVQ
# ==========
# TEST BEATS
# ==========
create_dataset.create_csv_test(max_num_class=0, length_area=7)
learning_rate = 0.05
max_epoh = 150
n_codebooks = 3
test_beats = LVQ()
test_beats.set_n_codebooks(n_codebooks)
# load and prepare data test
filename = 'beats_codebooks.csv'
test_beats.import_codebooks(filename)
test_beats.load_csv("test_histogram.csv", "test")
print([item[-1] for item in test_beats.codebooks])
# for i in range(len(test_beats.data_test[0])-1):
# test_beats.min_max_normalize(test_beats.data_test, i, 0, 255)
score_beats, wrong_data_beats, actual_beats, predictions_beats = test_beats.accuracy_metric(
'test')
# ==========