print "loading data" f = pydub.AudioSegment.from_mp3('../ml-music/07_-_Brad_Sucks_-_Total_Breakdown.mp3') data = np.fromstring(f._data, np.int16) data = data.astype(np.float64).reshape((-1,2)) print data.shape data = data[:,0]+data[:,1] #data = data[:,:subsample*int(len(data)/subsample)-1,:] data -= data.min() data /= data.max() / 2. data -= 1. print data.shape print "Setting up decoder" decoder = Sequential() decoder.add(Dense(2048, input_dim=32768, activation='relu')) decoder.add(Dropout(0.5)) decoder.add(Dense(1024, activation='relu')) decoder.add(Dropout(0.5)) decoder.add(Dense(1, activation='sigmoid')) sgd = SGD(lr=0.01, momentum=0.1) decoder.compile(loss='binary_crossentropy', optimizer=sgd) print "Setting up generator" generator = Sequential() generator.add(Dense(2048*2, input_dim=2048, activation='relu')) generator.add(Dense(1024*8, activation='relu')) generator.add(Dense(32768, activation='linear'))
def run(): train_e = getParticleSet('/home/drozd/analysis/data_train_elecs.npy') train_p = getParticleSet('/home/drozd/analysis/data_train_prots.npy') train = np.concatenate((train_e, train_p)) np.random.shuffle(train) X_train = train[:, 0:-1] Y_train = train[:, -1] del train_e, train_p, train val_e = np.concatenate( (getParticleSet( '/home/drozd/analysis/fraction1/data_validate_elecs_1.npy'), getParticleSet('/home/drozd/analysis/fraction1/data_test_elecs_1.npy') )) val_p = np.concatenate( (getParticleSet( '/home/drozd/analysis/fraction1/data_validate_prots_1.npy'), getParticleSet('/home/drozd/analysis/fraction1/data_test_prots_1.npy') )) val = np.concatenate((val_e, val_p)) np.random.shuffle(val) X_val = val[:, 0:-1] Y_val = val[:, -1] val_imba = np.concatenate((val_e[0:int(val_p.shape[0] / 100)], val_p)) np.random.shuffle(val_imba) X_val_imba = val_imba[:, 0:-1] Y_val_imba = val_imba[:, -1] del val_e, val_p, val, val_imba model = Sequential() model.add( Dense(300, input_shape=(X_train.shape[1], ), kernel_initializer='he_uniform', activation='relu')) model.add(Dropout(0.1)) model.add(Dense(150, kernel_initializer='he_uniform', activation='relu')) model.add(Dropout(0.1)) model.add(Dense(70, kernel_initializer='he_uniform', activation='relu')) model.add(Dropout(0.1)) model.add(Dense(1, kernel_initializer='he_uniform', activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['binary_accuracy']) rdlronplt = ReduceLROnPlateau(monitor='loss', patience=3, min_lr=0.001) earl = EarlyStopping(monitor='loss', min_delta=0.0001, patience=5) callbacks = [rdlronplt, earl] history = model.fit(X_train, Y_train, batch_size=150, epochs=40, verbose=0, callbacks=callbacks, validation_data=(X_val, Y_val)) # -------------------------------- predictions_balanced = model.predict(X_val) predictions_imba = model.predict(X_val_imba) predictions_train = model.predict(X_train) del X_val, X_val_imba, X_train sk_l_precision_b, sk_l_recall_b, sk_l_thresholds_b = precision_recall_curve( Y_val, predictions_balanced) sk_l_precision_i, sk_l_recall_i, sk_l_thresholds_i = precision_recall_curve( Y_val_imba, predictions_imba) sk_l_precision_t, sk_l_recall_t, sk_l_thresholds_t = precision_recall_curve( Y_train, predictions_train) sk_l_fpr_b, sk_l_tpr_b, sk_l_roc_thresholds_b = roc_curve( Y_val, predictions_balanced) sk_l_fpr_i, sk_l_tpr_i, sk_l_roc_thresholds_i = roc_curve( Y_val_imba, predictions_imba) sk_l_fpr_t, sk_l_tpr_t, sk_l_roc_thresholds_t = roc_curve( Y_train, predictions_train) man_l_precision_b, man_l_recall_b, man_l_thresholds_b = getPR( Y_val, predictions_balanced, 100) man_l_precision_i, man_l_recall_i, man_l_thresholds_i = getPR( Y_val_imba, predictions_imba, 100) man_l_fpr_b, man_l_tpr_b, man_l_roc_thresholds_b = getROC( Y_val, predictions_balanced, 100) man_l_fpr_i, man_l_tpr_i, man_l_roc_thresholds_i = getROC( Y_val_imba, predictions_imba, 100) print("----- AUC -----") print("Train:", average_precision_score(Y_train, predictions_train)) print("Validate:", average_precision_score(Y_val, predictions_balanced)) print("----- F1 -----") print("Train:", f1_score(Y_train, np.around(predictions_train))) print("Validate:", f1_score(Y_val, np.around(predictions_balanced))) print("----- Precision/Recall -----") print("Train:", precision_score(Y_train, np.around(predictions_train)), " / ", recall_score(Y_train, np.around(predictions_train))) print("Validate:", precision_score(Y_val, np.around(predictions_balanced)), " / ", recall_score(Y_val, np.around(predictions_balanced))) fig1 = plt.figure() plt.plot(sk_l_precision_b, sk_l_recall_b, label='balanced') plt.plot(sk_l_precision_i, sk_l_recall_i, label='imbalanced') #~ plt.plot(sk_l_precision_t, sk_l_recall_t,label='training set') #~ plt.plot(man_l_precision_b, man_l_recall_b,'o',label='balanced, hand') #~ plt.plot(man_l_precision_i, man_l_recall_i,'o',label='imbalanced, hand') plt.xlabel('Precision') plt.ylabel('Recall') plt.legend(loc='best') plt.savefig('PR') fig1b = plt.figure() plt.plot(sk_l_precision_b, sk_l_recall_b, label='validation set') plt.plot(sk_l_precision_t, sk_l_recall_t, label='training set') plt.xlabel('Precision') plt.ylabel('Recall') plt.legend(loc='best') plt.savefig('PRb') fig2 = plt.figure() plt.plot(sk_l_fpr_b, sk_l_tpr_b, label='balanced') plt.plot(sk_l_fpr_i, sk_l_tpr_i, label='imbalanced') #~ plt.plot(man_l_fpr_b, man_l_tpr_b,'o',label='balanced, hand') #~ plt.plot(man_l_fpr_i, man_l_tpr_i,'o',label='imbalanced, hand') plt.xlabel('False Positive') plt.ylabel('True Positive') plt.legend(loc='best') plt.savefig('ROC') fig2b = plt.figure() plt.plot(sk_l_fpr_b, sk_l_tpr_b, label='validation set') plt.plot(sk_l_fpr_t, sk_l_tpr_t, label='training set') plt.xlabel('False Positive') plt.ylabel('True Positive') plt.legend(loc='best') plt.savefig('ROCb') Nbins = 50 binList = [x / Nbins for x in range(0, Nbins + 1)] elecs_t, prots_t = getClassifierScore(Y_train, predictions_train) fig3 = plt.figure() plt.hist(elecs_t, bins=binList, label='e', alpha=0.7, histtype='step', color='green') plt.hist(prots_t, bins=binList, label='p', alpha=0.7, histtype='step', color='red') plt.xlabel('Classifier score') plt.ylabel('Number of events') plt.title('Training set') plt.legend(loc='best') plt.yscale('log') plt.savefig('predHisto_train') fig3b = plt.figure() plt.hist(elecs_t, bins=binList, label='e', alpha=0.7, histtype='step', color='green', normed=True) plt.hist(prots_t, bins=binList, label='p', alpha=0.7, histtype='step', color='red', normed=True) plt.xlabel('Classifier score') plt.ylabel('Fraction of events') plt.title('Training set - normalised') plt.legend(loc='best') plt.yscale('log') plt.savefig('predHisto_train_n') del elecs_t, prots_t, Y_train, predictions_train elecs_b, prots_b = getClassifierScore(Y_val, predictions_balanced) fig4 = plt.figure() plt.hist(elecs_b, bins=binList, label='e', alpha=0.7, histtype='step', color='green') plt.hist(prots_b, bins=binList, label='p', alpha=0.7, histtype='step', color='red') plt.xlabel('Classifier score') plt.ylabel('Number of events') plt.title('Balanced validation set') plt.legend(loc='best') plt.yscale('log') plt.savefig('predHisto_bal') fig4b = plt.figure() plt.hist(elecs_b, bins=binList, label='e', alpha=0.7, histtype='step', color='green', normed=True) plt.hist(prots_b, bins=binList, label='p', alpha=0.7, histtype='step', color='red', normed=True) plt.xlabel('Classifier score') plt.ylabel('Fraction of events') plt.title('Balanced validation set - normalised') plt.legend(loc='best') plt.yscale('log') plt.savefig('predHisto_bal_n') del elecs_b, prots_b, Y_val, predictions_balanced elecs_i, prots_i = getClassifierScore(Y_val_imba, predictions_imba) fig5 = plt.figure() plt.hist(elecs_i, bins=binList, label='e', alpha=0.7, histtype='step', color='green') plt.hist(prots_i, bins=binList, label='p', alpha=0.7, histtype='step', color='red') plt.xlabel('Classifier score') plt.ylabel('Number of events') plt.legend(loc='best') plt.title('Imbalanced validation set') plt.yscale('log') plt.savefig('predHisto_imba') fig5b = plt.figure() plt.hist(elecs_i, bins=binList, label='e', alpha=0.7, histtype='step', color='green', normed=True) plt.hist(prots_i, bins=binList, label='p', alpha=0.7, histtype='step', color='red', normed=True) plt.xlabel('Classifier score') plt.ylabel('Fraction of events') plt.title('Imbalanced validation set - normalised') plt.legend(loc='best') plt.yscale('log') plt.savefig('predHisto_imba_n')
def training_code(): #titanic-complete3.arff är som det vi fick men: #har attributen normaliserade mellan 0 till 1 #Filter:ordinal to numeric, #cabin och embarked attributet är borttagna #Gör om arff filen till numpy arrays. raw_data = loadarff('titanic-complete3.arff') df_data = pd.DataFrame(raw_data[0]) arr = df_data.to_numpy() #Survival attributet blev en string, fixas här numbers = [] x = 0 for i in range(arr.size//6): for word in arr[x,5].split(): if word.isdigit(): numbers.append(int(word)) x += 1 y=0 for i in range(len(numbers)): arr[y,5]= numbers[y] y+=1 arr = arr.astype("float32") # X_input är de 5 attributen # Y_output är de respektive matchande klasstillhörighetern X_input = arr[:,0:5] Y_output = arr[:,5] num_folds = 10 acc_per_fold = [] loss_per_fold = [] # initialiserar vikterna np.random.seed(42) skf = StratifiedKFold(n_splits=num_folds, shuffle=True) fold_no = 1 visualo = [] visuaacc = [] num_of_epochs = 2000 #genomför cross validation och tränar modellen for train_index, test_index in skf.split(X_input, Y_output): # One hot encoding X_train, X_test = X_input[train_index], X_input[test_index] Y_train, Y_test = np_utils.to_categorical(Y_output[train_index], 2), np_utils.to_categorical(Y_output[test_index], 2) #bygger min mlp model = Sequential() model.add(Dense(4,input_dim = (5), activation="relu")) model.add(Dense(2, activation="sigmoid")) #Adam är en form av SGD model.compile(optimizer="Adam", loss="binary_crossentropy", metrics = ["accuracy"]) print('------------------------------------------------------------------------') print(f'Training for fold {fold_no} ...') csv_logger = CSVLogger("training_mlp.log", append=True, separator=";") history = model.fit(x=X_train, y=Y_train, epochs=num_of_epochs, callbacks=[csv_logger], verbose=0) model.save("Titanic_mlp.h5") scores = model.evaluate(X_test, Y_test, verbose=0) print(f'Score for fold {fold_no}: {model.metrics_names[0]} of {scores[0]}; {model.metrics_names[1]} of {scores[1]*100}%') acc_per_fold.append(scores[1] * 100) loss_per_fold.append(scores[0]) fold_no += 1 visualo.append(history.history["loss"]) visuaacc.append(history.history["accuracy"]) print('------------------------------------------------------------------------') print('Score per fold') for i in range(0, len(acc_per_fold)): print('------------------------------------------------------------------------') print(f'> Fold {i+1} - Loss: {loss_per_fold[i]} - Accuracy: {acc_per_fold[i]}%') print('------------------------------------------------------------------------') print('Average scores for all folds:') print(f'> Accuracy: {np.mean(acc_per_fold)} (+- {np.std(acc_per_fold)})') print(f'> Loss: {np.mean(loss_per_fold)}') print('------------------------------------------------------------------------') #plottar träningen med snittet för varje epok per k_fold herek = np.asarray(visualo, dtype=np.float32) loss_visu = np.sum(herek, axis=0) plt.plot(loss_visu/num_folds, label='Binary Crossentropy (loss)') herek2 = np.asarray(visuaacc, dtype=np.float32) acc_visu2 = np.sum(herek2, axis=0) plt.plot(acc_visu2/num_folds, label='accuracy/100') plt.title('training progress for titanic_mlp') plt.ylabel('value') plt.xlabel('No. epoch') plt.legend(loc="upper left") plt.show()
def build_part1_RNN(window_size): model = Sequential() model.add(LSTM(5, input_shape = (window_size,1))) model.add(Dense(1)) return model
import pickle import pandas as pd import numpy as np from keras.models import Sequential from Libraries import data_preprocessing as pp from Libraries import data_evaluation as eval from Libraries import model_evaluation as m_Eval from sklearn.model_selection import train_test_split from Libraries import model_setup RunName = 'bla' file = open('Data.p', 'rb') Data = pickle.load(file) x = Data[0] m = Sequential() dropChannels = [ 'time', 'stopId', 'trg1', 'n1', 'trot1', 'tlin1', 'tlin2', 'tamb1' ] InputDataSet = pp.shape_Data_to_LSTM_format(Data[0][0], dropChannels) input_shape = (None, InputDataSet.shape[2]) m = model_setup.distributed_into_one(input_shape) test_data = list() histories = list() epochs = 1 for currData in Data: seed = 0 X = pp.shape_Data_to_LSTM_format(currData[0], dropChannels) #y = pp.shape_Labels_to_LSTM_format(currData[1])
def run(gParameters): print ('Params:', gParameters) file_train = gParameters['train_data'] file_test = gParameters['test_data'] url = gParameters['data_url'] train_file = candle.get_file(file_train, url+file_train, cache_subdir='Pilot1') test_file = candle.get_file(file_test, url+file_test, cache_subdir='Pilot1') X_train, Y_train, X_test, Y_test = load_data(train_file, test_file, gParameters) print('X_train shape:', X_train.shape) print('X_test shape:', X_test.shape) print('Y_train shape:', Y_train.shape) print('Y_test shape:', Y_test.shape) x_train_len = X_train.shape[1] # this reshaping is critical for the Conv1D to work X_train = np.expand_dims(X_train, axis=2) X_test = np.expand_dims(X_test, axis=2) print('X_train shape:', X_train.shape) print('X_test shape:', X_test.shape) model = Sequential() layer_list = list(range(0, len(gParameters['conv']), 3)) for l, i in enumerate(layer_list): filters = gParameters['conv'][i] filter_len = gParameters['conv'][i+1] stride = gParameters['conv'][i+2] print(int(i/3), filters, filter_len, stride) if gParameters['pool']: pool_list=gParameters['pool'] if type(pool_list) != list: pool_list=list(pool_list) if filters <= 0 or filter_len <= 0 or stride <= 0: break if 'locally_connected' in gParameters: model.add(LocallyConnected1D(filters, filter_len, strides=stride, padding='valid', input_shape=(x_train_len, 1))) else: #input layer if i == 0: model.add(Conv1D(filters=filters, kernel_size=filter_len, strides=stride, padding='valid', input_shape=(x_train_len, 1))) else: model.add(Conv1D(filters=filters, kernel_size=filter_len, strides=stride, padding='valid')) model.add(Activation(gParameters['activation'])) if gParameters['pool']: model.add(MaxPooling1D(pool_size=pool_list[int(i/3)])) model.add(Flatten()) for layer in gParameters['dense']: if layer: model.add(Dense(layer)) model.add(Activation(gParameters['activation'])) if gParameters['drop']: model.add(Dropout(gParameters['drop'])) model.add(Dense(gParameters['classes'])) model.add(Activation(gParameters['out_act'])) #Reference case #model.add(Conv1D(filters=128, kernel_size=20, strides=1, padding='valid', input_shape=(P, 1))) #model.add(Activation('relu')) #model.add(MaxPooling1D(pool_size=1)) #model.add(Conv1D(filters=128, kernel_size=10, strides=1, padding='valid')) #model.add(Activation('relu')) #model.add(MaxPooling1D(pool_size=10)) #model.add(Flatten()) #model.add(Dense(200)) #model.add(Activation('relu')) #model.add(Dropout(0.1)) #model.add(Dense(20)) #model.add(Activation('relu')) #model.add(Dropout(0.1)) #model.add(Dense(CLASSES)) #model.add(Activation('softmax')) kerasDefaults = candle.keras_default_config() # Define optimizer optimizer = candle.build_optimizer(gParameters['optimizer'], gParameters['learning_rate'], kerasDefaults) model.summary() model.compile(loss=gParameters['loss'], optimizer=optimizer, metrics=[gParameters['metrics']]) output_dir = gParameters['save'] if not os.path.exists(output_dir): os.makedirs(output_dir) # calculate trainable and non-trainable params gParameters.update(candle.compute_trainable_params(model)) # set up a bunch of callbacks to do work during model training.. model_name = gParameters['model_name'] path = '{}/{}.autosave.model.h5'.format(output_dir, model_name) # checkpointer = ModelCheckpoint(filepath=path, verbose=1, save_weights_only=False, save_best_only=True) csv_logger = CSVLogger('{}/training.log'.format(output_dir)) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=1, mode='auto', epsilon=0.0001, cooldown=0, min_lr=0) candleRemoteMonitor = candle.CandleRemoteMonitor(params=gParameters) timeoutMonitor = candle.TerminateOnTimeOut(gParameters['timeout']) history = model.fit(X_train, Y_train, batch_size=gParameters['batch_size'], epochs=gParameters['epochs'], verbose=1, validation_data=(X_test, Y_test), callbacks = [csv_logger, reduce_lr, candleRemoteMonitor, timeoutMonitor]) score = model.evaluate(X_test, Y_test, verbose=0) if False: print('Test score:', score[0]) print('Test accuracy:', score[1]) # serialize model to JSON model_json = model.to_json() with open("{}/{}.model.json".format(output_dir, model_name), "w") as json_file: json_file.write(model_json) # serialize model to YAML model_yaml = model.to_yaml() with open("{}/{}.model.yaml".format(output_dir, model_name), "w") as yaml_file: yaml_file.write(model_yaml) # serialize weights to HDF5 model.save_weights("{}/{}.weights.h5".format(output_dir, model_name)) print("Saved model to disk") # load json and create model json_file = open('{}/{}.model.json'.format(output_dir, model_name), 'r') loaded_model_json = json_file.read() json_file.close() loaded_model_json = model_from_json(loaded_model_json) # load yaml and create model yaml_file = open('{}/{}.model.yaml'.format(output_dir, model_name), 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() loaded_model_yaml = model_from_yaml(loaded_model_yaml) # load weights into new model loaded_model_json.load_weights('{}/{}.weights.h5'.format(output_dir, model_name)) print("Loaded json model from disk") # evaluate json loaded model on test data loaded_model_json.compile(loss=gParameters['loss'], optimizer=gParameters['optimizer'], metrics=[gParameters['metrics']]) score_json = loaded_model_json.evaluate(X_test, Y_test, verbose=0) print('json Test score:', score_json[0]) print('json Test accuracy:', score_json[1]) print("json %s: %.2f%%" % (loaded_model_json.metrics_names[1], score_json[1]*100)) # load weights into new model loaded_model_yaml.load_weights('{}/{}.weights.h5'.format(output_dir, model_name)) print("Loaded yaml model from disk") # evaluate loaded model on test data loaded_model_yaml.compile(loss=gParameters['loss'], optimizer=gParameters['optimizer'], metrics=[gParameters['metrics']]) score_yaml = loaded_model_yaml.evaluate(X_test, Y_test, verbose=0) print('yaml Test score:', score_yaml[0]) print('yaml Test accuracy:', score_yaml[1]) print("yaml %s: %.2f%%" % (loaded_model_yaml.metrics_names[1], score_yaml[1]*100)) return history
#values from range 0-255 change to range 0-1 X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 #print(X_train[0], ) #preprocessing test data classes = 10 y_train = to_categorical(y_train, classes) y_test = to_categorical(y_test, classes) #building model nn5 = Sequential() nn5.add(Dense(1000, activation='relu', input_shape=(784,))) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(1000, activation ='relu')) nn5.add(Dense(classes, activation='softmax')) nn5.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) print(nn5.summary()) csv_logger = CSVLogger('training2.log', separator=',', append=False)
''' ############################################################################### ## Finished model METRICS = [ keras.metrics.MeanSquaredError(name='MSE'), keras.metrics.RootMeanSquaredError(name='RMSE'), keras.metrics.MeanAbsoluteError(name='MAE'), ] NUMBER_OF_EPOCHS = 25 BATCH_SIZE = 5000 LEARNING_RATE = 0.001 print('\nCreating learning model.') clf = Sequential() clf.add( Dense(X_train.shape[1], activation='relu', input_shape=(X_train.shape[1], ))) clf.add(Dense(32, activation='relu')) clf.add(Dense(8, activation='relu')) clf.add(Dense(32, activation='relu')) clf.add(Dense(X_train.shape[1], activation=None)) ############################################################################### ## Compile the network ############################################################################### print('\nCompiling the network.') clf.compile(loss='mean_squared_error', optimizer=Adam(lr=LEARNING_RATE),
train_x = np.array(train_data[x_label]) # train_x存入train.csv文件中所有商品的feat信息 test_x = np.array(test_data[x_label]) # test_x存入test.csv文件中所有商品的feat信息 # ------ 将train_y的数据转换成one_hot向量(9维) ------ # train_y = np.zeros([len(train_y_raw), 9]) # 构建train_y矩阵(49502*9) for i in range(len(train_y_raw)): lable_data = int(train_y_raw[i][-1]) # lable_data存入了49502个商品的类别号 train_y[i, lable_data-1] = 1 # train_y存入class的one_hot向量(class7=000000100) ##print(train_x.shape, train_y.shape, test_x.shape)# (49502, 93) (49502, 9) (12376, 93) # ------ 构建模型与模型训练,93-128-64-32-16-9神经网络结构 ------ # model = Sequential() # 序贯(Sequential)模型(多个网络层的线性堆叠) model.add(Dense(128, input_shape=(93,), activation="relu")) model.add(Dense(64, activation="relu")) model.add(Dense(32, activation="relu")) model.add(Dense(16, activation="relu")) model.add(Dense(9)) model.add(Activation('softmax')) # 前几层用relu激活函数,最后一层使用softmax激活函数 #model.summary() model.compile(loss='mean_squared_logarithmic_error', optimizer='adadelta', metrics=['accuracy']) model.fit(x = train_x, y = train_y, batch_size = 2048, nb_epoch = 250) # 训练模型,分批迭代样本的数据 # ------ 预测答案 ------ # test_y = model.predict(test_x)
def save_bottlebeck_features(): np.random.seed(2929) vgg_model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(150, 150, 3)) print('Model loaded.') #initialise top model top_model = Sequential() top_model.add(Flatten(input_shape=vgg_model.output_shape[1:])) top_model.add(Dense(256, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(1, activation='sigmoid')) model = Model(inputs=vgg_model.input, outputs=top_model(vgg_model.output)) model.trainable = True model.summary() #Total of 20 layers. The classification is considered as one layer #Therefore, intermediate is 19 layers #0, 4[:4], 3[:7], 4[:11], 4[:15], 4[:19] (Group 0, 1, 2, 3, 4, 5) #0 -> All trainable #5 -> All non-trainable except classification layer #Always keep layer 20 trainable because it is classification layer #layer_count = 1 for layer in model.layers[:7]: layer.trainable = False #print("NO-Top: Layer is %d trainable" %layer_count) #layer_count = layer_count + 1 model.summary() train_datagen = ImageDataGenerator(rescale=1. / 255) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='binary') validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_height, img_width), batch_size=batch_size, class_mode='binary') sgd = optimizers.Adam( lr=1e-6 ) #optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss="binary_crossentropy", optimizer=sgd, metrics=['accuracy']) # model.compile(optimizer='rmsprop', # loss='binary_crossentropy', metrics=['accuracy']) history = model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size, verbose=1) history_dict = history.history #Plotting the training and validation loss history_dict = history.history loss_values = history_dict['loss'] val_loss_values = history_dict['val_loss'] epochs_0 = range(1, len(history_dict['acc']) + 1) plt.plot(epochs_0, loss_values, 'bo', label='Training loss') plt.plot(epochs_0, val_loss_values, 'b', label='Validation loss') plt.title( 'ADvsMC_64_VGG16_Freeze_data2_group2 - Training and validation loss') plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() #plt.show() plt.savefig('ADvsMC_64_VGG16_Freeze_data2_group2_loss.png') plt.close() #Plotting the training and validation accuracy acc_values = history_dict['acc'] val_acc_values = history_dict['val_acc'] plt.plot(epochs_0, acc_values, 'bo', label='Training acc') plt.plot(epochs_0, val_acc_values, 'b', label='Validation acc') plt.title( 'ADvsMC_64_VGG16_Freeze_data2_group2 - Training and validation accuracy' ) plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() #plt.show() plt.savefig('ADvsMC_64_VGG16_Freeze_data2_group2_acc.png') plt.close()
def SegNet(): model = Sequential() #encoder 256, 256 model.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=(img_w, img_h, 3), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(128,128) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(64,64) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(32,32) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.5)) model.add(MaxPooling2D(pool_size=(2, 2))) #(16,16) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.5)) model.add(MaxPooling2D(pool_size=(2, 2))) #(8,8) #decoder model.add(UpSampling2D(size=(2, 2))) #(16,16) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(32,32) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(64,64) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(128,128) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(256,256) model.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=(3, img_w, img_h), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(Conv2D(n_label, (1, 1), strides=(1, 1), padding='same')) model.add(Reshape((n_label, img_w * img_h))) #axis=1和axis=2互换位置,等同于np.swapaxes(layer,1,2) model.add(Permute((2, 1))) model.add(Activation('softmax')) sgd = optimizers.SGD(lr=0.005, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) model.summary() return model
from sklearn.model_selection import train_test_split import numpy as np import keras from keras.layers import Merge from keras.models import Sequential from keras.layers import Dense, Dropout, Activation from keras.optimizers import SGD DOC_VEC_DIM=10 NUMERICAL_FEATURE_DIM=5 y_train=[0.8,0.9] # semantic semantic_input=np.random.standard_normal(size=(2,10)) semantic_model= Sequential() semantic_model.add(Dense(100,input_dim=DOC_VEC_DIM)) semantic_model.add(PReLU()) semantic_model.add(Dropout(0.2)) semantic_model.add(BatchNormalization()) # numerical numerical_input=np.random.standard_normal(size=(2,NUMERICAL_FEATURE_DIM)) numerical_model= Sequential() numerical_model.add(Dense(100, input_dim=NUMERICAL_FEATURE_DIM)) numerical_model.add(PReLU()) numerical_model.add(Dropout(0.2)) numerical_model.add(BatchNormalization()) #merge
def mesure_1(self): for i in range(self.cv): self.split_train_test() k_y = 1 y_pred = None for col_y in self.y_train: cor_xy = [] for c in self.x_train: if numpy.var(self.x_train[c]) > 0: self.x_train[c] = (numpy.array(self.x_train) - numpy.mean(self.x_train)) / numpy.var(self.x_train) model = linear_model.LinearRegression() model.fit(self.x_train,self.y_train[col_y]) cor_xy = numpy.abs(model.coef_) # for c in self.x_train: # cor_xy.append(abs(self.y_train[col_y].corr(self.x_train[c]))) # cor_xy = numpy.array(cor_xy) # sel = cor_xy.astype(str) == 'nan' # cor_xy[sel] = 0 cor_xy = pandas.DataFrame(cor_xy) cor_xy.columns = ['corr'] cor_xy = cor_xy.sort_values(['corr'],ascending = False) k = 1 col_x = self.x_train.columns while k <= self.nb_split: x_an_train = self.x_train[col_x[cor_xy.index[0:int(k / self.nb_split * len(col_x))]]] x_an_test = self.x_test[col_x[cor_xy.index[0:int(k / self.nb_split * len(col_x))]]] if self.model_type == 'logistic': model = linear_model.LogisticRegression(penalty='none',solver='newton-cg') elif self.model_type == 'tree': model = tree.DecisionTreeClassifier() elif self.model_type == 'rf': model = ensemble.RandomForestClassifier() elif self.model_type == 'svm': model = svm.SVC(probability = True) elif self.model_type == 'xgboost': model = xgb.XGBClassifier(objective="binary:logistic") if self.model_type != 'deeplearning': model.fit(x_an_train,self.y_train[col_y]) y_pred = model.predict_proba(x_an_test)[:,1] if self.model_type == 'deeplearning': model = Sequential() model.add(Dense(128, activation='relu')) # model.add(Dense(128, activation='softplus')) # model.add(Dense(128, activation='tanh')) # model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy']) model.fit(numpy.array(x_an_train), numpy.array(self.y_train[col_y]),batch_size=32, nb_epoch=10, verbose=0) y_pred = model.predict_proba(x_an_test)[:,0] fpr, tpr, thresholds = metrics.roc_curve(self.y_test[:,0], y_pred, pos_label=1) auc_res = metrics.auc(fpr, tpr) sel_11 = (y_pred >= 0.5) * (self.y_test[:,0] == 1) sel_10 = (y_pred >= 0.5) * (self.y_test[:,0] == 0) sel_01 = (y_pred < 0.5) * (self.y_test[:,0] == 1) sel_00 = (y_pred < 0.5) * (self.y_test[:,0] == 0) self.mes['11'].iloc[k-1] += sum(sel_11) self.mes['10'].iloc[k-1] += sum(sel_10) self.mes['01'].iloc[k-1] += sum(sel_01) self.mes['00'].iloc[k-1] += sum(sel_00) self.mes['auc'].iloc[k-1] += auc_res print(str(k_y) + ' - ' + str(k) + ' - ' + str(i)) k += 1 k_y += 1 self.mes.to_csv('C:/netflix/model_outecomes_imdb.csv',sep = ';',index = False)
def mesure(self): for i in range(self.cv): self.split_train_test() k_y = 1 y_pred = None col_y_i = 0 for col_y in self.y_train: cor_xy = [] # for c in self.x_train: # if numpy.var(self.x_train[c]) > 0: # self.x_train[c] = (numpy.array(self.x_train[c]) - numpy.mean(self.x_train[c])) / numpy.var(self.x_train[c]) # model = linear_model.LinearRegression() # model.fit(self.x_train,self.y_train[col_y]) # cor_xy = numpy.abs(model.coef_) for c in self.x_train: cor_xy.append(abs(self.y_train[col_y].corr(self.x_train[c]))) cor_xy = numpy.array(cor_xy) sel = cor_xy.astype(str) == 'nan' cor_xy[sel] = 0 cor_xy = pandas.DataFrame(cor_xy) cor_xy.columns = ['corr'] cor_xy = cor_xy.sort_values(['corr'],ascending = False) k = 1 col_x = self.x_train.columns x_an_train = self.x_train[col_x[cor_xy.index[0:int(self.prop_db * len(col_x))]]] x_an_test = self.x_test[col_x[cor_xy.index[0:int(self.prop_db * len(col_x))]]] if self.model_type == 'logistic': model = linear_model.LogisticRegression(penalty='none',solver='newton-cg') elif self.model_type == 'tree': model = tree.DecisionTreeClassifier() elif self.model_type == 'rf': model = ensemble.RandomForestClassifier() elif self.model_type == 'svm': model = svm.SVC(probability = True) elif self.model_type == 'xgboost': model = xgb.XGBClassifier(objective="binary:logistic") if self.model_type != 'deeplearning': model.fit(x_an_train,self.y_train[col_y]) try: y_pred = numpy.c_[y_pred,model.predict_proba(x_an_test)[:,1]] except: y_pred = model.predict_proba(x_an_test)[:,1] if self.model_type == 'deeplearning': model = Sequential() model.add(Dense(128, activation='relu')) # model.add(Dense(128, activation='softplus')) # model.add(Dense(128, activation='tanh')) # model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy']) model.fit(numpy.array(x_an_train), numpy.array(self.y_train[col_y]),batch_size=32, nb_epoch=10, verbose=0) try: y_pred = numpy.c_[y_pred,model.predict_proba(x_an_test)[:,0]] except: y_pred = model.predict_proba(x_an_test)[:,0] try: fpr, tpr, thresholds = metrics.roc_curve(self.y_test[:,col_y_i], y_pred, pos_label=1) auc_res = metrics.auc(fpr, tpr) except: fpr, tpr, thresholds = metrics.roc_curve(self.y_test[:,col_y_i], y_pred[:,y_pred.shape[1] - 1], pos_label=1) auc_res = metrics.auc(fpr, tpr) self.mes[str(col_y_i) + '_auc'].iloc[0] += auc_res col_y_i += 1 print(str(k_y) + ' - ' + str(self.prop_db) + ' - ' + str(i)) k_y += 1 y_dec = numpy.apply_along_axis(numpy.argmax,1,y_pred) kyd = 0 for d in y_dec: self.mes['all_1'].iloc[0] += self.y_test[kyd,d] self.mes['all_0'].iloc[0] += 1 - self.y_test[kyd,d] self.mes[str(d) + '_1'] += self.y_test[kyd,d] self.mes[str(d) + '_0'].iloc[0] += 1 - self.y_test[kyd,d] kyd += 1 self.mes.to_csv('C:/fake_news/model_outecomes_' + str(self.model_type) + '_' + str(self.prop_db) + '.csv',sep = ';',index = False)
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words) # truncate and pad input sequences max_review_length = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_review_length) X_test = sequence.pad_sequences(X_test, maxlen=max_review_length) print("") # -+-+-+-+-+-+-+- BUILDING MODEL -+-+-+-+-+-+-+- print("BUILDING MODEL") embedding_vecor_length = 32 input_layer = Embedding(top_words, embedding_vecor_length, input_length=max_review_length) branch_1 = Sequential() branch_1.add(input_layer) branch_1.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2)) branch_3 = Sequential() branch_3.add(input_layer) branch_3.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu')) branch_3.add(MaxPooling1D(pool_size=2)) branch_3.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2)) branch_4 = Sequential() branch_4.add(input_layer) branch_4.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu')) branch_4.add(MaxPooling1D(pool_size=2)) branch_4.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
all_image_paths = list(data_root.glob('*/*')) all_image_paths = [str(path) for path in all_image_paths] random.shuffle(all_image_paths) labels = sorted(item.name for item in data_root.glob('*/') if item.is_dir()) labels_to_idx = dict((name, idx) for idx, name in enumerate(labels)) all_image_labels = [labels_to_idx[pathlib.Path(path).parent.name] for path in all_image_paths] train_val_imgs, test_imgs, train_val_labels, test_labels = train_test_split(all_image_paths, all_image_labels, test_size=0.10, random_state=21) train_imgs, val_imgs, train_labels, val_labels = train_test_split(train_val_imgs, train_val_labels, test_size=0.1111, random_state=21) base_model = keras.applications.vgg19.VGG19(weights=None, include_top=False, input_shape=(224,224,5)) inter = Sequential() inter.add(base_model) #inter.add(MaxPooling2D(pool_size=(7,7))) inter.add(Flatten()) inter.add(Dropout(0.3)) inter.add(Dense(1024, kernel_regularizer=regularizers.l2(0.01))) inter.add(Dense(512, kernel_regularizer=regularizers.l2(0.01))) inter.add(Dense(50, activation='softmax')) # x = MaxPooling2D(pool_size=(2,2))(x) # x = Flatten()(x) # x = Dense(1000)(x) # x = Dense(500)(x) # preds = Dense(50, activation='softmax')(x) # # final_model = Model(inputs=noise.input, outputs=preds)
zoom_range=0.2, height_shift_range=0.2, width_shift_range=0.2, rescale=1./255) optimize_test=ImageDataGenerator( rescale=1./255) train_batches=optimize.flow_from_directory(train_path,target_size=(img_width,img_height),classes=['Normal','Pneumonia'],batch_size=batch_size,shuffle=True) valid_batches=optimize.flow_from_directory(valid_path,target_size=(img_width,img_height),classes=['Normal','Pneumonia'],batch_size=12,shuffle=True) test_batches=optimize_test.flow_from_directory(test_path,target_size=((img_width,img_height),classes=['Normal','Pneumonia'],batch_size=1170,shuffle=False) #create model model = Sequential()#add model layers model.add(Conv2D(32,(3,3),activation='relu',padding='same',input_shape=(img_width,img_height,3))) model.add(Conv2D(32,(3,3),activation='relu',padding='same')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(64,(3,3),activation='relu',padding='same')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Flatten()) model.add(Dense(2, activation='softmax')) model.summary() adam = optimizers.Adam(lr=0.001) model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
for i in range(0, df.shape[0]): features.append(df['pixels'].values[i]) features = np.array(features) features = features.reshape(features.shape[0], 224, 224, 3) features.shape features /= 255 #normalize in [0, 1] train_x, test_x, train_y, test_y = train_test_split( features, target_classes, test_size=0.30) #, random_state=42), stratify=target_classes) #VGG-Face model model = Sequential() model.add(ZeroPadding2D((1, 1), input_shape=(224, 224, 3))) model.add(Convolution2D(64, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(128, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(ZeroPadding2D((1, 1))) model.add(Convolution2D(256, (3, 3), activation='relu')) model.add(ZeroPadding2D((1, 1)))
################################################################################################ reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.7, patience=2, min_lr=0.0001, verbose=1) kernel_regularizer = regularizers.l2(0.0001) model_29 = Sequential([ Conv2D(128, (3, 20), activation='relu', kernel_regularizer=kernel_regularizer, border_mode='valid', input_shape=(1107, 20, 1)), Conv2D(128, (5, 1), strides=(3,1), activation='relu', kernel_regularizer=kernel_regularizer, border_mode='valid'), Conv2D(128, (5, 1), strides=(3,1), activation='relu', kernel_regularizer=kernel_regularizer, border_mode='valid'), Conv2D(128, (5, 1), strides=(3,1), activation='relu', kernel_regularizer=kernel_regularizer, border_mode='valid'), Conv2D(128, (5, 1), strides=(3,1), activation='relu', kernel_regularizer=kernel_regularizer, border_mode='valid'), Conv2D(128, (5, 1), strides=(3,1), activation='relu', kernel_regularizer=kernel_regularizer, border_mode='valid'), Reshape((-1, 128)), Bidirectional(LSTM(64, return_sequences=True)), AttentionWithContext(), Dense(3, activation='softmax') ]) print (model_29.summary) print ("model_29 BUILT") model_29.compile(loss='categorical_crossentropy', optimizer="adam", metrics=['accuracy']) print ("model_29 COMPILED") checkpoint = ModelCheckpoint(filepath='/models/model_29.hdf5', monitor='val_loss', save_best_only=True)
y_train = to_categorical(y_train, num_classes=num_classes) ###_YOUR_CODE_GOES_HERE_###) y_test = to_categorical(y_test, num_classes=num_classes) ###_YOUR_CODE_GOES_HERE_###) # ## 2. Exercise part: model definition # # Next, initialise a Keras *Sequential* model and add three layers to it: # # Layer: Add a *Dense* layer with in input_shape=(max_words,), 512 output units and "relu" activation. # Layer: Add a *Dropout* layer with dropout rate of 50%. # Layer: Add a *Dense* layer with num_classes output units and "softmax" activation. # In[18]: model = Sequential( ) ###_YOUR_CODE_GOES_HERE_### # Instantiate sequential model model.add( Dense(512, input_dim=max_words, activation="relu") ) ###_YOUR_CODE_GOES_HERE_###) # Add first layer. Make sure to specify input shape model.add(Dropout(0.5)) ###_YOUR_CODE_GOES_HERE_###) # Add second layer model.add(Dense( num_classes, activation="softmax")) ###_YOUR_CODE_GOES_HERE_###) # Add third layer # ## 3. Exercise part: model compilation # # As the next step, we need to compile our Keras model with a training configuration. Compile your model with "categorical_crossentropy" as loss function, "adam" as optimizer and specify "accuracy" as evaluation metric. NOTE: In case you get an error regarding h5py, just restart the kernel and start from scratch # In[19]: model.compile(optimizer="adam",
BATCH_SIZE = 64 NUM_EPOCHS = 100 # lookup tables print("building lookup tables...") word2id = collections.defaultdict(lambda: 1) word2id["PAD"] = 0 word2id["UNK"] = 1 for v, (k, _) in enumerate(word_freqs.most_common(VOCAB_SIZE - 2)): word2id[k] = v + 2 id2word = {v:k for k, v in word2id.items()} # define autoencoder print("defining autoencoder...") autoencoder = Sequential() autoencoder.add(Embedding(VOCAB_SIZE, EMBED_SIZE, input_length=SEQUENCE_LEN, init="glorot_uniform", name="encoder_word2emb")) autoencoder.add(LSTM(LATENT_SIZE, name="encoder_lstm")) autoencoder.add(RepeatVector(SEQUENCE_LEN, name="decoder_repeat")) autoencoder.add(LSTM(EMBED_SIZE, return_sequences=True, name="decoder_lstm")) autoencoder.add(TimeDistributed(Dense(1, activation="softmax"), name="decoder_emb2word")) autoencoder.add(Reshape((SEQUENCE_LEN,), name="decoder_reshape")) # display autoencoder model summary for layer in autoencoder.layers: print(layer.name, layer.input_shape, layer.output_shape) autoencoder.compile(optimizer="adam", loss="categorical_crossentropy")
horizontal_flip=True) validgen = ImageDataGenerator( rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True) datagen.fit(x_train) validgen.fit(x_test) #Define the NN architecture from keras.models import Sequential from keras.layers import Dense, Activation, Conv2D, MaxPooling2D, Flatten #Two hidden layers nn = Sequential() nn.add(Conv2D(32, 3, 3, activation='relu', input_shape=input_shape)) nn.add(Conv2D(32, 3, 3, activation='relu')) nn.add(MaxPooling2D(pool_size=(2, 2))) nn.add(Conv2D(64, 3, 3, activation='relu')) nn.add(Conv2D(64, 3, 3, activation='relu')) nn.add(MaxPooling2D(pool_size=(2, 2))) nn.add(Conv2D(128, 3, 3, activation='relu')) nn.add(Flatten()) nn.add(Dense(256, activation='relu')) nn.add(Dense(10, activation='softmax')) #Model visualization #We can plot the model by using the ```plot_model``` function. We need to install *pydot, graphviz and pydot-ng*. #from keras.util import plot_model #plot_model(nn, to_file='nn.png', show_shapes=true)
def build_part2_RNN(window_size, num_chars): model = Sequential() model.add(LSTM(200, input_shape=(window_size, num_chars))) model.add(Dense(num_chars)) model.add(Activation('softmax')) return model
def f_NN2(X_train, Y_train, X_test, Y_test, reuse): # LOADS THE SAMPLES UNPROCESSED # CNN ARE USED FOR VISUAL FEATURES DETECTION SO # PROCESSING WOULD HARM THE APPEARANCE OF THE SPECTRA X_train = np.load('Data_files/X_train.npy', mmap_mode='r') X_test = np.load('Data_files/X_test.npy', mmap_mode='r') # CONVERTS THE TARGETS TO ONE HOT ENCODING VECTORS Y_train_ = keras.utils.to_categorical(Y_train) Y_test_ = keras.utils.to_categorical(Y_test) # RESHAPES THE INPUT TO BE 1 CHANNEL SAMPLES train_shape = (X_train.shape[0], X_train.shape[1], 1) test_shape = (X_test.shape[0], X_test.shape[1], 1) X_train_ = X_train.reshape(train_shape) X_test_ = X_test.reshape(test_shape) del X_train, X_test X_train_ = keras.utils.normalize(X_train_, axis=1) X_test_ = keras.utils.normalize(X_test_, axis=1) if reuse: path = 'Algos/NN_folder/NN2' with open(path+'_history.pkl', 'rb') as filehandler: history = pickle.load(filehandler) model = load_model(path+'.h5') else: # MODEL CONSTRUCTION model = Sequential() model.add(AveragePooling1D(pool_size=5)) model.add(Conv1D(16, 3, activation='relu')) # model.add(BatchNormalization()) model.add(Conv1D(32, 3, activation='relu')) model.add(Flatten()) model.add(Dense(64, activation='relu')) # model.add(Dropout(0.25)) # model.add(BatchNormalization()) model.add(Dense(5, activation='softmax')) model.compile(optimizer='SGD', loss='categorical_crossentropy', metrics=['acc']) call_back = ModelCheckpoint('Algos/NN_folder/weights.{epoch:02d}' '-{val_loss:.2f}.h5', monitor='val_loss') # FIT THE MODEL TO THE TRAINING DATA FOR 20 EPOCHS # BY BATCHES OF 30 SAMPLES # VERBOSE IS THE DEGREE OF INFORMATIONS OUTPUT IN # THE TERMINAL DURING TRAINING # CALLBACKS (MODELCHECKPOINT HERE) SAVES THE INTERMEDIATE # STATES OF THE NETWORK TO BE ABLE TO RESTART TRAINING # FROM LAST STATE model_history = model.fit(X_train_, Y_train_, epochs=20, batch_size=30, validation_data=(X_test_, Y_test_), verbose=1, callbacks=[call_back]) history = model_history.history # PLOTS THE MODEL HISTORY plot_history(history) # PREDICTS ON THE TEST SET AND COMPUTES THE CONFUSION MATRIX expected = np.argmax(model.predict(X_test_), axis=1) conf_matrix = confusion_matrix(expected, Y_test) normalisation = np.sum(conf_matrix, axis=1, keepdims=True) conf_matrix = conf_matrix/normalisation print(conf_matrix) # SAVES THE MODEL AND ITS HISTORY path = 'Algos/NN_folder/NN2' model.save(path+'.h5') # keras.utils.plot_model(model, to_file='Images/architecture_NN2.png') with open(path+'_history.pkl', 'wb') as filehandler: pickle.dump(history, filehandler) print('Model saved') return conf_matrix
# y_test[0:594]=0 # y_test[594:1188]=1 # y_test[1188:1782]=2 # y_test[1782:2376]=3 # y_test[2376:2970]=4 # y_test[2970:3564]=5 # convert class vectors to binary class matrices - this is for use in the # categorical_crossentropy loss below y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) model_adam = Sequential() model_adam.add(Dense(128, input_dim=39)) model_adam.add(Activation('relu')) model_adam.add(Dense(256)) model_adam.add(Activation('relu')) model_adam.add(Dense(6)) model_adam.add(Activation('softmax')) ''' Set up the optimizer ''' from keras.optimizers import SGD, Adam, RMSprop, Adagrad # sgd = SGD(lr=0.01,momentum=0.0,decay=0.0,nesterov=False) ''' Compile model with specified loss and optimizer ''' model_adam.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['accuracy'])
For 2++ (two or more) inputs, we can use Model Keras model """ """ Layers: *Dense - regular deeply connected neural network layer *Dropout - regularization.. Easily implemented by randomly selecting nodes to be dropped-out with a given probability *Conv1D, Conv2D, Conv3D - Convolution Layers *LSTM - Recurrent Layer *GRU - Recurrent Integration version Layer *MaxPooling2D - Max pooling to a convolutional neural network in code *Flatten - used to reshape the tensor to such a shape which is equal to the number of elements present in the tensor """ # Training model from one input (CT scan picture) model_CT_lungs = Sequential() model_CT_lungs.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(224, 224, 3))) model_CT_lungs.add(Conv2D(128, (3, 3), activation='relu')) model_CT_lungs.add(MaxPooling2D(pool_size=(2, 2))) model_CT_lungs.add(Dropout(0.25)) model_CT_lungs.add(Conv2D(64, (3, 3), activation='relu')) model_CT_lungs.add(MaxPooling2D(pool_size=(2, 2))) model_CT_lungs.add(Dropout(0.25)) model_CT_lungs.add(Conv2D(128, (3, 3), activation='relu')) model_CT_lungs.add(MaxPooling2D(pool_size=(2, 2)))
onehotencoder = OneHotEncoder(sparse=False) X = onehotencoder.fit_transform(X) y = pd.get_dummies(y) import keras from keras.models import Sequential from keras.layers import Dense, Dropout, PReLU from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42) classifier = Sequential() classifier.add( Dense(units=250, kernel_initializer="random_normal", input_dim=47)) classifier.add(Dropout(0.2)) classifier.add(keras.layers.PReLU()) classifier.add(Dense(units=150, kernel_initializer="random_normal")) classifier.add(Dropout(0.2)) classifier.add(keras.layers.PReLU()) classifier.add( Dense(units=74, kernel_initializer="random_normal", activation='softmax')) classifier.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) classifier.fit(X_train, y_train, batch_size=32, epochs=250)
X_train.append(training_set_scaled[i-60:i, 0]) y_train.append(training_set_scaled[i, 0]) X_train, y_train = np.array(X_train), np.array(y_train) # Reshaping X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1)) # Part 2 - Building the RNN from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from keras.layers import Dropout # Initialising the RNN regressor = Sequential() # Adding the first LSTM layer and some Dropout regularisation regressor.add(LSTM(units = 50, return_sequences = True, input_shape = (X_train.shape[1], 1))) regressor.add(Dropout(0.2)) # Adding a second LSTM layer and some Dropout regularisation regressor.add(LSTM(units = 50, return_sequences = True)) regressor.add(Dropout(0.2)) # Adding a third LSTM layer and some Dropout regularisation regressor.add(LSTM(units = 50, return_sequences = True)) regressor.add(Dropout(0.2)) # Adding a fourth LSTM layer and some Dropout regularisation regressor.add(LSTM(units = 50))
for i in range(len(X)): axes = ax[i] axes.imshow(X[i], aspect='auto') #axes.set_title("Angle" + str(y[i])) axes.axis('off') plt.show() """ Setup the model architecture """ input_shape = (X_batch.shape[1], X_batch.shape[2], X_batch.shape[3]) pool_size = (2, 2) model = Sequential() model.add( Lambda(lambda x: x / 127.5 - 1., input_shape=input_shape, output_shape=input_shape)) model.add( Convolution2D(24, 5, 5, subsample=(2, 2), border_mode="valid", init="he_normal")) model.add(ELU()) model.add(
def index(request): back_period = 30 stock = yf.Ticker("AAPL") hist = stock.history(period='max', interval='1d') data = hist.filter(items=['Close']) dataset1=data.values stock = yf.Ticker("CIPLA.NS") hist = stock.history(period='max', interval='1d') data = hist.filter(items=['Close']) dataset2=data.values dataset=np.concatenate((dataset1,dataset2)) scaler=MinMaxScaler() scaled_dataset=scaler.fit_transform(dataset) scaled_dataset1= scaled_dataset[0:dataset1.shape[0]] scaled_dataset2= scaled_dataset[dataset1.shape[0]:] data_x=[] data_y=[] for i in range(back_period,scaled_dataset1.shape[0]): data_x.append(scaled_dataset1[i-back_period:i,:]) data_y.append(scaled_dataset1[i,0]) for i in range(back_period,scaled_dataset2.shape[0]): data_x.append(scaled_dataset2[i-back_period:i,:]) data_y.append(scaled_dataset2[i,0]) data_x=np.array(data_x) data_y=np.array(data_y) data_y =data_y.reshape(-1,1) training_size = math.ceil(data_x.shape[0]*0.7) data_x,data_y= shuffle(data_x,data_y,random_state=1) train_x= data_x[0:training_size,:] train_y= data_y[0:training_size,:] model = Sequential() model.add(LSTM(40, input_shape=(train_x.shape[1],1),return_sequences=True)) model.add(LSTM(25)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') model.fit(train_x, train_y, epochs=0, batch_size=1) test_x=data_x[training_size:,:] test_y=data_y[training_size:,:] test_predict= model.predict(test_x) test_predict= scaler.inverse_transform(test_predict) test_y= scaler.inverse_transform(test_y) error= np.sqrt(np.mean(((test_predict- test_y)**2))) stock = yf.Ticker("GOOGL") hist = stock.history(period='max', interval='1d') vol_data= hist['Volume'] data = hist.filter(items=['Close']) dataset=data.values scaled_dataset= scaler.transform(dataset) training_size = math.ceil(dataset.shape[0]*0.7) train_data= data[0:training_size+back_period] test_data= data[training_size+back_period:] test_scaled_data = scaled_dataset[training_size:] test_x=[] for i in range(back_period,test_scaled_data.shape[0]): test_x.append(test_scaled_data[i-back_period:i,:]) test_x=np.array(test_x) test_predict= model.predict(test_x) # test_predict = np.reshape(test_predict,(test_predict.shape[0],test_predict.shape[1])) test_predict= scaler.inverse_transform(test_predict) test_data['Predictions'] = test_predict fig = plt.figure(figsize=(15,12)) plt.plot(train_data['Close']) plt.plot(test_data['Predictions']) plt.plot(test_data['Close']) buf = io.BytesIO() fig.savefig(buf,format='png') buf.seek(0) stri = base64.b64encode(buf.read()) uri = urllib.parse.quote(stri) return Response({'context' : uri})