def save_fig(sel, out_name): # Save ROC and Classification 2D figure (acc, sens, spec, auc) = eval_performance( sel.label_all, sel.prediction, sel.decision, sel.accuracy, sel.sensitivity, sel.specificity, sel.AUC, verbose=0, is_showfig=1, legend1='HC', legend2='SZ', is_savefig=1, out_name=out_name )
def main_function(self, i, label_all_perm, feature_all): """The training data, validation data and test data are randomly splited """ print(f"Permutaion {i}...\n") # KFold Cross Validation accuracy, sensitivity, specificity, AUC = np.array([]), np.array( []), np.array([]), np.array([]) kf = KFold(n_splits=self.cv, shuffle=True, random_state=0) for i, (tr_ind, te_ind) in enumerate(kf.split(feature_all)): feature_train = feature_all[tr_ind, :] label_train = label_all_perm[tr_ind] feature_test = feature_all[te_ind, :] label_test = label_all_perm[te_ind] # normalization prep = el_preprocessing.Preprocessing( data_preprocess_method='StandardScaler', data_preprocess_level='group') feature_train, feature_test = prep.data_preprocess( feature_train, feature_test) # dimension reduction if self.is_dim_reduction: feature_train, feature_test, model_dim_reduction = el_dimreduction.pca_apply( feature_train, feature_test, self.components) # train model = self.training(feature_train, label_train) # test pred, dec = self.testing(model, feature_test) # Evaluating classification performances acc, sens, spec, auc = eval_performance(label_test, pred, dec, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=0, is_showfig=0) accuracy = np.append(accuracy, acc) sensitivity = np.append(sensitivity, sens) specificity = np.append(specificity, spec) AUC = np.append(AUC, auc) # return np.mean(accuracy),np.mean(sensitivity), np.mean(specificity), np.mean(AUC) return accuracy, sensitivity, specificity, AUC
def save_fig(self): # Save ROC and Classification 2D figure acc, sens, spec, auc = eval_performance( self.label_test_all, self.prediction, self.decision, self.accuracy, self.sensitivity, self.specificity, self.AUC, verbose=0, is_showfig=self.is_showfig_finally, is_savefig=1, out_name=os.path.join(self.path_out, 'Classification_performances.pdf'))
def save_fig(selftest, label_validation, prediction, decision, accuracy, sensitivity, specificity, AUC, outname): # Save ROC and Classification 2D figure acc, sens, spec, auc = eval_performance(label_validation, prediction, decision, accuracy, sensitivity, specificity, AUC, verbose=0, is_showfig=1, is_savefig=1, out_name=os.path.join( path_out, outname), legend1='Healthy', legend2='Unhealthy')
def save_fig(selftest): # Save ROC and Classification 2D figure acc, sens, spec, auc = eval_performance( selftest.label_test, selftest.prediction, selftest.decision, selftest.accuracy, selftest.sensitivity, selftest.specificity, selftest.AUC, verbose=0, is_showfig=selftest.is_showfig_finally, is_savefig=1, out_name=os.path.join(selftest.path_out, 'Classification_performances_test.pdf'), legend1='Healthy', legend2='Unhealthy')
def main_svc_rfe_cv(sel): print('Training model and testing...\n') # Load data uid_550, feature_550, label_550 = sel._load_data(sel.dataset_our_center_550) uid_206, feature_206, label_206 = sel._load_data(sel.dataset_206) uid_COBRE, feature_COBRE, label_COBRE = sel._load_data(sel.data_COBRE) uid_UCAL, feature_UCAL, label_UCAL = sel._load_data(sel.data_UCAL) uid_all = np.concatenate([uid_550, uid_206, uid_COBRE, uid_UCAL]) feature_all = [feature_550, feature_206, feature_COBRE, feature_UCAL] sel.label_all = [label_550, label_206, label_COBRE, label_UCAL] name = ['550','206','COBRE','UCLA'] # Leave one site CV n_site = len(sel.label_all) test_index = np.array([], dtype=np.int16) sel.decision = np.array([], dtype=np.int16) sel.prediction = np.array([], dtype=np.int16) sel.accuracy = np.array([], dtype=np.float16) sel.sensitivity = np.array([], dtype=np.float16) sel.specificity = np.array([], dtype=np.float16) sel.AUC = np.array([], dtype=np.float16) sel.coef = [] for i in range(n_site): print('-'*40) print(f'{i+1}/{n_site}: test dataset is {name[i]}...') feature_train, label_train = feature_all.copy(), sel.label_all.copy() feature_test, label_test = feature_train.pop(i), label_train.pop(i) feature_train = np.concatenate(feature_train, axis=0) label_train = np.concatenate(label_train, axis=0) # Resampling training data # feature_train, label_train = sel.re_sampling(feature_train, label_train) # Normalization prep = el_preprocessing.Preprocessing(data_preprocess_method='StandardScaler', data_preprocess_level='subject') feature_train, feature_test = prep.data_preprocess(feature_train, feature_test) # Dimension reduction if sel.is_dim_reduction: feature_train, feature_test, model_dim_reduction = el_dimreduction.pca_apply( feature_train, feature_test, sel.components ) print(f'After dimension reduction, the feature number is {feature_train.shape[1]}') else: print('No dimension reduction perfromed\n') # Train and test print('training and testing...\n') model = sel.training(feature_train, label_train, sel.cv) if sel.is_dim_reduction: sel.coef.append(model_dim_reduction.inverse_transform(model.coef_)) # save coef else: sel.coef.append(clf.coef_) # save coef pred, dec = sel.testing(model, feature_test) sel.prediction = np.append(sel.prediction, np.array(pred)) sel.decision = np.append(sel.decision, np.array(dec)) # Evaluating classification performances acc, sens, spec, auc = eval_performance(label_test, pred, dec, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=0) sel.accuracy = np.append(sel.accuracy, acc) sel.sensitivity = np.append(sel.sensitivity, sens) sel.specificity = np.append(sel.specificity, spec) sel.AUC = np.append(sel.AUC, auc) print(f'performances = {acc, sens, spec,auc}') sel.label_all = np.concatenate(sel.label_all) sel.special_result = np.concatenate( [uid_all, sel.label_all, sel.decision, sel.prediction], axis=0).reshape(4, -1).T return sel
def main_function(self): """ This function is the main function. """ # Load data and mask data_all, label_all, self.orig_shape, self.mask_obj, self.mask_all = self._load_nii_and_gen_label( ) # KFold Cross Validation self.label_test_all = np.array([], dtype=np.int16) train_index = np.array([], dtype=np.int16) test_index = np.array([], dtype=np.int16) self.decision = np.array([], dtype=np.int16) self.prediction = np.array([], dtype=np.int16) self.accuracy = np.array([], dtype=np.float16) self.sensitivity = np.array([], dtype=np.float16) self.specificity = np.array([], dtype=np.float16) self.AUC = np.array([], dtype=np.float16) self.coef = [] kf = KFold(n_splits=self.num_of_fold_outer, shuffle=True, random_state=0) for i, (tr_ind, te_ind) in enumerate(kf.split(data_all)): print(f'------{i+1}/{self.num_of_fold_outer}...------\n') train_index = np.int16(np.append(train_index, tr_ind)) test_index = np.int16(np.append(test_index, te_ind)) feature_train = data_all[tr_ind, :] label_train = label_all[tr_ind] feature_test = data_all[te_ind, :] label_test = label_all[te_ind] self.label_test_all = np.int16( np.append(self.label_test_all, label_test)) # Resampling training data feature_train, label_train = self.re_sampling( feature_train, label_train) # data_preprocess prep = elprep.Preprocessing(self.data_preprocess_method, self.data_preprocess_level) feature_train, feature_test = prep.data_preprocess( feature_train, feature_test) # dimension reduction using univariate feature selection # feature_train, feature_test, mask_selected = self.dimReduction_filter( # feature_train, label_train, feature_test, 0.05) # Dimension reduction using PCA if self.is_dim_reduction: feature_train, feature_test, model_dim_reduction = self.dimReduction_PCA( feature_train, feature_test, self.components) print( f'After dimension reduction, the feature number is {feature_train.shape[1]}' ) else: print('No dimension reduction perfromed\n') print(f'The feature number is {feature_train.shape[1]}') # Train: inner feature selection using RFECV print('Training...\n') model, weight = self.rfeCV_training(feature_train, label_train, self.step, self.num_fold_of_inner_rfeCV, self.n_jobs) if self.is_dim_reduction: self.coef.append(model_dim_reduction.inverse_transform(weight)) else: self.coef.append(weight) # Testting print('Testting...\n') pred, dec = self.testing(model, feature_test) self.prediction = np.append(self.prediction, np.array(pred)) self.decision = np.append(self.decision, np.array(dec)) # Evaluating classification performances acc, sens, spec, auc = eval_performance( label_test, pred, dec, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=self.is_showfig_in_each_fold) self.accuracy = np.append(self.accuracy, acc) self.sensitivity = np.append(self.sensitivity, sens) self.specificity = np.append(self.specificity, spec) self.AUC = np.append(self.AUC, auc) # Save results and fig to local path self.save_results() self._weight2nii(dimension_nii_data=(61, 73, 61)) self.save_fig() print("--" * 10 + "Done!" + "--" * 10) return self
def main_function(self): """ """ print('Training model and testing...\n') # load data and mask data_all, label_all, self.orig_shape, self.mask_obj, self.mask_all = self._load_nii_and_gen_label( ) # KFold Cross Validation self.label_test_all = np.array([], dtype=np.int16) train_index = np.array([], dtype=np.int16) test_index = np.array([], dtype=np.int16) self.decision = np.array([], dtype=np.int16) self.prediction = np.array([], dtype=np.int16) self.accuracy = np.array([], dtype=np.float16) self.sensitivity = np.array([], dtype=np.float16) self.specificity = np.array([], dtype=np.float16) self.AUC = np.array([], dtype=np.float16) self.coef = [] kf = KFold(n_splits=self.num_of_kfold, shuffle=True, random_state=0) for i, (tr_ind, te_ind) in enumerate(kf.split(data_all)): print(f'------{i+1}/{self.num_of_kfold}...------\n') train_index = np.int16(np.append(train_index, tr_ind)) test_index = np.int16(np.append(test_index, te_ind)) feature_train = data_all[tr_ind, :] label_train = label_all[tr_ind] feature_test = data_all[te_ind, :] label_test = label_all[te_ind] self.label_test_all = np.int16( np.append(self.label_test_all, label_test)) # Resampling training data feature_train, label_train = self.re_sampling( feature_train, label_train) # data_preprocess feature_train, feature_test = elprep.Preprocessing( ).data_preprocess(feature_train, feature_test, self.data_preprocess_method, self.data_preprocess_level) # Dimension reduction using PCA if self.is_dim_reduction: feature_train, feature_test, model_dim_reduction = self.dimReduction_PCA( feature_train, feature_test, self.components) print( f'After dimension reduction, the feature number is {feature_train.shape[1]}' ) else: print('No dimension reduction perfromed\n') print(f'The feature number is {feature_train.shape[1]}') # Feature selection if self.is_feature_selection: feature_train, feature_test, mask, n_features_origin = self.feature_selection_relief( feature_train, label_train, feature_test, self.n_features_to_select) # Train and test print('training and testing...\n') model = self.training(feature_train, label_train) # Get weight if self.is_feature_selection: coef = np.zeros([ n_features_origin, ]) coef[mask] = model.coef_ else: coef = model.coef_ if self.is_dim_reduction: self.coef.append(model_dim_reduction.inverse_transform(coef)) else: self.coef.append(coef) pred, dec = self.testing(model, feature_test) self.prediction = np.append(self.prediction, np.array(pred)) self.decision = np.append(self.decision, np.array(dec)) # Evaluating classification performances acc, sens, spec, auc = eval_performance( label_test, pred, dec, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=self.is_showfig_in_each_fold) self.accuracy = np.append(self.accuracy, acc) self.sensitivity = np.append(self.sensitivity, sens) self.specificity = np.append(self.specificity, spec) self.AUC = np.append(self.AUC, auc) # Save results and fig to local path self.save_results() self._weight2nii(dimension_nii_data=(61, 73, 61)) self.save_fig() print("--" * 10 + "Done!" + "--" * 10) return self
def main_function(sel): """ The training data, validation data and test data are randomly splited """ print('Training model and testing...\n') # load data dataset_our_center_550 = np.load(sel.dataset_our_center_550) dataset_206 = np.load(sel.dataset_206) dataset_COBRE = np.load(sel.dataset_COBRE) dataset_UCAL = np.load(sel.dataset_UCAL) # Extracting features and label features_our_center_550 = dataset_our_center_550[:, 2:] features_206 = dataset_206[:, 2:] features_COBRE = dataset_COBRE[:, 2:] features_UCAL = dataset_UCAL[:, 2:] label_our_center_550 = dataset_our_center_550[:, 1] label_206 = dataset_206[:, 1] label_COBRE = dataset_COBRE[:, 1] label_UCAL = dataset_UCAL[:, 1] # Generate training data and test data data_all = np.concatenate( [features_our_center_550, features_206, features_UCAL, features_COBRE], axis=0) label_all = np.concatenate( [label_our_center_550, label_206, label_UCAL, label_COBRE], axis=0) # Unique ID uid_our_center_550 = np.int32(dataset_our_center_550[:, 0]) uid_206 = np.int32(dataset_206[:, 0]) uid_all = np.concatenate([uid_our_center_550, uid_206, np.zeros(len(label_UCAL, )) -1, np.zeros(len(label_COBRE, )) -1], axis=0) uid_all = np.int32(uid_all) # KFold Cross Validation sel.label_test_all = np.array([], dtype=np.int16) train_index = np.array([], dtype=np.int16) test_index = np.array([], dtype=np.int16) sel.decision = np.array([], dtype=np.int16) sel.prediction = np.array([], dtype=np.int16) sel.accuracy = np.array([], dtype=np.float16) sel.sensitivity = np.array([], dtype=np.float16) sel.specificity = np.array([], dtype=np.float16) sel.AUC = np.array([], dtype=np.float16) sel.coef = [] kf = KFold(n_splits=sel.cv, shuffle=True, random_state=0) for i, (tr_ind, te_ind) in enumerate(kf.split(data_all)): print(f'------{i+1}/{sel.cv}...------\n') train_index = np.int16(np.append(train_index, tr_ind)) test_index = np.int16(np.append(test_index, te_ind)) feature_train = data_all[tr_ind, :] label_train = label_all[tr_ind] feature_test = data_all[te_ind, :] label_test = label_all[te_ind] sel.label_test_all = np.int16(np.append(sel.label_test_all, label_test)) # resampling training data # feature_train, label_train = sel.re_sampling(feature_train, label_train) # normalization prep = elprep.Preprocessing(data_preprocess_method='StandardScaler', data_preprocess_level='subject') feature_train, feature_test = prep.data_preprocess(feature_train, feature_test) # dimension reduction if sel.is_dim_reduction: feature_train, feature_test, model_dim_reduction = sel.dimReduction( feature_train, feature_test, sel.components) print(f'After dimension reduction, the feature number is {feature_train.shape[1]}') else: print('No dimension reduction perfromed\n') # train print('training and testing...\n') # model, weight = rfeCV(feature_train, label_train, step=0.2, cv=3, n_jobs=-1, permutation=0) model = sel.training(feature_train, label_train) coef = model.coef_ # coef = weight # Weight if sel.is_dim_reduction: sel.coef.append(model_dim_reduction.inverse_transform(coef)) # save coef else: sel.coef.append(coef) # save coef # test pred, dec = sel.testing(model, feature_test) sel.prediction = np.append(sel.prediction, np.array(pred)) sel.decision = np.append(sel.decision, np.array(dec)) # Evaluating classification performances acc, sens, spec, auc = eval_performance(label_test, pred, dec, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=0) sel.accuracy = np.append(sel.accuracy, acc) sel.sensitivity = np.append(sel.sensitivity, sens) sel.specificity = np.append(sel.specificity, spec) sel.AUC = np.append(sel.AUC, auc) uid_all_sorted = np.int32(uid_all[test_index]) sel.special_result = np.concatenate( [uid_all_sorted, sel.label_test_all, sel.decision, sel.prediction], axis=0).reshape(4, -1).T print('Done!') return sel
def main_function(sel): """ The training data, validation data and test data are randomly splited """ print('training model and testing...\n') # load data data = np.load(sel.data ) # Extracting features and label features_our_center_550 = data [:,2:] label_our_center_550 = data [:,1] # Generate training data and test data data_all = features_our_center_550 label_all = label_our_center_550 # Unique ID # KFold Cross Validation sel.label_test_all = np.array([], dtype=np.int16) train_index = np.array([], dtype=np.int16) test_index = np.array([], dtype=np.int16) sel.decision = np.array([], dtype=np.int16) sel.prediction = np.array([], dtype=np.int16) sel.accuracy = np.array([], dtype=np.float16) sel.sensitivity = np.array([], dtype=np.float16) sel.specificity = np.array([], dtype=np.float16) sel.AUC = np.array([], dtype=np.float16) sel.coef = [] kf = KFold(n_splits=sel.cv, shuffle=True, random_state=0) for i, (tr_ind , te_ind) in enumerate(kf.split(data_all)): print(f'------{i+1}/{sel.cv}...------\n') train_index = np.int16(np.append(train_index, tr_ind)) test_index = np.int16(np.append(test_index, te_ind)) feature_train = data_all[tr_ind,:] label_train = label_all[tr_ind] feature_test = data_all[te_ind,:] label_test = label_all[te_ind] sel.label_test_all = np.int16(np.append(sel.label_test_all, label_test)) # resampling training data # feature_train, label_train = sel.re_sampling(feature_train, label_train) # normalization prep = elprep.Preprocessing(data_preprocess_method='StandardScaler', data_preprocess_level='subject') feature_train, feature_test = prep.data_preprocess(feature_train, feature_test) # dimension reduction if sel.is_dim_reduction: feature_train,feature_test, model_dim_reduction= sel.dimReduction(feature_train, feature_test, sel.components) print(f'After dimension reduction, the feature number is {feature_train.shape[1]}') else: print('No dimension reduction perfromed\n') # train and test print('training and testing...\n') model = sel.training(feature_train,label_train) weight = model.coef_ if sel.is_dim_reduction: sel.coef.append(model_dim_reduction.inverse_transform(weight)) # save coef else: sel.coef.append(weight) # save coef pred, dec = sel.testing(model,feature_test) sel.prediction = np.append(sel.prediction, np.array(pred)) sel.decision = np.append(sel.decision, np.array(dec)) # Evaluating classification performances acc, sens, spec, auc = eval_performance(label_test, pred, dec, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=0) sel.accuracy = np.append(sel.accuracy,acc) sel.sensitivity = np.append(sel.sensitivity,sens) sel.specificity = np.append(sel.specificity,spec) sel.AUC = np.append(sel.AUC,auc) sel.special_result = np.concatenate([sel.label_test_all, sel.decision, sel.prediction], axis=0).reshape(3, -1).T print('Done!') return sel
data_chronic_medicated_SSD_550_18_figure3) acc_firstepisode_medicated_SSD_550_18_figure3 = np.sum( data_firstepisode_medicated_SSD_550_18_figure3[1] - data_firstepisode_medicated_SSD_550_18_figure3[3] == 0) / len( data_firstepisode_medicated_SSD_550_18_figure3) acc_first_episode_unmedicated_SSD_550_18_figure3 = np.sum( data_firstepisode_unmedicated_SSD_550_18_figure3[1] - data_firstepisode_unmedicated_SSD_550_18_figure3[3] == 0) / len( data_firstepisode_unmedicated_SSD_550_18_figure3) accuracy_figure3, sensitivity_figure3, specificity_figure3, auc_figure3 = eval_performance( scale_550_selected_figure3[1].values, scale_550_selected_figure3[3].values, scale_550_selected_figure3[2].values, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=True, is_showfig=False, legend1='HC', legend2='Patients', is_savefig=False, out_name=None) #%% Statistics # figure3 n = len(data_chronic_medicated_SSD_550_18_figure3) acc = acc_chronic_medicated_SSD_550_18_figure3 k = np.int32(n * acc) p, sum_prob, prob, randk = lc_binomialtest(n, k, 0.5, 0.5) print(p) n = len(data_firstepisode_medicated_SSD_550_18_figure3)
def main_function(selftest): """ """ print('Training model and testing...\n') # load data feature_train, feature_validation, label_train, label_validation, colname = selftest._load_data( ) n_features_orig = feature_train.shape[1] # Check data # Age encoding feature_train[:, 2] = selftest.age_encodeing(feature_train[:, 2], feature_train[:, 2]) feature_validation[:, 2] = selftest.age_encodeing( feature_train[:, 2], feature_validation[:, 2]) # Data normalization: do not need, because all variables are discrete variables. # Feature selection: LassoCV if selftest.is_feature_selection: coef, mask_lassocv = selftest.feature_selection_lasso( feature_train, label_train) feature_train, feature_validation = feature_train[:, mask_lassocv], feature_validation[:, mask_lassocv] var_important = pd.DataFrame(np.array(colname)[mask_lassocv]) var_important_coef = pd.concat( [var_important, pd.DataFrame(coef[coef != 0])], axis=1) var_important_coef.columns = ['变量', '系数(lasso); 正系数为危险因素,负系数为保护因素'] var_important_coef.to_csv(os.path.join(selftest.path_out, 'important_variables.txt'), index=False) # Onehot encoding # onehot = OneHotEncoder() # onehot.fit(feature_train) # feature_train = onehot.transform(feature_train).toarray() # feature_validation= onehot.transform(feature_validation).toarray() # Train print('training and testing...\n') if selftest.is_feature_selection: model = selftest.training(feature_train, label_train) else: model, w = selftest.rfeCV(feature_train, label_train) # Save model with open(os.path.join(selftest.path_out, 'model_classification.pkl'), 'wb') as f_model: joblib.dump(model, f_model) # Validating prediction_train, decision_train = selftest.testing( model, feature_train) prediction_validation, decision_validation = selftest.testing( model, feature_validation) # Evaluating classification performances accuracy_train, sensitivity_train, specificity_train, AUC_train = eval_performance( label_train, prediction_train, decision_train, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=0) accuracy_validation, sensitivity_validation, specificity_validation, AUC_validation = eval_performance( label_validation, prediction_validation, decision_validation, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=0) # Save results and fig to local path selftest.save_results(accuracy_train, sensitivity_train, specificity_train, AUC_train, decision_train, prediction_train, label_train, 'train') selftest.save_results(accuracy_validation, sensitivity_validation, specificity_validation, AUC_validation, decision_validation, prediction_validation, label_validation, 'validation') selftest.save_fig(label_train, prediction_train, decision_train, accuracy_train, sensitivity_train, specificity_train, AUC_train, 'classification_performances_train.pdf') selftest.save_fig(label_validation, prediction_validation, decision_validation, accuracy_validation, sensitivity_validation, specificity_validation, AUC_validation, 'classification_performances_validation.pdf') print( f"MSE = {np.mean(np.power((decision_validation - label_validation), 2))}" ) print("--" * 10 + "Done!" + "--" * 10) return selftest
def main_function(selftest): """ """ print('Training model and testing...\n') # load data and mask mask_lassocv = joblib.load( os.path.join(selftest.path_out, 'mask_selected_features_lassocv.pkl')) model_feature_selection = joblib.load( os.path.join(selftest.models_path, 'model_feature_selection.pkl')) model_classification = joblib.load( os.path.join(selftest.models_path, 'model_classification.pkl')) feature_test, selftest.label_test, feature_train = selftest._load_data( ) # Age encoding feature_test[:, 2] = ClassifyFourKindOfPersonTrain().age_encodeing( feature_train[:, 2], feature_test[:, 2]) # Feature selection if selftest.is_feature_selection: feature_test = feature_test[:, mask_lassocv != 0] # Testting selftest.prediction, selftest.decision = selftest.testing( model_classification, feature_test) # Evaluating classification performances selftest.accuracy, selftest.sensitivity, selftest.specificity, selftest.AUC = eval_performance( selftest.label_test, selftest.prediction, selftest.decision, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=1, is_showfig=0) # Save results and fig to local path selftest.save_results() selftest.save_fig() print("--" * 10 + "Done!" + "--" * 10) return selftest
data_chronic_medicated_SSD_550_18_pca70) acc_firstepisode_medicated_SSD_550_18_pca70 = np.sum( data_firstepisode_medicated_SSD_550_18_pca70[1] - data_firstepisode_medicated_SSD_550_18_pca70[3] == 0) / len( data_firstepisode_medicated_SSD_550_18_pca70) acc_first_episode_unmedicated_SSD_550_18_pca70 = np.sum( data_firstepisode_unmedicated_SSD_550_18_pca70[1] - data_firstepisode_unmedicated_SSD_550_18_pca70[3] == 0) / len( data_firstepisode_unmedicated_SSD_550_18_pca70) accuracy_pca70, sensitivity_pca70, specificity_pca70, auc_pca70 = eval_performance( scale_550_selected_pca70[1].values, scale_550_selected_pca70[3].values, scale_550_selected_pca70[2].values, accuracy_kfold=None, sensitivity_kfold=None, specificity_kfold=None, AUC_kfold=None, verbose=True, is_showfig=False, legend1='HC', legend2='Patients', is_savefig=False, out_name=None) # pca80 acc_chronic_medicated_SSD_550_18_pca80 = np.sum( data_chronic_medicated_SSD_550_18_pca80[1] - data_chronic_medicated_SSD_550_18_pca80[3] == 0) / len( data_chronic_medicated_SSD_550_18_pca80) acc_firstepisode_medicated_SSD_550_18_pca80 = np.sum( data_firstepisode_medicated_SSD_550_18_pca80[1] - data_firstepisode_medicated_SSD_550_18_pca80[3] == 0) / len(