def main():
# load data into shuffle matrix
df = pd.read_csv("diabetes.csv")
data = np.array(df)
np.random.shuffle(data)
# split data into labels and design matrix
design = data[:, :-1].T
labels = data[:, -1]
labels = labels.reshape((labels.shape[0],1)).T # keep dims to 2
n, m_tot = design.shape
# normalize dataset
maxs = np.amax(design, axis=1)
mins = np.amin(design, axis=1)
ranges = maxs - mins
design -= mins.reshape(len(mins),1)
design /= ranges.reshape(len(ranges),1)
# split into test and training data
frac_test = .8
split_idx = int(frac_test*m_tot)
train_design = design[:, :split_idx]
train_labels = labels[:, :split_idx]
test_design = design[:, split_idx:]
test_labels = labels[:, split_idx:]
# fit neural network
nn = NN(ns=[n,5,1], acts=["ReLU","ReLU","sigmoid"])
nn.fit(train_design, train_labels, alpha=1e-2, epochs = 20_000)
test_acc = nn.evaluate(X=test_design, Y=test_labels)
train_acc = nn.evaluate(X=train_design, Y=train_labels)
print("Network test set accuracy: %.5f" % test_acc)
print("Network training set accuracy: %.5f" % train_acc)
print()
# fit perceptron
perc = Perceptron()
perc.fit(X=train_design, Y=train_labels, alpha=1e-4,
lambd=1e-2, epochs=100_000)
test_acc = perc.acc(X=test_design, Y=test_labels)
train_acc = perc.acc(X=train_design, Y=train_labels)
print("Own perceptron test set accuracy: %.5f" % test_acc)
print("Own perceptron training set accuracy: %.5f" % train_acc)
print()
# fit standard template perceptron from sklearn
clf = standardPerceptron(tol=1e-3, random_state=0)
clf.fit(train_design.T, train_labels.squeeze())
train_acc = clf.score(train_design.T, train_labels.squeeze())
test_acc = clf.score(test_design.T, test_labels.squeeze())
print("Sklearn perceptron test set accuracy: %.5f" % test_acc)
print("Sklearn perceptron training set accuracy: %.5f"%train_acc)
print()
from NN import NN
import numpy as np
nn = NN([2,2,1],'tanh')
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0,1,1,0])
nn.fit(X,y)
for i in [[0,0],[0,1],[1,0],[1,1]]:
print(i,nn.predict(i))
import numpy as np
from NN import NN
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y_and = np.array([a & b for a, b in X])
y_or = np.array([a | b for a, b in X])
y_xor = np.array([a ^ b for a, b in X])
# AND
nn = NN(max_iterations=3000, size_hidden=10, size_output=2, learning_rate=0.01)
nn.fit(X, y_and)
nn.plot_accuracies('./nn_and.png')
print('Score and: {}'.format(nn.score(X, y_and)))
# OR
nn = NN(max_iterations=3000, size_hidden=10, size_output=2, learning_rate=0.01)
nn.fit(X, y_or)
nn.plot_accuracies('./nn_or.png')
print('Score or: {}'.format(nn.score(X, y_or)))
# XOR
nn = NN(max_iterations=3000, size_hidden=10, size_output=2, learning_rate=0.01)
nn.fit(X, y_and)
nn.plot_accuracies('./nn_xor.png')
print('Score xor: {}'.format(nn.score(X, y_and)))
from Parser import get_data_set
from NN import NN
X_train, X_test, y_train, y_test = get_data_set('digits.data')
nn = NN()
nn.fit(X_train, y_train)
nn.plot_accuracies()
print('Score train: {}'.format(nn.score(X_train, y_train)))
print('Score: {}'.format(nn.score(X_test, y_test)))
# -*- coding: utf-8 -*-
# import the necessary packages
from NN import NN
import numpy as np
# construct the XOR dataset
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
# define our 2-2-1 neural network and train it
nn = NN([2, 2, 1], alpha=0.5)
nn.fit(X, y, epochs=20000)
# now that our network is trained, loop over the XOR data points
for (x, target) in zip(X, y):
# make a prediction on the data point and display the result
# to our console
pred = nn.predict(x)[0][0]
step = 1 if pred > 0.5 else 0
print("[INFO] data={}, ground-truth={}, pred={:.4f}, step={}".format(
x, target[0], pred, step))
import numpy as np
from sklearn.datasets import load_digits
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.preprocessing import LabelBinarizer
from NN import NN
from sklearn.model_selection import train_test_split
digits = load_digits()
X = digits.data
y = digits.target
# normalize values into (0,1)
X -= X.min()
X /= X.max()
nn = NN([64, 100, 10], 'logistic')
X_train, X_test, y_train, y_test = train_test_split(X, y)
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)
print("start fitting")
nn.fit(X_train, labels_train, epochs=30000)
predictions = []
for i in range(X_test.shape[0]):
o = nn.predict(X_test[i])
predictions.append(np.argmax(o))
print(confusion_matrix(y_test, predictions))
print(classification_report(y_test, predictions))
import lime
import lime.lime_tabular
import sklearn
import sklearn.metrics
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import fetch_20newsgroups
from lime.lime_text import LimeTextExplainer
from utils_lime import Draw_Lime_On_Logistic_Regression
exit()
if variables.choice_of_work == 1:
xtrain, ytrain, xtest, ytest = load_data(variables.file_name)
xtrain, xtest = normalisation(xtrain, xtest)
n = NN(variables.choice, variables.w)
n.fit(xtrain, ytrain)
ypred = n.pred(xtest)
print(1 - accuracy_score(ytest, ypred))
explainer = lime.lime_tabular.LimeTabularExplainer(xtrain,
mode='classification')
exp = explainer.explain_instance(xtest[0],
n.pred_proba,
labels=1,
top_labels=1)
exp.as_pyplot_figure()
plt.show()
elif variables.choice_of_work == 2:
xtrain, ytrain, xtest, ytest = load_data(variables.file_name)
xtrain, xtest = normalisation(xtrain, xtest)
sax = SAX(variables.p, variables.alpha)
VSM_train, classes = sax.fit(xtrain, ytrain)
trainy.append(label[x])
else:
testy.append(label[x])
testx.append(data[x])
trainy = np.array(trainy)
trainx = np.array(trainx)
testx = np.array(testx)
testy = np.array(testy)
# print(data.shape)
# print(label.shape)
# trainx,testx,trainy,testy = train_test_split(data,label,test_size=0.5)
model = NN([3], 0.005)
model.fit(trainx, trainy, 10)
joblib.dump(model, "neural.sav")
acr, scr, pred = model.score(testx, testy)
print(acr)
plot_conf(np.array(pred), np.argmax(testy, axis=1), "conf_NN",
"NN Relu-Softmax")
plt.close()
fpr, tpr, thres = roc_curve(np.argmax(testy, axis=1), scr, pos_label=0)
plt.plot(fpr, tpr)
plt.savefig("plots/rocNN.png")
plt.close()
plt.plot(np.arange(0, len(fpr)), fpr, label="FPR")
plt.plot(np.arange(0, len(fpr)), np.subtract(1, np.array(tpr)), label="FNR")
plt.legend()
label_ones = np.ones((data_human.shape[0], 1))
label_zeros = np.zeros((data_non_human.shape[0], 1))
targets = np.vstack((label_ones, label_zeros))
X_train, X_test, Y_train, Y_test = train_test_split(feature_set,
targets,
test_size=0.2)
# create the network
nn_model = NN(X_train, Y_train)
nn_model.add_layer(Layer(24, activation='relu'))
nn_model.add_layer(Layer(12, activation='sigmoid'))
#fit the network
nn_model.fit(iteration=100, learning_rate=0.1)
# plot cost function
Y_train_pred = nn_model.predict(X_train)
Y_test_pred = nn_model.predict(X_test)
accuracy_train = np.sum(Y_train_pred == Y_train) / len(Y_train) * 100
accuracy = np.sum(Y_test_pred == Y_test) / len(Y_test) * 100
print("Train accuracy: " + str(accuracy_train) + "%")
print("Test accuracy: " + str(accuracy) + "%")
# # create the network
# nn_model_2 = NN(X_train, Y_train)
# nn_model_2.add_layer(Layer(50, activation='relu'))
# nn_model_2.add_layer(Layer(25, activation='sigmoid'))
