signal = A * (np.sin(2 * np.pi * 5 * t) + 1) / 2 # Input Sub Threshold Signal
input_data = signal.reshape(len(signal), 1)
INA = 0.35 # Initial Neural Activity
EPSILON = np.arange(0.001, 1.001, 0.001)
#EPSILON_1 = 0.05 # Epsilon
DT = 0.65 # Discrimination Threshold
ROW = -1
CROSS_CORR_ZERO_LAG = np.zeros((len(EPSILON), 1))
compute_statistics = 2 # [0-firing rate, 1 - Energy, 2 - Firinig Time and 3 - Entropy]
feature_name = ['firing rate', 'energy', 'firing time', 'entropy']
for EPSILON_1 in EPSILON:
ROW = ROW + 1
feature = CFX.transform(input_data, INA, 10000, EPSILON_1,
DT)[:, compute_statistics]
feature_quantized = feature.copy()
if compute_statistics == 1 or compute_statistics == 2:
feature = (feature - np.min(feature)) / (np.max(feature) -
np.min(feature) + 0.0001)
if np.std(feature) != 0:
CROSS_CORR_ZERO_LAG[ROW, 0] = np.corrcoef(signal, feature)[0, 1]
plt.figure(figsize=(10, 10))
plt.plot(EPSILON, CROSS_CORR_ZERO_LAG, '-*k', markersize=6)
# plt.axhline(y=threshold, color='b', linestyle='--', alpha=0.6, label = 'threshold')
# plt.plot(t, feature,'-or', markersize = 6, label = feature_name[compute_statistics])
#plt.plot(t, (firing_rate-np.min(firing_rate))/(np.max(firing_rate)-np.min(firing_rate)),'-or', markersize = 6, label = 'normalized firing time')
# Loading the overlapping concentric circle data (not normalized)
classification_type = "concentric_circle_noise"
traindata, trainlabel, testdata, testlabel = get_data(classification_type)
# Normalizing the test data
X_test_norm = (testdata - np.min(testdata, 0)) / (np.max(testdata, 0) -
np.min(testdata, 0))
# Hyperparameters found using three fold validation
initial_neural_activity = 0.22
discrimination_threshold = 0.96
epsilon = 0.018
# Extracting Neurochaos features from normalized test data
neurochaos_test_data_features = CFX.transform(X_test_norm,
initial_neural_activity, 20000,
epsilon,
discrimination_threshold)
# Binary Classification problem
target_names = ['class-0', 'class-1']
# Extracting traindata belonging to class-0 and class-1 separately
class_0, class_1 = class_wise_data(traindata, trainlabel)
# Extracting the data belonging to 4 quadrants from class-0
quad_1_c0, quad_2_c0, quad_3_c0, quad_4_c0 = data_in_quadrants(class_0)
# Extracting the data belonging to 4 quadrants from class-1
quad_1_c1, quad_2_c1, quad_3_c1, quad_4_c1 = data_in_quadrants(class_1)
# Finding the L2 norm (distance) of data instances belonging to quadrant 1,
# 2, 3 and 4 for the class-0 data.
radius_1_c0 = np.sqrt(np.sum(quad_1_c0**2, axis=1))
radius_2_c0 = np.sqrt(np.sum(quad_2_c0**2, axis=1))
def k_cross_validation(FOLD_NO, traindata, trainlabel, testdata, testlabel,
INITIAL_NEURAL_ACTIVITY, DISCRIMINATION_THRESHOLD,
EPSILON, DATA_NAME):
"""
Parameters
----------
FOLD_NO : TYPE-Integer
DESCRIPTION-K fold classification.
traindata : TYPE-numpy 2D array
DESCRIPTION - Traindata
trainlabel : TYPE-numpy 2D array
DESCRIPTION - Trainlabel
testdata : TYPE-numpy 2D array
DESCRIPTION - Testdata
testlabel : TYPE - numpy 2D array
DESCRIPTION - Testlabel
INITIAL_NEURAL_ACTIVITY : TYPE - numpy 1D array
DESCRIPTION - initial value of the chaotic skew tent map.
DISCRIMINATION_THRESHOLD : numpy 1D array
DESCRIPTION - thresholds of the chaotic map
EPSILON : TYPE numpy 1D array
DESCRIPTION - noise intenity for NL to work (low value of epsilon implies low noise )
DATA_NAME : TYPE - string
DESCRIPTION.
Returns
-------
FSCORE, Q, B, EPS, EPSILON
"""
ACCURACY = np.zeros((len(DISCRIMINATION_THRESHOLD),
len(INITIAL_NEURAL_ACTIVITY), len(EPSILON)))
FSCORE = np.zeros((len(DISCRIMINATION_THRESHOLD),
len(INITIAL_NEURAL_ACTIVITY), len(EPSILON)))
Q = np.zeros((len(DISCRIMINATION_THRESHOLD), len(INITIAL_NEURAL_ACTIVITY),
len(EPSILON)))
B = np.zeros((len(DISCRIMINATION_THRESHOLD), len(INITIAL_NEURAL_ACTIVITY),
len(EPSILON)))
EPS = np.zeros(
(len(DISCRIMINATION_THRESHOLD), len(INITIAL_NEURAL_ACTIVITY),
len(EPSILON)))
KF = KFold(n_splits=FOLD_NO, random_state=42,
shuffle=True) # Define the split - into 2 folds
KF.get_n_splits(
traindata
) # returns the number of splitting iterations in the cross-validator
print(KF)
ROW = -1
COL = -1
WIDTH = -1
for DT in DISCRIMINATION_THRESHOLD:
ROW = ROW + 1
COL = -1
WIDTH = -1
for INA in INITIAL_NEURAL_ACTIVITY:
COL = COL + 1
WIDTH = -1
for EPSILON_1 in EPSILON:
WIDTH = WIDTH + 1
ACC_TEMP = []
FSCORE_TEMP = []
for TRAIN_INDEX, VAL_INDEX in KF.split(traindata):
X_TRAIN, X_VAL = traindata[TRAIN_INDEX], traindata[
VAL_INDEX]
Y_TRAIN, Y_VAL = trainlabel[TRAIN_INDEX], trainlabel[
VAL_INDEX]
# Extract features
FEATURE_MATRIX_TRAIN = CFX.transform(
X_TRAIN, INA, 10000, EPSILON_1, DT)
FEATURE_MATRIX_VAL = CFX.transform(X_VAL, INA, 10000,
EPSILON_1, DT)
mean_each_class, Y_PRED = chaosnet(FEATURE_MATRIX_TRAIN,
Y_TRAIN,
FEATURE_MATRIX_VAL)
ACC = accuracy_score(Y_VAL, Y_PRED) * 100
RECALL = recall_score(Y_VAL, Y_PRED, average="macro")
PRECISION = precision_score(Y_VAL, Y_PRED, average="macro")
F1SCORE = f1_score(Y_VAL, Y_PRED, average="macro")
ACC_TEMP.append(ACC)
FSCORE_TEMP.append(F1SCORE)
Q[ROW, COL, WIDTH] = INA # Initial Neural Activity
B[ROW, COL, WIDTH] = DT # Discrimination Threshold
EPS[ROW, COL, WIDTH] = EPSILON_1
ACCURACY[ROW, COL, WIDTH] = np.mean(ACC_TEMP)
FSCORE[ROW, COL, WIDTH] = np.mean(FSCORE_TEMP)
print("Mean F1-Score for Q = ", Q[ROW, COL, WIDTH], "B = ",
B[ROW, COL, WIDTH], "EPSILON = ", EPS[ROW, COL,
WIDTH], " is = ",
np.mean(FSCORE_TEMP))
print("Saving Hyperparameter Tuning Results")
PATH = os.getcwd()
RESULT_PATH = PATH + '/SR-PLOTS/' + DATA_NAME + '/NEUROCHAOS-RESULTS/'
try:
os.makedirs(RESULT_PATH)
except OSError:
print("Creation of the result directory %s failed" % RESULT_PATH)
else:
print("Successfully created the result directory %s" % RESULT_PATH)
np.save(RESULT_PATH + "/h_fscore.npy", FSCORE)
np.save(RESULT_PATH + "/h_accuracy.npy", ACCURACY)
np.save(RESULT_PATH + "/h_Q.npy", Q)
np.save(RESULT_PATH + "/h_Q.npy", B)
np.save(RESULT_PATH + "/h_EPS.npy", EPS)
MAX_FSCORE = np.max(FSCORE)
Q_MAX = []
B_MAX = []
EPSILON_MAX = []
for ROW in range(0, len(DISCRIMINATION_THRESHOLD)):
for COL in range(0, len(INITIAL_NEURAL_ACTIVITY)):
for WID in range(0, len(EPSILON)):
if FSCORE[ROW, COL, WID] == MAX_FSCORE:
Q_MAX.append(Q[ROW, COL, WID])
B_MAX.append(B[ROW, COL, WID])
EPSILON_MAX.append(EPS[ROW, COL, WID])
print("BEST F1SCORE", MAX_FSCORE)
print("BEST INITIAL NEURAL ACTIVITY = ", Q_MAX)
print("BEST DISCRIMINATION THRESHOLD = ", B_MAX)
print("BEST EPSILON = ", EPSILON_MAX)
return FSCORE, Q, B, EPS, EPSILON
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Quick script for demonstrating ChaosFEX functionality @author: Dr. Pranay S. Yadav """ # Import calls import numpy as np import ChaosFEX.feature_extractor as CFX # Initialize a 2D array feat = np.random.random(size=(100, 100)) # Extract features CFX.transform(feat, 0.1, 1000, 0.1, 0.15)
def hyperparameter_tuning_bc(classification_type, epsilon, initial_neural_activity, discrimination_threshold):
"""
This module does hyperparameter tuning to find the best epsilon,
and discrimination threshold.
Parameters
----------
classification_type : string
DESCRIPTION- classification_type = "binary_class", loads binary
classification data.
classification_type = "multi_class", loads multiclass classification
data.
epsilon : array, 1D
DESCRIPTION - epsilon - is the neighbourhood of the stimulus. Epsilon is
a value between 0 and 0.3.
initial_neural_activity : array, 1D (This array should contain
only one element, for eg. np.array([0.34],dtype = 'float64')).
DESCRIPTION - Every chaotic neuron has an initial neural activity.
The firinig of chaotic neuron starts from this value.
discrimination_threshold : array, 1D
DESCRIPTION - discrimination threshold is used to calculate the
fraction of time the chaotic trajrectory is above this threshold.
For more informtion, refer the following: https://aip.scitation.org/doi/abs/10.1063/1.5120831?journalCode=cha
Returns
-------
best_initial_neural_activity : array, 1D (This array has only one element).
DESCRIPTION - return initial neural activity
best_discrimination_threshold : array, 1D
DESCRIPTION - return discrimniation threshold
best_epsilon : array, 1D
DESCRIPTION - return best epsilon
"""
full_genome_data, full_genome_label = get_data(classification_type)
accuracy_matrix = np.zeros((len(discrimination_threshold), len(epsilon)))
f1score_matrix = np.zeros((len(discrimination_threshold), len(epsilon)))
q_matrix = np.zeros((len(discrimination_threshold), len(epsilon)))
b_matrix = np.zeros((len(discrimination_threshold), len(epsilon)))
epsilon_matrix = np.zeros((len(discrimination_threshold), len(epsilon)))
# Define the split - into 2 folds
k_fold = KFold(n_splits=3, random_state=42, shuffle=True)
# returns the number of splitting iterations in the cross-validator
k_fold.get_n_splits(full_genome_data)
print(k_fold)
KFold(n_splits=3, random_state=42, shuffle=True)
row = -1
col = -1
initial_condition_instance = initial_neural_activity[0]
for threshold_instance in discrimination_threshold:
row = row+1
col = -1
for epsilon_instance in epsilon:
col = col+1
acc_temp = []
fscore_temp = []
for train_index, val_index in k_fold.split(full_genome_data):
train_genome_data = full_genome_data[train_index]
val_genome_data = full_genome_data[val_index]
train_genome_label = full_genome_label[train_index]
val_genome_label = full_genome_label[val_index]
print(" train data (%) = ",
(train_genome_data.shape[0]/full_genome_data.shape[0])*100)
print("val data (%) = ",
(val_genome_data.shape[0]/full_genome_data.shape[0])*100)
neurochaos_train_data_features = CFX.transform(train_genome_data,
initial_condition_instance,
20000, epsilon_instance,
threshold_instance)
neurochaos_val_data_features = CFX.transform(val_genome_data,
initial_condition_instance,
20000, epsilon_instance,
threshold_instance)
# Neurochaos-SVM with linear kernel.
classifier_neurochaos_svm = LinearSVC(random_state=0, tol=1e-5, dual=False)
classifier_neurochaos_svm.fit(neurochaos_train_data_features,
train_genome_label[:, 0])
predicted_neurochaos_val_label = classifier_neurochaos_svm.predict(neurochaos_val_data_features)
# Accuracy
acc_neurochaos = accuracy_score(val_genome_label, predicted_neurochaos_val_label)*100
# Macro F1- Score
f1score_neurochaos = f1_score(val_genome_label, predicted_neurochaos_val_label, average="macro")
acc_temp.append(acc_neurochaos)
fscore_temp.append(f1score_neurochaos)
q_matrix[row, col] = initial_condition_instance
b_matrix[row, col] = threshold_instance
epsilon_matrix[row, col] = epsilon_instance
# Average Accuracy
accuracy_matrix[row, col] = np.mean(acc_temp)
# Average Macro F1-score
f1score_matrix[row, col] = np.mean(fscore_temp)
print("q_matrix = ", q_matrix[row, col],
"b_matrix = ", b_matrix[row, col],
"epsilon = ", epsilon_matrix[row, col])
print("Three fold Average F-SCORE %.3f" %f1score_matrix[row, col])
print('--------------------------')
# Creating a result path to save the results.
path = os.getcwd()
result_path = path + '/NEUROCHAOS-RESULTS/' + classification_type + '/CROSS_VALIDATION/'
try:
os.makedirs(result_path)
except OSError:
print("Creation of the result directory %s failed" % result_path)
else:
print("Successfully created the result directory %s" % result_path)
print("Saving Hyperparameter Tuning Results")
np.save(result_path + 'H_ACCURACY.npy', accuracy_matrix)
np.save(result_path + 'H_FSCORE.npy', f1score_matrix)
np.save(result_path + 'H_INITIAL_CONDITION.npy', q_matrix)
np.save(result_path + 'H_THRESHOLD.npy', b_matrix)
np.save(result_path + 'H_EPS.npy', epsilon_matrix)
# =============================================================================
# best hyperparameters
# =============================================================================
# Computing the maximum F1-score obtained during crossvalidation.
maximum_fscore = np.max(f1score_matrix)
best_initial_neural_activity = []
best_discrimination_threshold = []
best_epsilon = []
for row in range(0, f1score_matrix.shape[0]):
for col in range(0, f1score_matrix.shape[1]):
if f1score_matrix[row, col] == np.max(f1score_matrix):
best_initial_neural_activity.append(q_matrix[row, col])
best_discrimination_threshold.append(b_matrix[row, col])
best_epsilon.append(epsilon_matrix[row, col])
print("maximum f1score_neurochaos = ", maximum_fscore)
print("best initial neural activity = ", best_initial_neural_activity)
print("best discrimination threshold = ", best_discrimination_threshold)
print("best epsilon = ", best_epsilon)
return best_initial_neural_activity, best_discrimination_threshold, best_epsilon
def low_training_sample_five_class(classification_type, trials, max_samples, initial_neural_activity, discrimination_threshold, epsilon):
"""
This is the function module for the low training sample regime for five class
classification dataset. To add more classes or reduce the number of classes,
the user has to modify this function file.
Parameters
----------
classification_type : string
DESCRIPTION - This code is only for five class classification,
classification_type= "multi_class"
trials : int
DESCRIPTION - The number of random trials of training. For eg. if trials = 20, we do
20 random trails of training and find the macro averged f1-score of the test data for the 20 ransod trials.
max_sample : int
DESCRIPTION - The upper limit on the number of samples per class for training. For eg., if
max_samples = 6, means the maximum number of samples per class used for training is 6.
initial_neural_activity : scalar, float
DESCRIPTION - The chaotic neurons has an initial neural activity.
Initial neural activity is a value in the range 0 and 1.
discrimination_threshold : scalar, float
DESCRIPTION - The chaotic neurons has a discrimination threhold.
discrimination threshold is a value in the range 0 and 1.
epsilon : scalar, float
DESCRIPTION - A value in the range 0 and 0.3. for eg. epsilon = 0.1835
Returns
-------
fscore_neurochaos : array, 2D, float
DESCRIPTION. - The macro averged f1-score for training with 1, 2.., max_samples per class.
This will provide averaged f1-score for N random trials of training with 1, 2,..., max_samples
per class.
standard_deviation_fscore_neurochaos : array, 2D, flaot
DESCRIPTION - This will provide the standard deviation of averaged f1-score for N random trials of training with 1, 2,..., max_samples
per class.
fscore_svm : array, 2D, float
DESCRIPTION. - The macro averged f1-score for training with 1, 2.., max_samples per class.
This will provide averaged f1-score for N random trials of training with 1, 2,..., max_samples
per class.
standard_deviation_fscore_svm : array, 2D, flaot
DESCRIPTION - This will provide the standard deviation of averaged f1-score for N random trials of training with 1, 2,..., max_samples
per class.
"""
full_genome_data, full_genome_label = get_data(classification_type)
# Indices of class-0 and class-1 data instances
index_0 = np.where(full_genome_label == 0)[0]
index_1 = np.where(full_genome_label == 1)[0]
index_2 = np.where(full_genome_label == 2)[0]
index_3 = np.where(full_genome_label == 3)[0]
index_4 = np.where(full_genome_label == 4)[0]
print("**** TOTAL_DATA ******")
for class_label in range(np.max(full_genome_label)+1):
print("Data instance in Class -", class_label, " = ", full_genome_label.tolist().count([class_label]))
# Neurochaos Feature Extraction
neurochaos_genome_data_0 = CFX.transform(full_genome_data[index_0, :], initial_neural_activity, 20000, epsilon, discrimination_threshold)
neurochaos_genome_data_1 = CFX.transform(full_genome_data[index_1, :], initial_neural_activity, 20000, epsilon, discrimination_threshold)
neurochaos_genome_data_2 = CFX.transform(full_genome_data[index_2, :], initial_neural_activity, 20000, epsilon, discrimination_threshold)
neurochaos_genome_data_3 = CFX.transform(full_genome_data[index_3, :], initial_neural_activity, 20000, epsilon, discrimination_threshold)
neurochaos_genome_data_4 = CFX.transform(full_genome_data[index_4, :], initial_neural_activity, 20000, epsilon, discrimination_threshold)
# Input data (without Neurochaos Feature Extraction)
genome_data_0 = full_genome_data[index_0, :]
genome_data_1 = full_genome_data[index_1, :]
genome_data_2 = full_genome_data[index_2, :]
genome_data_3 = full_genome_data[index_3, :]
genome_data_4 = full_genome_data[index_4, :]
# Number of samples per class. For eg. if max_samples is 4, we compute
# training with 1, 2 3 and 4 samples. Each of these training is done
# with N random trials.
samples_per_class = np.arange(1, max_samples + 1, 1)
# Initialization for Neurochaos
accuracy_neurochaos = np.zeros((len(samples_per_class), 1))
fscore_neurochaos = np.zeros((len(samples_per_class), 1))
standard_deviation_fscore_neurochaos = np.zeros((len(samples_per_class), 1))
# Initialization for SVM
accuracy_svm = np.zeros((len(samples_per_class), 1))
fscore_svm = np.zeros((len(samples_per_class), 1))
standard_deviation_fscore_svm = np.zeros((len(samples_per_class), 1))
for num_instance in samples_per_class:
# Neurochaos array for appending accuracy and f1score
accuracy_neurochaos_list = []
f1score_neurochaos_list = []
# SVM array for appending accuracy and f1score
accuracy_svm_list = []
f1score_svm_list = []
# We do N random trials of training
for trial_number in range(0, trials):
train_neurochaos_genome_data_0, test_neurochaos_genome_data_0, train_neurochaos_genome_label_0, test_neurochaos_genome_label_0 = train_test_split(neurochaos_genome_data_0, full_genome_label[index_0], test_size=1 - (num_instance/neurochaos_genome_data_0.shape[0]), random_state=trial_number)
train_neurochaos_genome_data_1, test_neurochaos_genome_data_1, train_neurochaos_genome_label_1, test_neurochaos_genome_label_1 = train_test_split(neurochaos_genome_data_1, full_genome_label[index_1], test_size=1 - (num_instance/neurochaos_genome_data_1.shape[0]), random_state=trial_number)
train_neurochaos_genome_data_2, test_neurochaos_genome_data_2, train_neurochaos_genome_label_2, test_neurochaos_genome_label_2 = train_test_split(neurochaos_genome_data_2, full_genome_label[index_2], test_size=1 - (num_instance/neurochaos_genome_data_2.shape[0]), random_state=trial_number)
train_neurochaos_genome_data_3, test_neurochaos_genome_data_3, train_neurochaos_genome_label_3, test_neurochaos_genome_label_3 = train_test_split(neurochaos_genome_data_3, full_genome_label[index_3], test_size=1 - (num_instance/neurochaos_genome_data_3.shape[0]), random_state=trial_number)
train_neurochaos_genome_data_4, test_neurochaos_genome_data_4, train_neurochaos_genome_label_4, test_neurochaos_genome_label_4 = train_test_split(neurochaos_genome_data_4, full_genome_label[index_4], test_size=1 - (num_instance/neurochaos_genome_data_4.shape[0]), random_state=trial_number)
train_genome_data_0, test_genome_data_0, train_genome_label_0, test_genome_label_0 = train_test_split(genome_data_0, full_genome_label[index_0], test_size=1 - (num_instance/genome_data_0.shape[0]), random_state=trial_number)
train_genome_data_1, test_genome_data_1, train_genome_label_1, test_genome_label_1 = train_test_split(genome_data_1, full_genome_label[index_1], test_size=1 - (num_instance/genome_data_1.shape[0]), random_state=trial_number)
train_genome_data_2, test_genome_data_2, train_genome_label_2, test_genome_label_2 = train_test_split(genome_data_2, full_genome_label[index_2], test_size=1 - (num_instance/genome_data_2.shape[0]), random_state=trial_number)
train_genome_data_3, test_genome_data_3, train_genome_label_3, test_genome_label_3 = train_test_split(genome_data_3, full_genome_label[index_3], test_size=1 - (num_instance/genome_data_3.shape[0]), random_state=trial_number)
train_genome_data_4, test_genome_data_4, train_genome_label_4, test_genome_label_4 = train_test_split(genome_data_4, full_genome_label[index_4], test_size=1 - (num_instance/genome_data_4.shape[0]), random_state=trial_number)
print("num of samples per class = ", num_instance, "trial number = ", trial_number)
test_neurochaos_genome_data = np.concatenate((test_neurochaos_genome_data_0, test_neurochaos_genome_data_1, test_neurochaos_genome_data_2, test_neurochaos_genome_data_3, test_neurochaos_genome_data_4))
test_neurochaos_genome_label = np.concatenate((test_neurochaos_genome_label_0, test_neurochaos_genome_label_1, test_neurochaos_genome_label_2, test_neurochaos_genome_label_3, test_neurochaos_genome_label_4))
train_neurochaos_genome_data = np.concatenate((train_neurochaos_genome_data_0, train_neurochaos_genome_data_1, train_neurochaos_genome_data_2, train_neurochaos_genome_data_3, train_neurochaos_genome_data_4))
train_neurochaos_genome_label = np.concatenate((train_neurochaos_genome_label_0, train_neurochaos_genome_label_1, train_neurochaos_genome_label_2, train_neurochaos_genome_label_3, train_neurochaos_genome_label_4))
test_genome_data = np.vstack((test_genome_data_0, test_genome_data_1, test_genome_data_2, test_genome_data_3, test_genome_data_4))
test_genome_label = np.vstack((test_genome_label_0, test_genome_label_1, test_genome_label_2, test_genome_label_3, test_genome_label_4))
train_genome_data = np.vstack((train_genome_data_0, train_genome_data_1, train_genome_data_2, train_genome_data_3, train_genome_data_4))
train_genome_label = np.vstack((train_genome_label_0, train_genome_label_1, train_genome_label_2, train_genome_label_3, train_genome_label_4))
# Neurochaos feature extraction followed by SVM classifier
classifier_neurochaos = LinearSVC(random_state=0, tol=1e-5, dual=False)
classifier_neurochaos.fit(train_neurochaos_genome_data, train_neurochaos_genome_label[:, 0])
predicted_labels_neurochaos = classifier_neurochaos.predict(test_neurochaos_genome_data)
accuracy_neurochaos_val = accuracy_score(test_neurochaos_genome_label, predicted_labels_neurochaos)*100
f1score_neurochaos_val = f1_score(test_neurochaos_genome_label, predicted_labels_neurochaos, average="macro")
accuracy_neurochaos_list.append(accuracy_neurochaos_val)
f1score_neurochaos_list.append(f1score_neurochaos_val)
classifier_svm = LinearSVC(random_state=0, tol=1e-5, dual=False)
classifier_svm.fit(train_genome_data, train_genome_label[:, 0])
predicted_labels_svm = classifier_svm.predict(test_genome_data)
accuracy_svm_val = accuracy_score(test_genome_label, predicted_labels_svm)*100
f1score_svm_val = f1_score(test_genome_label, predicted_labels_svm, average="macro")
accuracy_svm_list.append(accuracy_svm_val)
f1score_svm_list.append(f1score_svm_val)
accuracy_neurochaos[num_instance-1, 0] = np.mean(accuracy_neurochaos_list)
fscore_neurochaos[num_instance-1, 0] = np.mean(f1score_neurochaos_list)
standard_deviation_fscore_neurochaos[num_instance-1, 0] = np.std(f1score_neurochaos_list)
accuracy_svm[num_instance-1, 0] = np.mean(accuracy_svm_list)
fscore_svm[num_instance-1, 0] = np.mean(f1score_svm_list)
standard_deviation_fscore_svm[num_instance-1, 0] = np.std(f1score_svm_list)
print("Saving Results")
path = os.getcwd()
result_path = path + '/NEUROCHAOS-LTS-RESULTS/' + classification_type + '/LTS/'
try:
os.makedirs(result_path)
except OSError:
print("Creation of the result directory %s failed" % result_path)
else:
print("Successfully created the result directory %s" % result_path)
np.save(result_path+"/fscore_neurochaos.npy", fscore_neurochaos)
np.save(result_path+"/std_fscore_neurochaos.npy", standard_deviation_fscore_neurochaos)
np.save(result_path+"/samples_per_class.npy", samples_per_class)
np.save(result_path+"/fscore_svm.npy", fscore_svm)
np.save(result_path+"/std_fscore_svm.npy", standard_deviation_fscore_svm)
return fscore_neurochaos, standard_deviation_fscore_neurochaos, fscore_svm, standard_deviation_fscore_svm
def five_fold_validation(classification_type, epsilon, initial_neural_activity, discrimination_threshold, folder_name, target_names):
"""
This module does the five_fold_crossvalidation and saves the classifcation
report. At present the results for binary classification and five class classification is saved.
Author: Harikrishnan N B
Email: [email protected]
Dtd: 2 - August - 2020
Parameters
----------
classification_type : string
DESCRIPTION - classification_type == "binary_class" loads binary classification genome data.
classification_type == "multi_class" loads multiclass genome data
epsilon : scalar, float
DESCRIPTION - A value in the range 0 and 0.3. for eg. epsilon = 0.1835
initial_neural_activity : scalar, float
DESCRIPTION - The chaotic neurons has an initial neural activity.
Initial neural activity is a value in the range 0 and 1.
discrimination_threshold : scalar, float
DESCRIPTION - The chaotic neurons has a discrimination threhold.
discrimination threshold is a value in the range 0 and 1.
folder_name : string
DESCRIPTION - the name of the folder to store results. For eg., if
folder_name = "hnb", then this function will create two folder "hnb-svm"
and "hnb-neurochaos" to save the classification report.
target_names : array, 1D, string
DESCRIPTION - if there are two classes, then target_names = ['class-0', class-1]
Note- At the present version of the code, the results for binary classification
and five class classification will be saved.
Returns
-------
mean_fold_accuracy_neurochaos, mean_fold_fscore_neurochaos, mean_fold_accuracy_svm, mean_fold_fscore_svm
The above are the average accuracy and f1 score for the five fold validation for neurochaos and svm respectively.
"""
path = os.getcwd()
result_path_svm = path + '/NEUROCHAOS-RESULTS/' + classification_type +'/' + folder_name +'-svm/'
result_path_neurochaos = path + '/NEUROCHAOS-RESULTS/' + classification_type + '/' + folder_name +'-neurochaos/'
# Creating Folder to save the results
try:
os.makedirs(result_path_neurochaos)
except OSError:
print("Creation of the result directory %s failed" % result_path_neurochaos)
else:
print("Successfully created the result directory %s" % result_path_neurochaos)
try:
os.makedirs(result_path_svm)
except OSError:
print("Creation of the result directory %s failed" % result_path_svm)
else:
print("Successfully created the result directory %s" % result_path_svm)
full_genome_data, full_genome_label = get_data(classification_type)
num_classes = len(np.unique(full_genome_label)) # Number of classes
print("**** Genome data details ******")
for class_label in range(np.max(full_genome_label)+1):
print("Total Data instance in Class -", class_label, " = ", full_genome_label.tolist().count([class_label]))
# Stratified five fold cross validation.
stratified_k_fold = StratifiedKFold(n_splits=5, random_state=42, shuffle=True) # Define the split - into 5 folds
stratified_k_fold.get_n_splits(full_genome_data, full_genome_label) # returns the number of splitting iterations in the cross-validator
print(stratified_k_fold)
StratifiedKFold(n_splits=5, random_state=42, shuffle=True)
iterations = 0
acc_temp_neurochaos = []
fscore_temp_neurochaos = []
acc_temp_svm = []
fscore_temp_svm = []
for train_index, val_index in stratified_k_fold.split(full_genome_data, full_genome_label):
iterations = iterations+1
print("iterations = ", iterations)
# Spliting into training and validation
train_genome_data, val_genome_data = full_genome_data[train_index], full_genome_data[val_index]
train_genome_label, val_genome_label = full_genome_label[train_index], full_genome_label[val_index]
print(" train data (%) = ", (train_genome_data.shape[0]/full_genome_data.shape[0])*100)
print("val data (%) = ", (val_genome_data.shape[0]/full_genome_data.shape[0])*100)
print("initial neural activity = ", initial_neural_activity, "discrimination threshold = ", discrimination_threshold, "epsilon = ", epsilon)
# Extracting Neurochaos features from the data
neurochaos_train_data_features = CFX.transform(train_genome_data, initial_neural_activity, 20000, epsilon, discrimination_threshold)
neurochaos_val_data_features = CFX.transform(val_genome_data, initial_neural_activity, 20000, epsilon, discrimination_threshold)
# Start of Neurochaos classifier
neurochaos_classifier = LinearSVC(random_state=0, tol=1e-5, dual=False)
neurochaos_classifier.fit(neurochaos_train_data_features, train_genome_label[:, 0])
predicted_neurochaos_val_label = neurochaos_classifier.predict(neurochaos_val_data_features)
acc_neurochaos = accuracy_score(val_genome_label, predicted_neurochaos_val_label)*100
f1score_neurochaos = f1_score(val_genome_label, predicted_neurochaos_val_label, average="macro")
report_neurochaos = classification_report(val_genome_label, predicted_neurochaos_val_label, target_names=target_names)
# Saving the classification report to csv file for neurochaos classifier.
print(report_neurochaos)
if num_classes == 2:
classification_report_csv_(report_neurochaos, num_classes).to_csv(result_path_neurochaos+'neurochaos_report_'+ str(iterations) +'.csv', index=False)
elif num_classes == 5:
classification_report_csv_(report_neurochaos, num_classes).to_csv(result_path_neurochaos+'neurochaos_report_'+ str(iterations) +'.csv', index=False)
else:
print("could not save classfication results-the current code saves the result of 2 class and 5 class problems")
confusion_matrix_neurochaos = cm(val_genome_label, predicted_neurochaos_val_label)
print("Confusion matrixfor Neurochaos\n", confusion_matrix_neurochaos)
acc_temp_neurochaos.append(acc_neurochaos)
fscore_temp_neurochaos.append(f1score_neurochaos)
# End of Neurochaos classifier.
# Start of SVM classifier
svm_classifier = LinearSVC(random_state=0, tol=1e-5, dual=False)
svm_classifier.fit(train_genome_data, train_genome_label[:, 0])
predicted_svm_val_label = svm_classifier.predict(val_genome_data)
acc_svm = accuracy_score(val_genome_label, predicted_svm_val_label)*100
f1score_svm = f1_score(val_genome_label, predicted_svm_val_label, average="macro")
report_svm = classification_report(val_genome_label, predicted_svm_val_label, target_names=target_names)
# Saving the classification report to csv file for svm classifier
print(report_svm)
if num_classes == 2:
classification_report_csv_(report_svm, num_classes).to_csv(result_path_svm+'report_svm_'+ str(iterations) +'.csv', index=False)
elif num_classes == 5:
classification_report_csv_(report_svm, num_classes).to_csv(result_path_svm+'report_svm_'+ str(iterations) +'.csv', index=False)
else:
print("could not save classfication results-the current code saves the result of 2 class and 5 class problems")
confusion_matrix_svm = cm(val_genome_label, predicted_svm_val_label)
print("Confusion matrix for SVM\n", confusion_matrix_svm)
acc_temp_svm.append(acc_svm)
fscore_temp_svm.append(f1score_svm)
# End of SVM classifier
mean_fold_accuracy_svm = np.mean(acc_temp_svm)
mean_fold_fscore_svm = np.mean(fscore_temp_svm)
mean_fold_accuracy_neurochaos = np.mean(acc_temp_neurochaos)
mean_fold_fscore_neurochaos = np.mean(fscore_temp_neurochaos)
np.save(result_path_neurochaos + 'initial_neural_activity.npy', initial_neural_activity)
np.save(result_path_neurochaos + 'discrimination_threshold.npy', discrimination_threshold)
np.save(result_path_neurochaos + 'EPS.npy', epsilon)
return mean_fold_accuracy_neurochaos, mean_fold_fscore_neurochaos, mean_fold_accuracy_svm, mean_fold_fscore_svm
print("**** Genome data details ******")
for class_label in range(np.max(full_artificial_label) + 1):
print("Total Data instance in Class -", class_label, " = ",
full_artificial_label.tolist().count([class_label]))
print(" train data = ", (full_artificial_data.shape[0]))
print("val data = ", (full_artificial_test_data.shape[0]))
print("initial neural activity = ", initial_neural_activity,
"discrimination threshold = ", discrimination_threshold,
"epsilon = ", epsilon)
# Extracting Neurochaos features from the data
neurochaos_train_data_features = CFX.transform(full_artificial_data,
initial_neural_activity, 20000,
epsilon,
discrimination_threshold)
neurochaos_val_data_features = CFX.transform(full_artificial_test_data,
initial_neural_activity, 20000,
epsilon, discrimination_threshold)
# Start of Neurochaos classifier
neurochaos_classifier = LinearSVC(random_state=0, tol=1e-5, dual=False)
neurochaos_classifier.fit(neurochaos_train_data_features[:, 4:6],
full_artificial_label[:, 0])
predicted_neurochaos_val_label = neurochaos_classifier.predict(
neurochaos_val_data_features[:, 4:6])
acc_neurochaos = accuracy_score(full_artificial_test_label,
predicted_neurochaos_val_label) * 100
for INA in INITIAL_NEURAL_ACTIVITY:
COL = COL + 1
WIDTH = -1
for EPSILON_1 in EPSILON:
WIDTH = WIDTH + 1
ACC_TEMP = []
FSCORE_TEMP = []
for TRAIN_INDEX, VAL_INDEX in KF.split(TRAINDATA):
X_TRAIN, X_VAL = TRAINDATA[TRAIN_INDEX], TRAINDATA[VAL_INDEX]
Y_TRAIN, Y_VAL = TRAINLABEL[TRAIN_INDEX], TRAINLABEL[VAL_INDEX]
# Extract features
FEATURE_MATRIX_TRAIN = CFX.transform(X_TRAIN, INA, 10000,
EPSILON_1, DT)
FEATURE_MATRIX_VAL = CFX.transform(X_VAL, INA, 10000,
EPSILON_1, DT)
CLASSIFIER = LinearSVC(random_state=0, tol=1e-5, dual=False)
CLASSIFIER.fit(FEATURE_MATRIX_TRAIN, Y_TRAIN[:, 0])
Y_PRED = CLASSIFIER.predict(FEATURE_MATRIX_VAL)
ACC = accuracy_score(Y_VAL, Y_PRED) * 100
RECALL = recall_score(Y_VAL, Y_PRED, average="macro")
PRECISION = precision_score(Y_VAL, Y_PRED, average="macro")
F1SCORE = f1_score(Y_VAL, Y_PRED, average="macro")
'''
print("ACCURACY")
print("%.3f" %ACC)
num_classes = len(np.unique(ccd_test_label)) # Number of classes
print("**** Genome data details ******")
for class_label in range(np.max(ccd_train_label) + 1):
print("Total Data instance in Class -", class_label, " = ",
ccd_train_label.tolist().count([class_label]))
print(" train data = ", (occd_train_data.shape[0]))
print("test data = ", (ccd_train_data.shape[0]))
print("initial neural activity = ", initial_neural_activity,
"discrimination threshold = ", discrimination_threshold,
"epsilon = ", epsilon)
# Extracting Neurochaos features from the data
neurochaos_train_data_features = CFX.transform(occd_train_data,
initial_neural_activity, 20000,
epsilon,
discrimination_threshold)
neurochaos_val_data_features = CFX.transform(ccd_train_data,
initial_neural_activity, 20000,
epsilon, discrimination_threshold)
# Start of Neurochaos classifier
neurochaos_classifier = LinearSVC(random_state=0, tol=1e-5, dual=False)
neurochaos_classifier.fit(neurochaos_train_data_features, occd_train_label[:,
0])
predicted_neurochaos_val_label = neurochaos_classifier.predict(
neurochaos_val_data_features)
acc_neurochaos = accuracy_score(ccd_train_label,
predicted_neurochaos_val_label) * 100
plt.xlim(-0.1, length + 20)
plt.plot(firingtime,
trajectory,
'-*k',
alpha=0.9,
linewidth=1.5,
label='neural response')
# plt.plot(firingtime, NOISE_LEVEL, 'b', alpha=0.9, label=NOISE_TYPE)
plt.plot([205, 210, 215], [0.5, 0.5, 0.5], 'ok', markersize=8)
plt.grid()
plt.legend(fontsize=20)
plt.tight_layout()
plt.savefig(NOISE_TYPE + ".jpg", format='jpg', dpi=150)
plt.show()
else:
FEATURE_MATRIX_TRAIN = CFX.transform(X_TRAIN, init_cond, length, EPSILON,
threshold)
A = (np.abs((X_TRAIN[0, 0]) - trajectory) < EPSILON)
sub_trajectory[0:np.int(A.tolist().index(True) + 1),
0] = trajectory[0:np.int(A.tolist().index(True) + 1)]
NOISE_LEVEL = []
for rand_length in range(0, length):
NOISE_LEVEL.append(
np.random.uniform((X_TRAIN[0, 0] - EPSILON),
(X_TRAIN[0, 0] + EPSILON)))
plt.figure(figsize=(12, 12))
plt.axhline(y=X_TRAIN[0, 0], color='r', linestyle='-', label='stimulus')
plt.axhline(y=X_TRAIN[0, 0] - EPSILON,
color='b',
