def load_multi_model(models_dir, custom_objects=None): ''' Loads multiple models stored in `models_path`. Args: models_path: A string indicating the directory were models are stored. custom_objects: Dict mapping class names (or function names) of custom (non-Keras) objects to class/functions. Returns: List of models, list of model_specs ''' models = [] model_specs = [] num_models = 0 model_extensions = ['.h5', '.hdf5'] for dirpath, dirnames, files in os.walk(models_dir): for dir in dirnames: files = os.listdir(os.path.join(dirpath, dir)) for filename in files: if filename.endswith(tuple(model_extensions)): print('Loading model ', filename) model, model_spec = load_model(os.path.join(dirpath, dir, filename), custom_objects=custom_objects) models.append(model) model_specs.append(model_spec) num_models += 1 print('Models loaded: ', num_models) return models, model_specs
def define_my_vgg(self): vgg = VGG19(include_top=False, input_shape=(self.image_row, self.image_row, 3)) vgg.trainable = False models = [] for i in [1, 2, 4, 5, 7, 8, 9, 10, 12, 13, 14, 15, 17, 18, 19, 20]: model = Model(inputs=vgg.input, outputs=vgg.layers[i].output) model.trainable = False models.append(model) return models
def load_trained_models_1(input_shape, directory): n_folds = 5 models = list() for i in range(n_folds): # define model model = CapsNet_1(input_shape=input_shape, n_class=2, routings=3) weight_file = directory + '/fold_%d' % (i) + '/best_model.h5' model.load_weights(weight_file) print('load weight from ', weight_file) models.append(model) return models
def get_models(models_dir): print("loading models from '%s'" % models_dir) custom_objects = {'PositionEncode': juliet_memnet.PositionEncode} models = [] for fname in MODEL_FNAMES: path = os.path.join(models_dir, fname) if not os.path.exists(path): print("Warning: could not find model file '%s'" % path) continue model = keras.models.load_model(path, custom_objects=custom_objects) models.append(model) return models
def compareModelAccuracy(a,b,c,d): print('\nCompare Multiple Classifiers:') print('\nK-Fold Cross-Validation Accuracy:\n') models = [] models.append(('LR', LogisticRegression())) models.append(('RF', RandomForestClassifier())) # models.append(('SVM', SVC())) # takes hours to run! # models.append(('LSVM', LinearSVC())) # models.append(('GNB', GaussianNB())) models.append(('DTC', DecisionTreeClassifier())) models.append(('XGB', XGBClassifier())) resultsAccuracy = [] names = [] for name, model in models: model.fit(a,b) kfold = model_selection.KFold(n_splits=10, random_state=7) accuracy_results = model_selection.cross_val_score(model, a,b, cv=kfold, scoring='accuracy') resultsAccuracy.append(accuracy_results) names.append(name) accuracyMessage = "%s: %f (%f)" % (name, accuracy_results.mean(), accuracy_results.std()) print(accuracyMessage) # boxplot algorithm comparison fig = plt.figure() fig.suptitle('Algorithm Comparison: Accuracy') ax = fig.add_subplot(111) plt.boxplot(resultsAccuracy) ax.set_xticklabels(names) ax.set_ylabel('Cross-Validation: Accuracy Score') plt.show() return
def load_models(paths): """ Load keras models from the paths, returning a list of models. """ models = [] for i, path in enumerate(paths, start=1): # Note: compile=False improves model load times (by about 3x) model = keras.models.load_model(path, compile=False) model.name = "model{}".format(i) models.append(model) return models
def get_models(self): models = [] models.append(self.predictions_1d_conv_output_1) # models.append(self.predictions_1d_conv_decrease) # models.append(self.predictions_1d_conv_double) # models.append(self.predictions_1d_conv_double_dropout) # models.append(self.predictions_1d_conv_activ_tanh) # models.append(self.predictions_1d_conv_activ_sig) # models.append(self.predictions_1d_conv_activ_linear) # models.append(self.predictions_1d_conv_activ_exp) # models.append(self.predictions_1d_conv_double_deep_unif) # models.append(self.predictions_1d_conv_double_deep_mixed) return models
return modelA, modelB def cut_model(model, cut_point): modelA, modelB = cut_model_functional(model, cut_point) return modelA, modelB models = [] for c in valid_cut_points: try: modelA, modelB = cut_model(model, c) models.append(modelB) except Exception as e: models.append(None) continue warmup_start = time.time() if model_name == 'lenet': image = load_img('images/' + images[0] + '.jpg', color_mode='grayscale', target_size=(28, 28)) else: image = load_img('images/' + images[0] + '.jpg', target_size=(224, 224)) # convert the image pixels to a numpy array
def predictor_results_to_csv(wav_name, wav_duration): """ :param wav_name: file's name :param wav_duration: file's duration :return: writes one row to wav_path with extracted features """ """ # search for the models the needed to be loaded by the types of labels we trained for - models list also save their sizes in order to insert the right input later on """ print("the chunk " + wav_name + " is being examined for disterss") directory_path = 'train/positive' list_of_files = listdir(directory_path) models = [] models_mfcc_sizes = [] for i in list_of_files: model_path = str(f'{clfGlobals.bestModelsPath}/{i}_clf_mfcc_12.h5') if os.path.exists(model_path): # print(f"loading model from {model_path}") models_mfcc_sizes.append(12) models.append(load_model(model_path)) continue model_path = str(f'{clfGlobals.bestModelsPath}/{i}_clf_mfcc_15.h5') if os.path.exists(model_path): # print(f"loading model from {model_path}") models_mfcc_sizes.append(15) models.append(load_model(model_path)) continue model_path = str(f'{clfGlobals.bestModelsPath}/{i}_clf_mfcc_20.h5') if os.path.exists(model_path): # print(f"loading model from {model_path}") models_mfcc_sizes.append(20) models.append(load_model(model_path)) continue """ # search for the right row in each csv file of the features and load it to dict for further use """ # input file name you want to search name = wav_name # read csv, and split on "," the line csv_file_12 = csv.reader(open('csv/test/data_test_mfcc_12.csv', "r"), delimiter=",") csv_file_15 = csv.reader(open('csv/test/data_test_mfcc_15.csv', "r"), delimiter=",") csv_file_20 = csv.reader(open('csv/test/data_test_mfcc_20.csv', "r"), delimiter=",") # loop through csv list dict = {} for row in csv_file_12: # if current rows 2nd value is equal to input, save that row if name == row[0]: dict[12] = row dict[12].pop(0) dict[12].pop() for row in csv_file_15: # if current rows 2nd value is equal to input, save that row if name == row[0]: dict[15] = row dict[15].pop(0) dict[15].pop() for row in csv_file_20: # if current rows 2nd value is equal to input, save that row if name == row[0]: dict[20] = row dict[20].pop(0) dict[20].pop() """ # the first features to be written in the predictor csv is the file name date and length of the file """ now = datetime.datetime.now() to_append = f'{str(str(now.day)+"-"+str(now.month)+"-"+str(now.year)+":"+str(now.hour)+"-"+str(now.minute)+"-"+str(now.second))} {str(wav_name)} {str(wav_duration)} ' """ # for each label insert the correct input , append the result to the row string and count the number of positive predictions found so far (count_positives) """ count_positives = 0 labels_that_appeared = list_of_files for i, m in enumerate(models, 0): # the input that is right for the model X = np.array(dict[models_mfcc_sizes[i]]) scaler = StandardScaler() # the input after being normalized - an input with 1 column and 18,21,26 rows is recieved X_test_scaled = scaler.fit_transform(X[:, np.newaxis]) # in order the insert the input to the model we nedd to inverse it to a row with 18,21,26 inputs X_inverse = X_test_scaled.transpose() # print(np.max(X_test)) # 2590 # print(np.max(X_inverse)) # 5 # this bring a 0/1 answer # prediction=m.predict(X_inverse) # this bring a probability- float number between 0 to 1 # the next line is the one who gets the results of the label classifier prediction = m.predict_proba(X_inverse) result1 = np.sum(prediction[0]) # result2=np.argmax(prediction[0]) # print(result1) # print(result2) # current_label_score2=m.predict_classes(input_for_label) # print(current_label_score[0][0]) # if the probabilty is over 0.5 than round to 1 otherwise 0 current_label_score = 1 if result1 >= 0.5 else 0 # current_label_score = prediction[0] # current_label_score2=current_label_score2.shape[0] to_append += f' {current_label_score}' count_positives += current_label_score # remove the label from the label list if its not found positive from that label labels_that_appeared[ i] = 0 if current_label_score == 0 else labels_that_appeared[i] # sum of the labels results to_append += f' {count_positives}' # if we found at leaset one positive label than we categorize the sound as a distress to_append += f' {(count_positives>0)}' # save to csv (append new lines) file = open('predictor_data.csv', 'a', newline='') with file: writer = csv.writer(file) writer.writerow(to_append.split()) # return the chunk result in order to sum all the results of the chunks of the file return (count_positives > 0), [ str(label) for label in labels_that_appeared ]
# Set the network speed to maximum, in case it's already limited due to previous runs. set_network_speed(50) # Initialise variables cut_points = [] network_speed = 50 weights = [0, 0, 0, 0, 0] models = [] valid_cut_points = get_valid_cut_points(model, model_name) valid_cut_points_iter = iter(valid_cut_points) # Load the pre-partitioned Edge models into the 'models' list for c in valid_cut_points: if c == -1: models.append(None) break json_file = open( 'edge_models/edge_models_' + str(model_name) + '/model_' + str(c) + '.json', 'r') loaded_model_json = json_file.read() json_file.close() modelA = model_from_json(loaded_model_json) models.append(modelA) print('model layers:', len(modelA.layers)) time.sleep(1) print('done sleep')
def ALLModels(opts): models = [] #models.append(XGB(opts)) #models.append(DTree(opts)) #models.append(LR(opts)) #models.append(SVMSVC(opts)) #models.append(LINSVC(opts)) #models.append(NBMULTI(opts)) #models.append(NBBonuli(opts)) X_train, y_train = data_process(opts) #y_train = to_categorical(y_train, num_classes = nclass) X_train = normalize(X_train, norm = 'max', axis=0, copy = True, return_norm = False) X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.3, random_state=42) X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=42) FOLDER = 'clean_vpn12_rf' param_grid = { 'critire': ['gini', 'gain'], 'n_estimators': [200, 700], 'max_features': ['auto', 'sqrt', 'log2'], 'min_samples_split': np.arange(2, 30, 2), 'max_depth':np.arange(2, 31) } classifier = RandomForestClassifier(n_jobs=-1, oob_score=True) rf = ML_Model("Random Forest", classifier, param_grid) rf.model_path = FOLDER models.append(rf) FOLDER = 'clean_vpn12_lr' classifier = LogisticRegression(multi_class='ovr', penalty='l2') param_grid = dict(C=[0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000]) lr = ML_Model("Log. Regression", classifier, param_grid) lr.model_path = FOLDER models.append(lr) classifier = BernoulliNB() FOLDER = 'clean_vpn12_NB-Bonulina' nb = ML_Model("NB-Bernoulli", classifier, None) nb.model_path = FOLDER models.append(nb) FOLDER = 'clean_vpn12_xgb' xgb = XGBClassifier( learning_rate=0.1, n_estimators=1000, objective='multi:softmax', nthread=4, scale_pos_weight=1, seed=27, num_classes = 12) param_grid = { 'max_depth': range(3, 10, 2), 'min_child_weight': range(1, 6, 2), 'gamma': [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 1, 1.5, 2, 5], 'subsample': [i / 10.0 for i in range(5, 11)], 'colsample_bytree': [i / 10.0 for i in range(5, 11)], 'reg_alpha': [1e-5, 1e-2, 0.1, 1, 100] } xgb = ML_Model('XGBoost', xgb, param_grid) xgb.model_path = FOLDER models.append(xgb) FOLDER = 'clean_vpn12_svc' classifier = svm.SVC() C_range = np.logspace(-2, 10, 13) gamma_range = np.logspace(-9, 3, 13) param_grid = dict(gamma=gamma_range, C=C_range) svmsvc = ML_Model('SVM-SVC', classifier, param_grid) svmsvc.model_path = FOLDER models.append(svmsvc) final_train(models, X_train, y_train, X_test, y_test, opts.sets) ML_Model.models_metric_summary(models)
def NNTRegressor(I_data_path, I_Model_path, k, num_epochs, batch_Size, Verbose, NNTList): import numpy as np import pandas as pd import pickle import matplotlib.pyplot as plt from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split import time import os import warnings warnings.filterwarnings('ignore') from sklearn.ensemble import RandomForestRegressor from sklearn.metrics import accuracy_score from sklearn.metrics import mean_absolute_error import keras from keras.models import Sequential from keras import models from keras import layers get_ipython().run_line_magic('matplotlib', 'inline') from joblib import dump #################################### Functions #################################### # Normalise def Normalise(Data, Target): sc = StandardScaler() dfX = Data.drop([Target], axis=1) sc.fit(dfX) X = sc.transform(dfX) os.makedirs(I_Model_path + 'temp', exist_ok=True) print('save scaler to '+ I_Model_path + 'temp/scaler.pickle') with open(I_Model_path + 'temp/scaler.pickle', 'wb') as f: pickle.dump(sc, f) dump(sc, I_Model_path + 'temp/std_scaler.bin', compress=True) y = Data.values[:, Data.columns.get_loc(Target)] return X, y #Validation def validation(train_data, train_targets, num_val_samples, i): val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples] val_targets = train_targets[i * num_val_samples: (i + 1) * num_val_samples] return val_data, val_targets def partial_train(train_data, train_targets, num_val_samples, i): partial_train_data = np.concatenate([train_data[:i * num_val_samples], train_data[(i + 1) * num_val_samples:]], axis=0) partial_train_targets = np.concatenate([train_targets[:i * num_val_samples], train_targets[(i + 1) * num_val_samples:]], axis=0) return partial_train_data, partial_train_targets #Models def build_model1(titles): red = Sequential() red.add(layers.Dense(64, activation='relu', input_shape=(n,))) red.add(layers.Dense(128, activation='relu')) red.add(layers.Dense(64, activation='relu')) red.add(layers.Dense(1)) red.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) title = 'Three hidden layers (relu: 64, 128, 64) and rmsprop optimizer' titles.append(title) return red def build_model2(titles): red = Sequential() red.add(layers.Dense(16, activation='relu', input_shape=(n,))) red.add(layers.Dense(16, activation='relu')) red.add(layers.Dense(1)) red.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) title = 'Two hidden layers (relu: 16) and rmsprop optimizer' titles.append(title) return red def build_model3(titles): red = Sequential() red.add(layers.Dense(512, activation='relu', input_shape=(n,))) red.add(layers.Dense(1)) red.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) title = 'One hidden layers (relu: 512) and rmsprop optimizer' titles.append(title) return red def build_model4(title): red = Sequential() red.add(layers.Dense(64, activation='relu', input_shape=(n,))) red.add(layers.Dense(64, activation='relu')) red.add(layers.Dense(64, activation='softmax')) red.add(layers.Dense(1)) red.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) title = 'Three hidden layers (relu: 64) and rmsprop optimizer' titles.append(title) return red def build_model5(title): red = Sequential() red.add(layers.Dense(32, activation='relu', input_shape=(n,))) red.add(layers.Dense(64, activation='relu')) red.add(layers.Dense(128, activation='relu')) red.add(layers.Dense(128, activation='relu')) red.add(layers.Dense(512, activation='relu')) red.add(layers.Dense(1)) red.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) title = 'One hidden layers (sigmoid: 16) and rmsprop optimizer' titles.append(title) return red def build_model6(titles): red = Sequential() red.add(layers.Dense(64, activation='relu', input_shape=(train_data.shape[1],))) red.add(layers.Dense(64, activation='relu')) red.add(layers.Dense(64, activation='relu')) red.add(layers.Dense(64, activation='relu')) red.add(layers.Dense(1)) red.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) title = 'Four hidden layers (relu: 64) and rmsprop optimizer' titles.append(title) return red #MAE in k def average_mae(train_all_scores, val_all_scores, num_epochs): training = [np.mean([x[k] for x in train_all_scores]) for k in range(num_epochs)] validation = [np.mean([x[k] for x in val_all_scores]) for k in range(num_epochs)] return training, validation #Visuals def plot_Mae(average_mae_training, average_mae_validation, title, i): my_dpi=96 plt.figure(figsize=(1000/my_dpi, 1000/my_dpi), dpi=my_dpi) plt.plot(range(1, len(average_mae_training) + 1), average_mae_training, 'o', label='Training') plt.plot(range(1, len(average_mae_validation) + 1), average_mae_validation, 'lightseagreen', label='Validation') plt.title(title, size=18) plt.xlabel('Epochs', size=18) plt.ylabel('Mean Absolute Error', size=18) plt.legend(loc='best',prop={'size': 16}) os.makedirs(I_Model_path + 'visuals', exist_ok=True) plt.savefig(I_Model_path + 'visuals/MAE Model' + str(NNTList[i]) + '.png') # Timer def Timer(Model_Step, last_time, k): Time_list = [] now = time.time() - last_time if now < 60: print(' Time of '+ Model_Step+str(k)+': '+ str(round(now))+'s') Time_list.append('Time of '+ Model_Step +str(k)+': '+ str(round(now))+'s') elif 60<now<3600: now_m = now/60 minutes = int(now_m) secs = int((now_m - minutes)*60) print(' Time of '+ Model_Step+str(k)+': ' +str(minutes)+'m and '+str(secs)+'s') Time_list.append(' Time of '+ Model_Step+str(k)+': ' +str(minutes)+'m and '+str(secs)+'s') del now_m del minutes del secs elif now>3600: now_h = now/3600 hours = int(now_h) now_m = (now_h - hours)*60 minutes = int(now_m) secs = int((now_m - minutes)*60) print(' Time of '+ Model_Step+str(k)+': ' +str(hours)+'h, '+str(minutes)+'m and '+str(secs)+'s') Time_list.append(' Time of '+ Model_Step+str(k)+': ' +str(hours)+'h, '+str(minutes)+'m and '+str(secs)+'s') del now_h del hours del now_m del minutes del secs ############################################################################################################ # Define inputs Master_path = I_data_path os.makedirs(I_Model_path, exist_ok=True) ## Load data: print('Loading the data...') data = pd.read_csv(Master_path) #Creating a dataset copy Data = data.copy() print('Working dataset has: ' + str(Data.shape[0])+ ' rows and ' + str(Data.shape[1])+ ' columns') # Normalise print('Normalising...') X, y = Normalise(Data,'CANTIDADSALIDA') print('Completed') #Split in train test print('Spliting in train and test set') train_data, test_data, train_targets, test_targets = train_test_split(X, y, train_size=0.80, test_size=0.20, random_state=0) ### Save as csv: os.makedirs(I_Model_path + 'temp', exist_ok=True) dfX = Data.drop('CANTIDADSALIDA', axis=1) print('Saving training feature set to ' + I_Model_path + 'temp/train_X.csv') train_data_df = pd.DataFrame(train_data, columns= dfX.columns ) train_data_df.to_csv(I_Model_path + 'temp/train_X.csv') with open(I_Model_path + 'temp/train_X.pickle', 'wb') as f: pickle.dump(train_data, f) print('Saving training labels to '+I_Model_path + 'temp/train_Y.csv') train_targets_df = pd.DataFrame(train_targets, columns= ['CANTIDADSALIDA']) train_targets_df.to_csv(I_Model_path + 'temp/train_Y.csv') with open(I_Model_path + 'temp/train_Y.pickle', 'wb') as f: pickle.dump(train_targets, f) print('Saving test feature set to '+ I_Model_path + 'temp/test_X.csv') test_data_df = pd.DataFrame(test_data, columns= dfX.columns ) test_data_df.to_csv(I_Model_path + 'temp/test_X.csv') with open(I_Model_path + 'temp/test_X.pickle', 'wb') as f: pickle.dump(test_data, f) print('Saving test labels to '+I_Model_path + '/temp/test_Y.csv') test_targets_df = pd.DataFrame(test_targets, columns= ['CANTIDADSALIDA']) test_targets_df.to_csv(I_Model_path + 'temp/test_Y.csv') with open(I_Model_path + 'temp/test_Y.pickle', 'wb') as f: pickle.dump(test_targets, f) train_data_df["CANTIDADSALIDA"] = train_targets_df["CANTIDADSALIDA"] train_data_df['CANTIDADSALIDA'] = train_data_df['CANTIDADSALIDA'].astype(int) test_data_df["CANTIDADSALIDA"] = test_targets_df["CANTIDADSALIDA"] test_data_df['CANTIDADSALIDA'] = test_data_df['CANTIDADSALIDA'].astype(int) # Parameters #A) Lists: models = [] titles = [] #B) Temps n = train_data.shape[1] # number of features num_val_samples = len(train_data) // k #Model if 1 in NNTList: models.append(build_model1(titles)) if 2 in NNTList: models.append(build_model2(titles)) if 3 in NNTList: models.append(build_model3(titles)) if 4 in NNTList: models.append(build_model4(titles)) if 5 in NNTList: models.append(build_model5(titles)) if 6 in NNTList: models.append(build_model6(titles)) # Training K-Cross Neural Network: print('- Starting to train the model:') final_time = time.time() for i in range(len(models)): last_time = time.time() print('Model '+ str(NNTList[i]) + ':') # NNT model red = models[i] # Lists train_all_scores_byModel = [] val_all_scores_byModel = [] #K-Cross-validation for j in range(k): last_time2 = time.time() print(" Processing fold #", j) # Validation val_data, val_targets = validation(train_data, train_targets, num_val_samples, j) partial_train_data, partial_train_targets = partial_train(train_data, train_targets, num_val_samples, j) # Training training = red.fit(partial_train_data, partial_train_targets, validation_data = (val_data, val_targets), epochs = num_epochs, batch_size = batch_Size, verbose=Verbose) #Mean absolute error train_mae_training = training.history['mae'] val_mae_training = training.history['val_mae'] # Adding to the list train_all_scores_byModel.append(train_mae_training) val_all_scores_byModel.append(val_mae_training) #timer Timer('Step ', last_time2, j) del val_data, val_targets #Saving the model print('Saving temps') os.makedirs(I_Model_path + 'models', exist_ok=True) os.makedirs(I_Model_path + 'temp', exist_ok=True) red.save(I_Model_path + 'models/Model' +str(NNTList[i])+ '.h5') with open(I_Model_path + 'models/NNTModel' +str(NNTList[i])+ '.pickle', 'wb') as f: pickle.dump(red, f) #timer print(' ' + str(Timer('Model ', last_time, NNTList[i]))) # Evaluate test_mse_score, test_mae_score = red.evaluate(test_data, test_targets,verbose=0) print(" Mean Absolute Error model "+ str(NNTList[i])+ ":" "= {:.2f}".format(test_mae_score)) average_mae_training, average_mae_validation = average_mae(train_all_scores_byModel, val_all_scores_byModel, num_epochs) with open(I_Model_path + 'temp/NNT_error' +str(NNTList[i])+ '.pickle', 'wb') as f: pickle.dump(test_mae_score, f) # Visual plot_Mae(average_mae_training, average_mae_validation, titles[i], i) plt.rcdefaults() print(' ' + str(Timer('Global', final_time, 0))) return train_data_df, train_targets_df, test_data_df, test_targets_df
except IndexError: print("There are no models currently saved in the top_models folder.") else: for folder in folders: mlp = None try: mlp = load_model(model_dir + "/" + folder + "/model") holdout_data = pd.read_csv(model_dir + "/" + folder + "/holdout_data.csv") training_data = pd.read_csv(model_dir + "/" + folder + "/training_data.csv") score_df = pd.read_csv(model_dir + "/" + folder + "/learning_scores.csv", sep='\s*,\s*') models.append([mlp, holdout_data, training_data, score_df]) predictions = mlp.predict(X) model_mae = mean_absolute_error(Y, predictions) model_r2 = r2_score(Y, predictions) if disp_testing: holdout_X_test = holdout_data.iloc[:, 1:-2].values holdout_Y_test = holdout_data.loc[:, "κref."].values predictions = mlp.predict(holdout_X_test) model_mae = mean_absolute_error(holdout_Y_test, predictions) model_r2 = r2_score(holdout_Y_test, predictions) model_rmse = math.sqrt( mean_squared_error(holdout_Y_test, predictions)) else: predictions = mlp.predict(X)
def create_3(): ''' Create ensemble_3 Returns: ensemble_model: ensemble_3 ''' model_input = Input(shape=(28, 28, 1)) models = [] models.append(load_hdf5('model/emnist-letters_200epoch_lenet_1_1')) models.append(load_hdf5('model/emnist-letters_200epoch_lenet_1_2')) models.append(load_hdf5('model/emnist-letters_200epoch_lenet_1_5')) models.append(load_hdf5('model/emnist-letters_200epoch_lenet_1_6')) models.append(load_hdf5('model/emnist-letters_300epoch_lenet_2_2')) models.append(load_hdf5('model/emnist-letters_300epoch_lenet_2_1')) models.append(load_hdf5('model/emnist-letters_300epoch_lenet_2_4')) ensemble_model = ensemble_models(models, model_input) ensemble_model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) return ensemble_model