def main():
filename = "training_data.csv"
n_hidden_nodes = [5]
l_rate = 0.6
n_epochs = 800
n_folds = 4
print("Neural network model:\n n_hidden_nodes = {}".format(n_hidden_nodes))
print(" l_rate = {}".format(l_rate))
print(" n_epochs = {}".format(n_epochs))
print(" n_folds = {}".format(n_folds))
print("\nReading '{}'...".format(filename))
X, y = utils.read_csv(filename)
utils.normalize(X)
N, d = X.shape
n_classes = len(np.unique(y))
print(" X.shape = {}".format(X.shape))
print(" y.shape = {}".format(y.shape))
print(" n_classes = {}".format(n_classes))
idx_all = np.arange(0, N)
idx_folds = utils.crossval_folds(N, n_folds, seed=1)
acc_train, acc_test = list(), list()
print("\nTraining and cross-validating...")
for i, idx_test in enumerate(idx_folds):
idx_train = np.delete(idx_all, idx_test)
X_train, y_train = X[idx_train], y[idx_train]
X_test, y_test = X[idx_test], y[idx_test]
model = NeuralNetwork(n_input=d,
n_output=n_classes,
n_hidden_nodes=n_hidden_nodes)
model.train(X_train, y_train, l_rate=l_rate, n_epochs=n_epochs)
y_train_predict = model.predict(X_train)
y_test_predict = model.predict(X_test)
acc_train.append(100 * np.sum(y_train == y_train_predict) /
len(y_train))
acc_test.append(100 * np.sum(y_test == y_test_predict) / len(y_test))
print(
" Fold {}/{}: train acc = {:.2f}%, test acc = {:.2f}% (n_train = {}, n_test = {})"
.format(i + 1, n_folds, acc_train[-1], acc_test[-1], len(X_train),
len(X_test)))
print("\nAvg train acc = {:.2f}%".format(
sum(acc_train) / float(len(acc_train))))
print("Avg test acc = {:.2f}%".format(
sum(acc_test) / float(len(acc_test))))
def main():
# ===================================
# Settings
# ===================================
csv_filename = "data/creditcard.csv"
hidden_layers = [5]
eta = 0.1
n_epochs = 500
n_folds = 3
X, y, n_classes = utils.read_csv(csv_filename, target_name="Class")
N, d = X.shape
print(" -> X.shape = {}, y.shape = {}, n_classes = {}\n".format(X.shape, y.shape, n_classes))
print("Running")
idx_all = np.arange(0, N)
idx_folds = utils.crossval_folds(N, n_folds, seed=1)
acc_train, acc_valid = list(), list()
print("Cross-validation")
for i, idx_valid in enumerate(idx_folds):
idx_train = np.delete(idx_all, idx_valid)
X_train, y_train = X[idx_train], y[idx_train]
X_valid, y_valid = X[idx_valid], y[idx_valid]
model = NeuralNetwork(input_dim=d, output_dim=n_classes,
hidden_layers=hidden_layers, seed=1)
model.train(X_train, y_train, eta=eta, n_epochs=n_epochs)
ypred_train = model.predict(X_train)
ypred_valid = model.predict(X_valid)
acc_train.append(100 * np.sum(y_train == ypred_train) / len(y_train))
acc_valid.append(100 * np.sum(y_valid == ypred_valid) / len(y_valid))
print("TP: " + str(np.sum((y_valid == ypred_valid) & (y_valid == 1))))
print("TN: " + str(np.sum((y_valid == ypred_valid) & (y_valid == 0))))
print("FP: " + str(np.sum((y_valid != ypred_valid) & (y_valid == 1))))
print("FN: " + str(np.sum((y_valid != ypred_valid) & (y_valid == 0))))
TP = np.sum((y_valid == ypred_valid) & (y_valid == 1))
TN = np.sum((y_valid == ypred_valid) & (y_valid == 0))
FP = np.sum((y_valid != ypred_valid) & (y_valid == 1))
FN = np.sum((y_valid != ypred_valid) & (y_valid == 0))
precision = calculate_precision(TP, FP)
recall = calculate_recall(TP, FN)
print(str(f1_score(recall, precision)))
print(" Fold {}/{}: acc_train = {:.2f}%, acc_valid = {:.2f}% (n_train = {}, n_valid = {})".format(
i + 1, n_folds, acc_train[-1], acc_valid[-1], len(X_train), len(X_valid)))
print(" -> acc_train_avg = {:.2f}%, acc_valid_avg = {:.2f}%".format(
sum(acc_train) / float(len(acc_train)), sum(acc_valid) / float(len(acc_valid))))
def main():
# ===================================
# Settings
# ===================================
csv_filename = "data/Leeds02.csv"
hidden_layers = [5] # number of nodes in hidden layers i.e. [layer1, layer2, ...]
eta = 0.1 # learning rate
n_epochs = 400 # number of training epochs
n_folds = 4 # number of folds for cross-validation
seed_crossval = 1 # seed for cross-validation
seed_weights = 1 # seed for NN weight initialization
# ===================================
# Read csv data + normalize features
# ===================================
print("Reading '{}'...".format(csv_filename))
X, y, n_classes = utils.read_csv(csv_filename, target_name="y", normalize=True)
N, d = X.shape
print(" -> X.shape = {}, y.shape = {}, n_classes = {}\n".format(X.shape, y.shape, n_classes))
print("Neural network model:")
print(" input_dim = {}".format(d))
print(" hidden_layers = {}".format(hidden_layers))
print(" output_dim = {}".format(n_classes))
print(" eta = {}".format(eta))
print(" n_epochs = {}".format(n_epochs))
print(" n_folds = {}".format(n_folds))
print(" seed_crossval = {}".format(seed_crossval))
print(" seed_weights = {}\n".format(seed_weights))
# ===================================
# Create cross-validation folds
# ===================================
idx_all = np.arange(0, N)
idx_folds = utils.crossval_folds(N, n_folds, seed=seed_crossval) # list of list of fold indices
# ===================================
# Train/evaluate the model on each fold
# ===================================
acc_train, acc_valid = list(), list() # training/test accuracy score
print("Cross-validating with {} folds...".format(len(idx_folds)))
for i, idx_valid in enumerate(idx_folds):
# Collect training and test data from folds
idx_train = np.delete(idx_all, idx_valid)
X_train, y_train = X[idx_train], y[idx_train]
X_valid, y_valid = X[idx_valid], y[idx_valid]
# Build neural network classifier model and train
model = NeuralNetwork(input_dim=d, output_dim=n_classes,
hidden_layers=hidden_layers, seed=seed_weights)
model.train(X_train, y_train, eta=eta, n_epochs=n_epochs)
# Make predictions for training and test data
ypred_train = model.predict(X_train)
ypred_valid = model.predict(X_valid)
# Compute training/test accuracy score from predicted values
acc_train.append(100*np.sum(y_train==ypred_train)/len(y_train))
acc_valid.append(100*np.sum(y_valid==ypred_valid)/len(y_valid))
# Print cross-validation result
print(" Fold {}/{}: acc_train = {:.2f}%, acc_valid = {:.2f}% (n_train = {}, n_valid = {})".format(
i+1, n_folds, acc_train[-1], acc_valid[-1], len(X_train), len(X_valid)))
# ===================================
# Print results
# ===================================
print(" -> acc_train_avg = {:.2f}%, acc_valid_avg = {:.2f}%".format(
sum(acc_train)/float(len(acc_train)), sum(acc_valid)/float(len(acc_valid))))
def main():
# ===================================
# Settings
# ===================================
filename = "data/seeds_dataset.csv"
n_hidden_nodes = [
5
] # nodes in hidden layers i.e. [n_nodes_1, n_nodes_2, ...]
l_rate = 0.6 # learning rate
n_epochs = 800 # number of training epochs
n_folds = 4 # number of folds for cross-validation
print("Neural network model:\n n_hidden_nodes = {}".format(n_hidden_nodes))
print(" l_rate = {}".format(l_rate))
print(" n_epochs = {}".format(n_epochs))
print(" n_folds = {}".format(n_folds))
# ===================================
# Read data (X,y) and normalize X
# ===================================
print("\nReading '{}'...".format(filename))
X, y = utils.read_csv(filename) # read as matrix of floats and int
utils.normalize(X) # normalize
N, d = X.shape # extract shape of X
n_classes = len(np.unique(y))
print(" X.shape = {}".format(X.shape))
print(" y.shape = {}".format(y.shape))
print(" n_classes = {}".format(n_classes))
# ===================================
# Create cross-validation folds
# These are a list of a list of indices for each fold
# ===================================
idx_all = np.arange(0, N)
idx_folds = utils.crossval_folds(N, n_folds, seed=1)
# ===================================
# Train and evaluate the model on each fold
# ===================================
acc_train, acc_test = list(), list() # training/test accuracy score
print("\nTraining and cross-validating...")
for i, idx_test in enumerate(idx_folds):
# Collect training and test data from folds
idx_train = np.delete(idx_all, idx_test)
X_train, y_train = X[idx_train], y[idx_train]
X_test, y_test = X[idx_test], y[idx_test]
# Build neural network classifier model and train
model = NeuralNetwork(n_input=d,
n_output=n_classes,
n_hidden_nodes=n_hidden_nodes)
model.train(X_train, y_train, l_rate=l_rate, n_epochs=n_epochs)
# Make predictions for training and test data
y_train_predict = model.predict(X_train)
y_test_predict = model.predict(X_test)
# Compute training/test accuracy score from predicted values
acc_train.append(100 * np.sum(y_train == y_train_predict) /
len(y_train))
acc_test.append(100 * np.sum(y_test == y_test_predict) / len(y_test))
# Print cross-validation result
print(
" Fold {}/{}: train acc = {:.2f}%, test acc = {:.2f}% (n_train = {}, n_test = {})"
.format(i + 1, n_folds, acc_train[-1], acc_test[-1], len(X_train),
len(X_test)))
# ===================================
# Print results
# ===================================
print("\nAvg train acc = {:.2f}%".format(
sum(acc_train) / float(len(acc_train))))
print("Avg test acc = {:.2f}%".format(
sum(acc_test) / float(len(acc_test))))
X.shape, y.shape, n_classes))
N, d = X.shape
print("Neural network model:")
print(" input_dim = {}".format(d))
print(" hidden_layers = {}".format(hidden_layers))
print(" output_dim = {}".format(n_classes))
print(" eta = {}".format(eta))
print(" n_epochs = {}".format(n_epochs))
print(" n_folds = {}".format(n_folds))
print(" seed_crossval = {}".format(seed_crossval))
print(" seed_weights = {}\n".format(seed_weights))
# Create cross-validation folds
idx_all = np.arange(0, N)
idx_folds = utils.crossval_folds(
N, n_folds, seed=seed_crossval) # list of list of fold indices
# Train/evaluate the model on each fold
acc_train, acc_valid = list(), list()
print("Cross-validating with {} folds...".format(len(idx_folds)))
for i, idx_valid in enumerate(idx_folds):
# Collect training and test data from folds
idx_train = np.delete(idx_all, idx_valid)
X_train, y_train = X[idx_train], y[idx_train]
X_valid, y_valid = X[idx_valid], y[idx_valid]
# Build neural network classifier model and train
model = NN(input_dim=d,
output_dim=n_classes,
hidden_layers=hidden_layers,