def sonar_model(): model = Sequential() model.add(Dense(60, input_shape=(60,), activation='relu')) model.add(Dropout(0.2)) model.add(Dense(30, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) # Use the Binary Cross Entropy loss function for a Binary Classifier. # https://www.tensorflow.org/api_docs/python/tf/keras/models/Sequential#compile model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) return model
def siamese_network(input_shape=(105, 105, 1), classes=1): """Network Architecture""" left_input = layers.Input(shape=input_shape) right_input = layers.Input(shape=input_shape) # Creating the convnet which shares weights between the left and right legs of Siamese network siamese_convnet = Sequential() siamese_convnet.add( layers.Conv2D(filters=64, kernel_size=10, strides=1, input_shape=input_shape, activation='relu', kernel_initializer=RandomNormal(mean=0, stddev=0.01), kernel_regularizer=l2(1e-2), bias_initializer=RandomNormal(mean=0.5, stddev=0.01))) siamese_convnet.add(layers.MaxPooling2D(pool_size=(2, 2))) siamese_convnet.add( layers.Conv2D(filters=128, kernel_size=7, strides=1, activation='relu', kernel_initializer=RandomNormal(mean=0, stddev=0.01), kernel_regularizer=l2(1e-2), bias_initializer=RandomNormal(mean=0.5, stddev=0.01))) siamese_convnet.add(layers.MaxPooling2D(pool_size=(2, 2))) siamese_convnet.add( layers.Conv2D(filters=128, kernel_size=4, strides=1, activation='relu', kernel_initializer=RandomNormal(mean=0, stddev=0.01), kernel_regularizer=l2(1e-2), bias_initializer=RandomNormal(mean=0.5, stddev=0.01))) siamese_convnet.add(layers.MaxPooling2D(pool_size=(2, 2))) siamese_convnet.add( layers.Conv2D(filters=256, kernel_size=4, strides=1, activation='relu', kernel_initializer=RandomNormal(mean=0, stddev=0.01), kernel_regularizer=l2(1e-2), bias_initializer=RandomNormal(mean=0.5, stddev=0.01))) siamese_convnet.add(layers.Flatten()) siamese_convnet.add( layers.Dense(4096, activation='sigmoid', kernel_initializer=RandomNormal(mean=0, stddev=0.2), kernel_regularizer=l2(1e-4), bias_initializer=RandomNormal(mean=0.5, stddev=0.01))) encoded_left_input = siamese_convnet(left_input) encoded_right_input = siamese_convnet(right_input) l1_encoded = layers.Lambda(lambda x: tf.abs(x[0] - x[1]))( [encoded_left_input, encoded_right_input]) output = layers.Dense(classes, activation='sigmoid', kernel_initializer=RandomNormal(mean=0, stddev=0.2), bias_initializer=RandomNormal( mean=0.5, stddev=0.01))(l1_encoded) return Model(inputs=[left_input, right_input], outputs=output)
for j in [4,8,16,32,64,128,256,512,1024]: accr = [] print(j) for i in range(1): kf = KFold(n_splits=10,shuffle = True,random_state = i+2) for train_index, test_index in kf.split(x): x_train, x_test = x[train_index], x[test_index] y_train, y_test = y_1h[train_index], y_1h[test_index] scaler = StandardScaler() scaler.fit(x_train) x_train = scaler.transform(x_train) x_test = scaler.transform(x_test) model = Sequential() model.add(Flatten()) model.add(Dense(j, activation='relu')) model.add(Dense(j, activation='relu')) model.add(Dense(3, activation='softmax')) model.compile(loss = 'categorical_crossentropy', optimizer = "adam", metrics = ['accuracy']) train = model.fit(x_train, y_train, # Training epochs=5, batch_size=1, validation_data=(x_test, y_test),verbose=0) test = model.evaluate(x_test,y_test) # Testing preds = model.predict(x_test) predict_class = np.argmax(preds, axis=1) true_class = np.argmax(y_test, axis=1)
daily_test = DM.daily_test_data(daily_test_df) fif_train = DM.fif_train_data(fif_train_df) fif_test = DM.fif_test_data(fif_test_df) target_train = DM.target_train_data(target_train_df) target_test = DM.target_test_data(target_test_df) wenben_long_term_train = DM.wenben_long_term_train_data(wenben_norm_train_df) wenben_short_term_train = DM.wenben_short_term_train_data(wenben_norm_train_df) wenben_long_term_test = DM.wenben_long_term_test_data(wenben_norm_test_df) wenben_short_term_test = DM.wenben_short_term_test_data(wenben_norm_test_df) print('文本数据', wenben_long_term_train) print('交易数据', daily_train) model = Sequential() model.add(LSTM(100, input_shape=(daily_train.shape[1], daily_train.shape[2]))) model.add(Dropout(0.02)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer=keras.optimizers.Adam(lr=1e-3), metrics=['acc']) # fit network history = model.fit(daily_train, target_train, epochs=epochs, batch_size=batch_size, validation_split=validation_split, shuffle=False) loss, accuracy = model.evaluate(daily_test, y=target_test)
return precision def f1_m(y_true, y_pred): precision = precision_m(y_true, y_pred) recall = recall_m(y_true, y_pred) return 2 * ((precision * recall) / (precision + recall + K.epsilon())) data_generator = ImageDataGenerator(preprocessing_function=preprocess_input) model = Sequential() model.add( tf.keras.applications.ResNet50(include_top=False, input_shape=(96, 96, 3), weights='imagenet', input_tensor=None, pooling='avg', classes=2)) model.add(tf.keras.layers.Flatten()) model.add(Dense(256, activation="relu")) model.add(Dense(1, activation="sigmoid")) model.layers[0].trainable = False model.compile(optimizer="sgd", loss='binary_crossentropy', metrics=['accuracy', f1_m, precision_m, recall_m]) model.summary() train_generator = data_generator.flow_from_directory( r'.\dataset\transferlearningdata\train', target_size=(96, 96), color_mode='rgb',
def create_classification_model(loss_func, learning_rate, dropout): model = Sequential() # Convolution and Maxpooling layers model.add(layers.Input((256, 256, 3))) # Convolution layer gets 32 filters of size (3x3) (filter size should be ann odd number) model.add(layers.Conv2D(32, (3, 3), activation='relu')) # Maxpooling layer get size (2, 2), with stride = pool size and padding = valid, meaning no zero padding is applied model.add(layers.MaxPooling2D((2, 2), strides=(2, 2), padding='valid')) # down samples the feature map model.add(layers.Conv2D(32, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(32, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(32, (3, 3), activation='relu')) # output shape after layer: (28,28,32) (size 25088) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(32, (3, 3), activation='relu')) # output shape after layer: (12,12,32) (size 4608) # Flatten output model.add(layers.Flatten()) # Add dense layers model.add(layers.Dense(64, activation='relu')) model.add(layers.Dropout(dropout)) model.add(layers.Dense(32, activation='relu')) model.add(layers.Dropout(dropout)) # The last layer is size 4 since we have four classes # Softmax activation is a standard for multi-class classification model.add(layers.Dense(4, activation='softmax')) opt = keras.optimizers.Adam(learning_rate=learning_rate) # The loss function is adapted for categorical classification and the accuracy metric is added model.compile(optimizer=opt, loss=loss_func, metrics=['accuracy']) return model
def convnet_size(optim, loss_func, n_conv_layers): """ The function builds a CNN. The optimizer, loss function and number of convolution layers are specified with the parameters. The minimal number of convolution layers is 1, each additional convolution layers is accompanied by a MaxPooling layer. :param optim: :param loss_func: :param n_conv_layers: :return: """ model = Sequential() # Convolution and Maxpooling layers model.add(layers.Input((256, 256, 3))) # Experimenting with the amount of convolution layers for i in range(n_conv_layers-1): model.add(layers.Conv2D(32, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2), strides=(2, 2), padding='valid')) model.add(layers.Conv2D(32, (3, 3), activation='relu')) # output shape after layer: (12,12,32) (size 4608) # Flatten output model.add(layers.Flatten()) # Add dense layers model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(1)) model.compile(optimizer=optim, loss=loss_func, metrics=['MeanSquaredError']) return model
def build_keras_rnn(sampling_rate, feature_num, using_seq_label: bool, rnn_out_dim=128, dropout_rate=0.5, rnn_type=C.LSTM, threshold=0.5) -> Sequential: """""" model_out = Sequential() # add RNN if rnn_type == C.LSTM: model_out.add( keras.layers.LSTM(units=rnn_out_dim, input_shape=[sampling_rate, feature_num], return_sequences=using_seq_label)) elif rnn_type == C.GRU: model_out.add( keras.layers.GRU(units=rnn_out_dim, input_shape=[sampling_rate, feature_num], return_sequences=using_seq_label)) elif rnn_type == C.LSTM_LSTM: # tutorial found here: https://machinelearningmastery.com/stacked-long-short-term-memory-networks/ model_out.add( keras.layers.LSTM(rnn_out_dim, return_sequences=True, input_shape=[sampling_rate, feature_num])) model_out.add( keras.layers.LSTM(rnn_out_dim, return_sequences=using_seq_label)) elif rnn_type == C.GRU_GRU: # tutorial found here: https://machinelearningmastery.com/stacked-long-short-term-memory-networks/ model_out.add( keras.layers.GRU(rnn_out_dim, return_sequences=True, input_shape=[sampling_rate, feature_num])) model_out.add( keras.layers.GRU(rnn_out_dim, return_sequences=using_seq_label)) else: raise NotImplementedError("RNN does not recognize {}".format(rnn_type)) # add FFNN if using_seq_label: # feed hidden state at each time step to the same FFNN # tutorial see: https://machinelearningmastery.com/timedistributed-layer-for-long-short-term-memory-networks-in-python/ model_out.add( TimeDistributed(Dropout(rate=dropout_rate, seed=C.RANDOM_SEED))) model_out.add( TimeDistributed(Dense(units=rnn_out_dim, activation='relu'))) model_out.add(TimeDistributed(Dense(1, activation='sigmoid'))) else: model_out.add(Dropout(rate=dropout_rate, seed=C.RANDOM_SEED)) model_out.add(Dense(units=rnn_out_dim, activation='relu')) model_out.add(Dense(1, activation='sigmoid')) # compile model model_out = compile_model(model_out, threshold) return model_out
def build_model(): model = Sequential() model.add( LSTM(units=60, activation='relu', return_sequences=True, input_shape=(X_train.shape[1], 5))) model.add(Dropout(0.2)) model.add(LSTM(units=60, activation='relu', return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(units=80, activation='relu', return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(units=120, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(units=1)) model.compile(optimizer='adam', loss='mean_squared_error') return model
def build_alexnet(num_classes, img_size): """ Build an AlexNet :param num_classes: number of classes :param img_size: image size as tuple (width, height, 3) for rgb and (widht, height) for grayscale :return: model """ from tensorflow.keras import Sequential from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense model = Sequential() model.add( Conv2D(32, (3, 3), padding='same', input_shape=img_size, activation='relu')) model.add(Conv2D(32, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Conv2D(128, (3, 3), padding='same', activation='relu')) model.add(Conv2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) return model
def build_lenet5(num_classes, img_size): from tensorflow.keras import Sequential from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense model = Sequential() model.add( Conv2D(filters=6, kernel_size=(3, 3), activation='relu', input_shape=img_size)) model.add(AveragePooling2D()) model.add(Conv2D(filters=16, kernel_size=(3, 3), activation='relu')) model.add(AveragePooling2D()) model.add(Flatten()) model.add(Dense(120, activation='relu')) model.add(Dense(84, activation='relu')) model.add(Dense(num_classes, activation='softmax')) return model
def build_NN(train_data, batch_size, dropout): ''' Define Model ''' regressior = Sequential() input_shape = (train_data.shape[1], train_data.shape[2]) regressior.add( LSTM(units=1024, activation='tanh', return_sequences=True, input_shape=input_shape)) regressior.add(Dropout(dropout)) regressior.add(Dense(units=1024, activation='tanh')) regressior.add(LSTM(units=512, activation='tanh', return_sequences=True)) regressior.add(Dropout(dropout)) regressior.add(LSTM(units=128, activation='tanh', return_sequences=False)) regressior.add(Dropout(dropout)) # regressior.add(Flatten()) # regressior.add(Dense(units=64, activation = 'tanh')) regressior.add(Dense(units=1, activation='tanh')) regressior.summary() # plot_model(regressior, "plot_model.png") return regressior
def model_mixer(train_data, batch_size, dropout, activation_case, layer_case, units_case): ''' Composed of four layers (excluding posterior Flatten and Dense layers) up to four Dense or up to ''' model = Sequential() input_shape = (train_data.shape[1], train_data.shape[2]) activation_dict = {0: 'relu', 1: 'tanh', 2: 'softmax', 3: 'exponential'} units_dict = {0: 40, 1: 60, 2: 80, 3: 100, 4: 120} first_layer_dict = { 0: 'model.add(LSTM(units = {}, activation = {}, return_sequences = True, input_shape = input_shape))', 1: 'model.add(TimeDistributed(Dense(units={}, activation = {}), input_shape = input_shape))' } second_layer_dict = { 0: 'model.add(LSTM(units = {}, activation = {}, return_sequences = True))', 1: 'model.add(TimeDistributed(Dense(units={}, activation = {})))' } third_layer_dict = { 0: 'model.add(LSTM(units = {}, activation = {}, return_sequences = True))', 1: 'model.add(TimeDistributed(Dense(units={}, activation = {})))', 2: None } # Add first layer first_layer = first_layer_dict.get(layer_case[0]) first_layer = first_layer.format(units_dict.get(units_case[0]), activation_dict.get(activation_case)) eval(first_layer) model.add(Dropout(dropout)) # Add second layer second_layer = second_layer_dict.get(layer_case[1]) second_layer = second_layer.format(units_dict.get(units_case[1]), activation_dict.get(activation_case)) eval(second_layer) model.add(Dropout(dropout)) # Add third layer third_layer = third_layer_dict.get(layer_case[2]) if third_layer is not None: third_layer = third_layer.format(units_dict.get(units_case[2]), activation_dict.get(activation_case)) eval(third_layer) model.add(Dropout(dropout)) # Add Flatten and Dense layers to all Models # model.add(Flatten()) model.add(Dense(units=1)) model.summary() return model
def create_model(MLP_C_layer, MLP_m_layer, low_C, up_C, low_m, up_m, F, a0RNN, batch_input_shape, selectaux, selectdk, myDtype, return_sequences=False, unroll=False): batch_adjusted_shape = (batch_input_shape[2] + 1, ) #Adding state placeHolder = Input(shape=(batch_input_shape[2] + 1, )) #Adding state filterLayer = inputsSelection(batch_adjusted_shape, selectaux)(placeHolder) filterdkLayer = inputsSelection(batch_adjusted_shape, selectdk)(placeHolder) MLP_C_min = low_C MLP_C_range = up_C - low_C MLP_C_layer = MLP_C_layer(filterLayer) C_layer = Lambda(lambda x: ((x * MLP_C_range) + MLP_C_min))(MLP_C_layer) MLP_m_min = low_m MLP_m_range = up_m - low_m MLP_m_layer = MLP_m_layer(filterLayer) MLP_scaled_m_layer = Lambda(lambda x: ((x * MLP_m_range) + MLP_m_min))( MLP_m_layer) dk_input_shape = filterdkLayer.get_shape() dkLayer = StressIntensityRange(input_shape=dk_input_shape, dtype=myDtype, trainable=False) dkLayer.build(input_shape=dk_input_shape) dkLayer.set_weights([np.asarray([F], dtype=dkLayer.dtype)]) dkLayer = dkLayer(filterdkLayer) ldK_layer = Lambda(lambda x: tf.math.log(x) / (tf.math.log(tf.constant(10.))))(dkLayer) dKm_layer = Multiply()([MLP_scaled_m_layer, ldK_layer]) aux_layer = Add()([C_layer, dKm_layer]) da_layer = Lambda(lambda x: 10**(x))(aux_layer) functionalModel = Model(inputs=[placeHolder], outputs=[da_layer]) "-------------------------------------------------------------------------" CDMCellHybrid = CumulativeDamageCell(model=functionalModel, batch_input_shape=batch_input_shape, dtype=myDtype, initial_damage=a0RNN) CDMRNNhybrid = RNN(cell=CDMCellHybrid, return_sequences=return_sequences, return_state=False, batch_input_shape=batch_input_shape, unroll=unroll) model = Sequential() model.add(CDMRNNhybrid) model.compile(loss='mse', optimizer=RMSprop(learning_rate=1e-6), metrics=['mae']) return model
y = fashion.iloc[:, 0] y.head() # input shape for sequential neural networks X.iloc[0].shape # code target variable (y) to categorical y_cat = to_categorical(y, num_classes=10) y_cat.shape # ### create a dense neural network with 6 layers m2 = Sequential() # add layers m2.add(Dense(units=50, activation='elu', input_shape=(784, ))) for i in range(4): m2.add(Dense(units=50, activation='elu')) m2.add(Dense(units=10, activation="softmax")) m2.compile(loss=tf.keras.losses.CategoricalCrossentropy(from_logits=False), optimizer='adam', metrics=['accuracy']) m2.summary() history2 = m2.fit(X, y_cat, batch_size=500, epochs=300, validation_split=0.2) # save model m2.save("Dense_layers_300.h5")
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 # Importing the Keras libraries and packages from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense, LSTM, Dropout # Initialising the RNN regressior = Sequential() # Adding the first LSTM layer and some Dropout regularisation regressior.add( LSTM(units=60, return_sequences=True, input_shape=(X_train.shape[1], 1))) regressior.add(Dropout(0.2)) # Adding a second LSTM layer and some Dropout regularisation regressior.add(LSTM(units=60, return_sequences=True)) regressior.add(Dropout(0.2)) # Adding a third LSTM layer and some Dropout regularisation regressior.add(LSTM(units=80, return_sequences=True)) regressior.add(Dropout(0.2)) # Adding a fourth LSTM layer and some Dropout regularisation regressior.add(LSTM(units=120)) regressior.add(Dropout(0.2)) # Adding the output layer
rnd = random.randint(0, df_reg.index.__len__(), 1000) df_reg = df_reg.iloc[rnd, :] # split into input and output columns X, y = df_reg.values[:, :-1], df_reg.values[:, -1] # split into train and test datasets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33) print(X_train.shape, X_test.shape, y_train.shape, y_test.shape) # determine the number of input features n_features = X_train.shape[1] # define model model = Sequential() model.add( Dense(20, activation='relu', kernel_initializer='he_normal', input_shape=(n_features, ))) model.add(Dense(16, activation='relu', kernel_initializer='he_normal')) model.add(Dense(1)) # compile the model model.compile(optimizer='adam', loss='mse') # fit the model history = model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0) # evaluate the model error = model.evaluate(X_test, y_test, verbose=0) print('MSE: %.3f, RMSE: %.3f' % (error, sqrt(error))) # make a prediction
print(X_train.shape, y_train.shape) unique_elements, counts_elements = np.unique(y_train, return_counts=True) print(np.asarray((unique_elements, counts_elements))) print('\n Testing Data') print(X_test.shape, y_test.shape) unique_elements, counts_elements = np.unique(y_test, return_counts=True) print(np.asarray((unique_elements, counts_elements))) """# **Creating a CNN**""" #input_shape=input_img model = Sequential() model.add( Conv2D(64, kernel_size=(5, 5), strides=(1, 1), activation='relu', input_shape=(223, 217, 3))) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) model.add(Dropout(0.5)) model.add(Conv2D(128, (5, 5), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dense(7, activation='softmax')) model.compile(loss=keras.losses.sparse_categorical_crossentropy, optimizer=keras.optimizers.SGD(lr=0.01), metrics=['accuracy'])
class CNNModel: def __init__(self): self.x_train = self.x_test = self.y_train = self.y_test = None self.history = None self.model = None self.model_dir = 'models/' def load_data(self): IMG = Image_Loader() [self.x_train, self.y_train, self.x_test, self.y_test] = IMG.load_images() print('Training and testing data loaded.') def build_model(self): x_shape = self.x_train[0].shape self.model = Sequential() self.model.add( layers.Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=x_shape)) self.model.add(layers.MaxPooling2D(2, 2)) self.model.add(layers.Dropout(0.2)) self.model.add( layers.Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=x_shape)) self.model.add(layers.MaxPooling2D(2, 2)) self.model.add(layers.Dropout(0.2)) self.model.add( layers.Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=x_shape)) self.model.add(layers.MaxPooling2D(2, 2)) self.model.add(layers.Dropout(0.2)) self.model.add(layers.Flatten()) self.model.add( layers.Dense(128, activation='relu', kernel_initializer='he_uniform')) self.model.add(layers.Dense(10, activation='sigmoid')) self.model.add(layers.Dropout(0.2)) self.model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam') self.model.summary() def train(self): num_epochs = 100 num_batches = 64 self.history = self.model.fit(self.x_train, self.y_train, batch_size=num_batches, epochs=num_epochs, validation_data=(self.x_test, self.y_test), callbacks=[TqdmCallback()]) def eval_model(self): try: score = self.model.evaluate(self.x_train, self.y_train) print("Training Loss: ", score[0]) print("Training Accuracy: ", score[1]) score = self.model.evaluate(self.x_test, self.y_test) print("Testing Loss: ", score[0]) print("Testing Accuracy: ", score[1]) if (self.history): plt.subplot(1, 2, 1) plt.plot(self.history.history['accuracy'], label='accuracy') plt.plot(self.history.history['val_accuracy'], label='val_accuracy') plt.title('Training and Validation Accuracy') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.ylim([0.7, 1]) plt.legend(loc='lower right') plt.subplot(1, 2, 2) plt.plot(self.history.history['loss'], label='loss') plt.plot(self.history.history['val_loss'], label='val_loss') plt.title('Training and Validation Loss') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.ylim([0.7, 1]) plt.legend(loc='upper right') except: if (self.x_train is None): print( 'Train and test data not loaded. Run CNNModel.load_data().' ) else: print( 'Please make sure train and test data are loaded correctly.' ) def load_image(self, image, url=0): # set url to 1 if image is from internet if url: resp = get(image) img_bytes = BytesIO(resp.content) img = load_img(img_bytes, target_size=(32, 32)) else: img = load_img(image, target_size=(32, 32)) img_pix = asarray(img) img_pix = img_pix.reshape(1, 32, 32, 3) img_pix = img_pix.astype('float32') img_pix = img_pix / 255.0 print('Image loaded.') return img_pix def predict(self, img_pix): y_pred = self.model.predict_classes(img_pix) y_prob = self.model.predict_proba(img_pix) y_pred = y_pred[0] y_prob = y_prob[0][y_pred] pred_dict = {'prediction': str(y_pred), 'confidence': str(y_prob)} return pred_dict def serialize(self, filename): file = self.model_dir + filename self.model.save(file, save_format='h5') print('Model saved.') def deserialize(self, filename): file = self.model_dir + filename model = tf.keras.models.load_model(file) self.model = model print('Model loaded.')
def create_model(loss_func, learning_rate, dropout): model = Sequential() # Convolution and Maxpooling layers model.add(layers.Input((256, 256, 3))) # Convolution layer gets 32 filters of size (3x3) (filter size should be ann odd number) model.add(layers.Conv2D(32, (3, 3), activation='relu')) # Maxpooling layer get size (2, 2), with stride = pool size and padding = valid, meaning no zero padding is applied model.add(layers.MaxPooling2D((2, 2), strides=(2, 2), padding='valid')) # down samples the feature map model.add(layers.Conv2D(32, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(32, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(32, (3, 3), activation='relu')) # output shape after layer: (28,28,32) (size 25088) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(32, (3, 3), activation='relu')) # output shape after layer: (12,12,32) (size 4608) # Flatten output model.add(layers.Flatten()) # Add dense layers model.add(layers.Dense(64, activation='relu')) model.add(layers.Dropout(dropout)) model.add(layers.Dense(32, activation='relu')) model.add(layers.Dropout(dropout)) # The last layer is size 1, since the output is a continuous value. Also, we do not specify an activation function # since it is a regression task and the y-values are not transformed model.add(layers.Dense(1)) opt = keras.optimizers.Adam(learning_rate=learning_rate) model.compile(optimizer=opt, loss=loss_func) return model
with open('validation_x.pickle', 'rb') as f: validation_x = pickle.load(f) with open('validation_y.pickle', 'rb') as f: validation_y = pickle.load(f) with open('train_x.pickle', 'rb') as f: train_x = pickle.load(f) with open('train_y.pickle', 'rb') as f: train_y = pickle.load(f) model = Sequential() model.add( CuDNNLSTM(128, input_shape=(train_x.shape[1:]), return_sequences=True)) model.add(Dropout(0.2)) model.add(BatchNormalization()) model.add( CuDNNLSTM(128, input_shape=(train_x.shape[1:]), return_sequences=True)) model.add(Dropout(0.1)) model.add(BatchNormalization()) model.add(CuDNNLSTM(128, input_shape=(train_x.shape[1:]))) model.add(Dropout(0.2)) model.add(BatchNormalization()) model.add(Dense(32, activation='relu')) model.add(Dropout(0.2))
args = parser.parse_args() trainX = [] trainY = [] testX = [] testY = [] ### Import data # Done if the network is told to Train if args.action.lower() == "train": data = pd.read_csv(dataset_path + "trimmed_" + args.type + ".csv", header=0, index_col=0) trainX,trainY,testX,testY = split_data(data) #collect data ##build model model = Sequential() model.add(LSTM(units=100, return_sequences= True, input_shape=(None,5))) #model.add(LSTM(units=30, return_sequences=True)) model.add(LSTM(units=100)) model.add(Dense(units=5 )) model.compile(optimizer='adam', loss='mean_squared_error', metrics = ['accuracy']) trained_model = train(model,trainX,trainY, 20) #train model model.save("/Users/samyakovlev/Desktop/"+args.type+"_model.h5") #save model per vessel type elif args.action.lower() == "test": model = load_model("/Users/samyakovlev/Desktop/"+args.type+"_model.h5") model.summary() # Quick output to show the model was loaded data = pd.read_csv(dataset_path + "trimmed_" + args.type + ".csv", header=0, index_col=0) trainX,trainY,testX,testY = split_data(data) # collect data
def buildCnnModel(self, kwargs_list, layer_orders, out_dim): """ convert a kwargs into a cnn model kwargs_list and layer_orders should have the same length """ cnn = Sequential() for i, lo in enumerate(layer_orders): kwargs = kwargs_list[i] if lo == "Dense": cnn.add(Dense(**kwargs)) elif lo == "Conv2D": cnn.add(Conv2D(**kwargs)) elif lo == "MaxPooling2D": cnn.add(MaxPooling2D(**kwargs)) elif lo == "Dropout": cnn.add(Dropout(**kwargs)) elif lo == "Flatten": cnn.add(Flatten()) cnn.add(Dense(out_dim, activation='softmax')) kwargs = kwargs_list[-1] cnn.compile(metrics=['accuracy'], **kwargs["Compile"]) return cnn
train_correlated = train[col_mask] #Data samples inputs = train_correlated.drop('SalePrice', axis='columns') targets = train["SalePrice"] train_id = train["Id"] test_id = test['Id'] test_inputs = test[inputs.columns] ### Model ### model = Sequential() model.add(Dense(10, activation='relu')) model.add(Dense(300, activation='relu')) model.add(Dense(500, activation='relu')) model.add(Dense(100, activation='relu')) model.add(Dense(1, activation='linear')) model.compile(loss='MSE', optimizer=Adam(learning_rate=LEARN_RATE), metrics=['accuracy']) ### Training ## history = model.fit(inputs, targets, validation_split=VAL_SPLIT, epochs=EPOCHS) plt.figure()
# Note: unlike numpy, we cannot simply assign a zeros array first, # because we are not allowed to assign afterwards to the Tensor, # so we just initialize by treating j==0 separately for j in range(self.kernel_size): if j==0: z=self.w[j]*tf.roll(inputs,shift=j-j0,axis=1) else: z+=self.w[j]*tf.roll(inputs,shift=j-j0,axis=1) return z # In[3]: Net=Sequential() Net.add(PeriodicConvolution(kernel_size=3)) Net.compile(loss='mean_square_error', optimizer='adam') # In[4]: y_in=np.array([[0.,0.,3.,0.,0.]]) # In[5]: y_out=Net.predict_on_batch(y_in) print(y_out)
def create_model(training_data, training_labels): print('Creating new model ...') model = Sequential() model.add( layers.Conv2D( 32, (2, 2), activation='relu', #Or training_data.shape[1], training_data.shape[2] input_shape=(FREQ_BINS, TIME_PERIODS, 1))) model.add(layers.MaxPooling2D(2, 2)) model.add(layers.Conv2D(64, (2, 2), activation='relu')) model.add(layers.MaxPooling2D(2, 2)) model.add(layers.Conv2D(128, (2, 2), activation='relu')) model.add(layers.MaxPooling2D(2, 2)) model.add(layers.Flatten()) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(2, activation='softmax')) # model.summary() model.compile(loss='sparse_categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) history = model.fit(training_data, training_labels, epochs=10, verbose=1) print('Done training ...') model.save('ml/model/trained_model/CNN_COUGH_COVID_DETECTOR_MODEL_tf', save_format='tf') print('Model saved ...') #Add log file containing: Size of training data, accuracy and other metrics log.modelLogs(history=history, size=training_data.shape[0]) print('Log created ...')
NAME = "{}-conv-{}-nodes-{}-dense-{}-epochs-{}-kernel-{}".format( conv_layers, layer_sizes, dense_layers, EPOCHS, KERNEL_SIZE, int(time.time())) tboard_dir = os.path.join("logs", NAME) tensorboard = TensorBoard(log_dir=tboard_dir) earlystop_callback = EarlyStopping( monitor='val_accuracy', min_delta=0.01, patience=5) model = Sequential() model.add(Convolution2D(layer_sizes, KERNEL_SIZE, input_shape=train_X.shape[1:], activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(layer_sizes, KERNEL_SIZE, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(layer_sizes, KERNEL_SIZE, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(layer_sizes, KERNEL_SIZE, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dense(256, activation='relu'))
# You might very well be needing it! # Remeber to save only what is worth it from validation perspective... # model_saver = ModelCheckpoint(...) # If you need it... #def schedule(epoch, lr): # ... # return lr #lr_scheduler = LearningRateScheduler(schedule) # Build your whole LSTM model here! model = Sequential() model.add(CuDNNLSTM(LSTM_CELL_SIZE, input_shape=(TIME_WINDOW,column_count),stateful=False)) model.add(Dense(1, activation= "linear")) #For shape remeber, we have a variable defining the "window" and the features in the window... model.compile(loss='mean_squared_error', optimizer='sgd') # Fit on the train data # USE the batch size parameter! # Use validation data - warning, a tuple of stuff! # Epochs as deemed necessary... # You should avoid shuffling the data maybe. # You can use the callbacks for LR schedule or model saving as seems fit. history = model.fit(X_train_rolled, y_train_rolled, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_data=(X_valid_rolled ,y_valid_rolled), shuffle=False)
def model_OrderPrediction_SIAMESE(the_input_shape, units_dense_layers_1, units_dense_layers_2, dropout_rate_1, dropout_rate_2, learning_rate, momentum): # Se definen las 4 entradas del modelo input_1 = Input(shape=the_input_shape) input_2 = Input(shape=the_input_shape) input_3 = Input(shape=the_input_shape) input_4 = Input(shape=the_input_shape) #CaffeNet base_model = Sequential(name='CaffeNet') base_model.add( Conv2D(filters=96, kernel_size=(11, 11), strides=(4, 4), padding='valid', data_format='channels_last', activation='relu', input_shape=the_input_shape, name='Conv2D_1_CaffeNet')) base_model.add( MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid', data_format='channels_last', name='MaxPooling2D_1_CaffeNet')) base_model.add(BatchNormalization()) base_model.add( Conv2D(filters=256, kernel_size=(5, 5), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_2_CaffeNet')) base_model.add( MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid', data_format='channels_last', name='MaxPooling2D_2_CaffeNet')) base_model.add(BatchNormalization()) base_model.add( Conv2D(filters=384, kernel_size=(3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_3_CaffeNet')) base_model.add( Conv2D(filters=384, kernel_size=(3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_4_CaffeNet')) base_model.add( Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_5_CaffeNet')) base_model.add( MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid', data_format='channels_last', name='MaxPooling2D_3_CaffeNet')) # Las 4 entradas son pasadas a través del modelo base (calculo de las distintas convoluciones) output_1 = base_model(input_1) output_2 = base_model(input_2) output_3 = base_model(input_3) output_4 = base_model(input_4) flatten = Flatten(name='Flatten_OrderPrediction') # Se obtienen los vectores de características de las 4 entradas features_1 = flatten(output_1) features_2 = flatten(output_2) features_3 = flatten(output_3) features_4 = flatten(output_4) # Capa densa utilizada para resumir las caracteristicas extraidas de las capas convolucionales para cada frame dense_1 = Dense(units=units_dense_layers_1, activation='relu', name='FC_1_OrderPrediction') features_1 = dense_1(features_1) features_2 = dense_1(features_2) features_3 = dense_1(features_3) features_4 = dense_1(features_4) dropout_1 = Dropout(dropout_rate_1, name='Dropout_1_OrderPrediction') features_1 = dropout_1(features_1) features_2 = dropout_1(features_2) features_3 = dropout_1(features_3) features_4 = dropout_1(features_4) Features_12 = concatenate([features_1, features_2]) Features_13 = concatenate([features_1, features_3]) Features_14 = concatenate([features_1, features_4]) Features_23 = concatenate([features_2, features_3]) Features_24 = concatenate([features_2, features_4]) Features_34 = concatenate([features_3, features_4]) # Capa densa que aprende la relación entre las características de los distintos fotogramas dense_2 = Dense(units=units_dense_layers_2, activation='relu', name='FC_2_OrderPrediction') RelationShip_1_2 = dense_2(Features_12) RelationShip_1_3 = dense_2(Features_13) RelationShip_1_4 = dense_2(Features_14) RelationShip_2_3 = dense_2(Features_23) RelationShip_2_4 = dense_2(Features_24) RelationShip_3_4 = dense_2(Features_34) dropout_2 = Dropout(dropout_rate_2, name='Dropout_2_OrderPrediction') RelationShip_1_2 = dropout_2(RelationShip_1_2) RelationShip_1_3 = dropout_2(RelationShip_1_3) RelationShip_1_4 = dropout_2(RelationShip_1_4) RelationShip_2_3 = dropout_2(RelationShip_2_3) RelationShip_2_4 = dropout_2(RelationShip_2_4) RelationShip_3_4 = dropout_2(RelationShip_3_4) # Concatenación de todas las relaciones Features_Final = concatenate([ RelationShip_1_2, RelationShip_1_3, RelationShip_1_4, RelationShip_2_3, RelationShip_2_4, RelationShip_3_4 ]) prediction = Dense(units=12, activation='softmax', name='FC_Final_OrderPrediction')(Features_Final) siamese_model = Model(inputs=[input_1, input_2, input_3, input_4], outputs=prediction) siamese_model.summary() optimizer = SGD(learning_rate=learning_rate, momentum=momentum) siamese_model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy']) return siamese_model
from tensorflow.keras.datasets import imdb from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense, Embedding, Flatten from tensorflow.keras import preprocessing import tensorflow as tf max_features = 10000 max_len = 20 (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features) x_train = preprocessing.sequence.pad_sequences(x_train, maxlen=max_len) x_test = preprocessing.sequence.pad_sequences(x_test, maxlen=max_len) model = Sequential() model.add(Embedding(10000, 8, input_length=max_len)) model.add(Flatten()) model.add(Dense(1, activation='softmax')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) model.summary() tf_callback = tf.keras.callbacks.TensorBoard(log_dir='logs') history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2, callbacks=[tf_callback])
class ExpertApprenticeAgent(Agent): def __init__( self, max_iteration: int, action_space_size: int, keep_memory: bool = True, apprentice_training_before_takeover: int = 100, ): self.max_iteration = max_iteration self.keep_memory = keep_memory self.memory = dict() self.brain = Sequential() self.brain.add(Dense(64, activation=relu)) self.brain.add(Dense(64, activation=relu)) self.brain.add(Dense(64, activation=relu)) self.brain.add(Dense(action_space_size, activation=softmax)) self.brain.compile(optimizer=Adam(), loss=mse) self.apprentice_training_before_takeover = apprentice_training_before_takeover self.apprentice_training_count = 0 self.states_buffer = [] self.actions_buffer = [] @staticmethod def create_node_in_memory(memory, node_hash, available_actions, current_player): memory[node_hash] = [ {"r": 0, "n": 0, "np": 0, "a": a, "p": current_player} for a in available_actions ] @staticmethod def ucb_1(edge): return edge["r"] / edge["n"] + sqrt(2 * log(edge["np"]) / edge["n"]) def act(self, gs: GameState) -> int: if self.apprentice_training_count > self.apprentice_training_before_takeover: return gs.get_available_actions(gs.get_active_player())[ np.argmax( self.brain.predict(np.array([gs.get_vectorized_state()]))[0][ gs.get_available_actions(gs.get_active_player()) ] ) ] root_hash = gs.get_unique_id() memory = self.memory if self.keep_memory else dict() if root_hash not in memory: ExpertApprenticeAgent.create_node_in_memory( memory, root_hash, gs.get_available_actions(gs.get_active_player()), gs.get_active_player(), ) for i in range(self.max_iteration): gs_copy = gs.clone() s = gs_copy.get_unique_id() history = [] # SELECTION while not gs_copy.is_game_over() and all( (edge["n"] > 0 for edge in memory[s]) ): chosen_edge = max( ((edge, ExpertApprenticeAgent.ucb_1(edge)) for edge in memory[s]), key=lambda kv: kv[1], )[0] history.append((s, chosen_edge)) gs_copy.step(gs_copy.get_active_player(), chosen_edge["a"]) s = gs_copy.get_unique_id() if s not in memory: ExpertApprenticeAgent.create_node_in_memory( memory, s, gs_copy.get_available_actions(gs_copy.get_active_player()), gs_copy.get_active_player(), ) # EXPANSION if not gs_copy.is_game_over(): chosen_edge = choice( list(filter(lambda e: e["n"] == 0, (edge for edge in memory[s]))) ) history.append((s, chosen_edge)) gs_copy.step(gs_copy.get_active_player(), chosen_edge["a"]) s = gs_copy.get_unique_id() if s not in memory: ExpertApprenticeAgent.create_node_in_memory( memory, s, gs_copy.get_available_actions(gs_copy.get_active_player()), gs_copy.get_active_player(), ) # SIMULATION while not gs_copy.is_game_over(): gs_copy.step( gs_copy.get_active_player(), choice(gs_copy.get_available_actions(gs_copy.get_active_player())), ) scores = gs_copy.get_scores() # REMONTEE DU SCORE for (s, edge) in history: edge["n"] += 1 edge["r"] += scores[edge["p"]] for neighbour_edge in memory[s]: neighbour_edge["np"] += 1 target = np.zeros(gs.get_action_space_size()) for edge in memory[root_hash]: target[edge["a"]] = edge["n"] target /= np.sum(target) self.states_buffer.append(gs.get_vectorized_state()) self.actions_buffer.append(target) if len(self.states_buffer) > 200: self.apprentice_training_count += 1 self.brain.fit( np.array(self.states_buffer), np.array(self.actions_buffer), verbose=0 ) self.states_buffer.clear() self.actions_buffer.clear() if self.apprentice_training_count > self.apprentice_training_before_takeover: print("Apprentice is playing next round") return max((edge for edge in memory[root_hash]), key=lambda e: e["n"])["a"] def observe(self, r: float, t: bool, player_index: int): pass def save_model(self, filename: str): self.brain.save(f"{filename}.h5") def load_model(self, filename: str): self.brain = load_model(filename)