def train(path="data"):
audio_data, audio_label = wavelet_data(path)
X = np.float32(audio_data)
print('shape X:', str(X.shape))
Y = audio_label
print('shape Y: ', str(len(Y)))
# Encode class target ke integer
# encoder = LabelEncoder()
# encoder.fit(img_label)
# Y = encoder.transform(img_label)
# print('shape Y:', str(Y.shape))
X_train, X_test, Y_train, Y_test = train_test_split(
X, Y, test_size=0.2) #untuk spilt data latih n uji
print('X_train shape: ', X_train.shape)
print('X_test shape', X_test.shape)
pnn = PNN(std=2, verbose=False)
pnn.train(X_train, Y_train)
with open('pnn-model.dill', 'wb') as f:
dill.dump(pnn, f)
result = pnn.predict(X_test)
n_predicted_correctly = np.sum(result == Y_test)
n_test_samples = X_test.shape[0]
print("Guessed {} out of {}".format(n_predicted_correctly, n_test_samples))
print("Processiing time : %s seconds" % (time.time() - start_time))
def test_handle_errors(self):
with self.assertRaises(ValueError):
# Wrong: size of target data not the same as size of
# input data.
PNN().train(np.array([[0], [0]]), np.array([0]))
with self.assertRaises(ValueError):
# Wrong: 2-D target vector (must be 1-D)
PNN().train(np.array([[0], [0]]), np.array([[0]]))
with self.assertRaises(AttributeError):
# Wrong: can't use iterative learning process for this
# algorithm
PNN().train_epoch()
with self.assertRaises(ValueError):
# Wrong: invalid feature size for prediction data
grnet = PNN()
grnet.train(np.array([[0], [0]]), np.array([0]))
grnet.predict(np.array([[0]]))
def neuron(self, p_class, age, sib_sp, par_ch, fare, sex_female, sex_male,
embarked_c, embarked_q, embarked_s):
clf = PNN(verbose=False, std=10)
clf.fit(X_train, y_train)
x_test = np.array([[
p_class, age, sib_sp, par_ch, fare, sex_female, sex_male,
embarked_c, embarked_q, embarked_s
]])
y_predict = clf.predict(x_test)
return float(y_predict)
def test_digit_prediction(self):
dataset = datasets.load_digits()
x_train, x_test, y_train, y_test = train_test_split(
dataset.data, dataset.target, train_size=0.7
)
nw = PNN(standard_deviation=10)
nw.train(x_train, y_train)
result = nw.predict(x_test)
self.assertAlmostEqual(metrics.accuracy_score(y_test, result),
0.9889, places=4)
def test_simple_pnn(self):
dataset = datasets.load_iris()
data = dataset.data
target = dataset.target
test_data_size = 10
skfold = StratifiedKFold(target, test_data_size)
avarage_result = 0
for train, test in skfold:
x_train, x_test = data[train], data[test]
y_train, y_test = target[train], target[test]
nw = PNN(standard_deviation=0.1)
nw.train(x_train, y_train)
result = nw.predict(x_test)
avarage_result += sum(y_test == result)
self.assertEqual(avarage_result / test_data_size, 14.4)
import numpy as np
from sklearn import datasets
from sklearn.model_selection import StratifiedKFold
from neupy.algorithms import PNN
dataset = datasets.load_iris()
data = dataset.data
target = dataset.target
test_data_size = 10
skfold = StratifiedKFold(n_splits=test_data_size)
avarage_result = 0
print("> Start classify iris dataset")
for i, (train, test) in enumerate(skfold.split(data, target), start=1):
x_train, x_test = data[train], data[test]
y_train, y_test = target[train], target[test]
pnn_network = PNN(std=0.1, verbose=False)
pnn_network.train(x_train, y_train)
result = pnn_network.predict(x_test)
print("Test #{:<2}: Guessed {} out of {}".format(i,
np.sum(result == y_test),
test.size))
thisF1_sum = 0
sensitivity_sum = 0
print("> Start classify mesothelioma dataset")
for i, (train, test) in enumerate(skfold, start=1):
x_train, x_test = mesothelioma_data[train], mesothelioma_data[test]
y_train, y_test = mesothelioma_target[train], mesothelioma_target[test]
pnn_network = PNN(std=0.1, step=0.2, verbose=True) # BEST
#pnn_network = PNN(std=0.1, step=0.2, verbose=True, batch_size=20)
# pnn_network.train(x_train, y_train)
# predictions = pnn_network.predict(x_test)
pnn_network.train(mesothelioma_data[train], mesothelioma_target[train])
predictions = pnn_network.predict(mesothelioma_data[test])
# print(predictions)
#print(mesothelioma_target[test])
tn, fp, fn, tp = confusion_matrix(mesothelioma_target[test],
predictions).ravel()
print("tn, fp, fn, tp")
print(
tn,
fp,
fn,
tp,
)
mcc = matthews_corrcoef(mesothelioma_target[test], predictions)
import numpy as np
from sklearn import datasets
from sklearn.model_selection import StratifiedKFold
from neupy.algorithms import PNN
dataset = datasets.load_iris()
data = dataset.data
target = dataset.target
test_data_size = 10
skfold = StratifiedKFold(n_splits=test_data_size)
avarage_result = 0
print("> Start classify iris dataset")
for i, (train, test) in enumerate(skfold.split(data, target), start=1):
x_train, x_test = data[train], data[test]
y_train, y_test = target[train], target[test]
pnn_network = PNN(std=0.1, verbose=False)
pnn_network.train(x_train, y_train)
result = pnn_network.predict(x_test)
print("Test #{:<2}: Guessed {} out of {}".format(
i, np.sum(result == y_test), test.size
))
# fit only to the training data
scaler.fit(X_train)
#StandardScaler(copy=True, with_mean=True, with_std=True)
# apply the transformations to the data
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
pnn_network = PNN(std=1,
shuffle_data=True,
batch_size=10,
step=0.01,
verbose=False)
pnn_network.train(X_train, y_train)
result = pnn_network.predict(X_test)
train_predictions = pnn_network.predict(X_train)
train_accuracy = (train_predictions == y_train).sum() / len(y_train)
print('train accuracy %s' % train_accuracy) #0.958907605921
# prediction and evaluation
predictions = pnn_network.predict(X_test)
test_accuracy = (predictions == y_test).sum() / len(y_test)
print('test accuracy %s' % test_accuracy) #0.617346938776
from sklearn.metrics import classification_report, confusion_matrix
print(confusion_matrix(y_test, predictions))
'''
[[ 0 0 2 0 0 0]
[ 0 4 18 4 2 1]
nnclf.fit(X_train, Y_train)
endtime = time.time()
nn_pred = nnclf.predict(X_test)
nn_predictions = RBF_ISCC.target2matrix(nn_pred,
len(dataset.label_dict),
pos_note=1,
neg_note=0)
nn_score = performance_measure(nn_predictions, true_label)
print("NN:{score}".format(score=nn_score))
print("Time:{}s".format(endtime - starttime))
#%%
starttime = time.time()
rbfclf = PNN(std=0.5, batch_size="all")
rbfclf.train(X_train, Y_train)
endtime = time.time()
rbf_pred = rbfclf.predict(X_test)
rbf_predictions = RBF_ISCC.target2matrix(rbf_pred,
len(dataset.label_dict),
pos_note=1,
neg_note=0)
rbf_score = performance_measure(rbf_predictions, true_label)
print("RBF:{score}".format(score=rbf_score))
print("Time:{}s".format(endtime - starttime))
#%%
# starttime=time.time()
# krr_clf = KernelRidge().fit(X_train, Y_train)
# endtime=time.time()
# krr_clf_pred = krr_clf.predict(X_test)
## krr_clf_pred = np.round(krr_clf.predict(X_test)).astype(int)
## krr_predictions = RBF_ISCC.target2matrix(krr_clf_pred, len(dataset.label_dict), pos_note=1, neg_note=0)
# krr_score = performance_measureML(krr_predictions, true_label)
pnn = PNN(std=0.1)
pnn.train(X_train, Y_train)
# Cross validataion
score = cross_val_score(pnn,
X_train,
Y_train,
scoring='accuracy',
cv=cross_validation)
print("")
print("Cross Validation: {0} (+/- {1})".format(abs(score.mean().round(2)),
(score.std() * 2).round(2)))
print("")
#Prediction
Y_predict = pnn.predict(X_test)
print(Y_test.values)
print(Y_predict)
print("Accuracy: {0}".format(
metrics.accuracy_score(Y_test, Y_predict).round(2)))
else:
pnn = GaussianNB()
pnn.fit(X_train, Y_train)
print(
'Sigma: {0}'.format(pnn.sigma_)
) #Standard deviation is estimated using maximum likelihood, so one sigma per variable and per class
# Cross validataion
score = cross_val_score(pnn,
X_train,
