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
class DeepLearningModel: def __init__(self, FREQUENCY, TARGET_FREQUENCY): print(tf.version) self.FREQUENCY = FREQUENCY self.TARGET_FREQUENCY = TARGET_FREQUENCY self.DOWNSAMPLE = int(FREQUENCY/TARGET_FREQUENCY) print(self.DOWNSAMPLE) self.scale = [1024, 1024, 1024] self.mean = [0, 0, 0] self.Fs = self.TARGET_FREQUENCY #Samples per second self.Seconds = 2 # Seconds the frame covers self.frame_size = self.Fs*self.Seconds self.hop_size = 10 # The movement of the frame this results in overlapping data def create_save_and_ready_dataset(self): self.create_dataset() self.save_dataset() # takes a list of file paths to training data def create_dataset(self, files): self.datasets = self.preprocess_files(files) self.X, self.Y = self.create_frames(self.datasets[0], self.frame_size, self.hop_size) for i in range(1,len(self.datasets)): temp_x, temp_y = self.create_frames(self.datasets[i], self.frame_size, self.hop_size) self.X = np.append(self.X, temp_x, axis=0) self.Y = np.append(self.Y, temp_y) def save_dataset(self): np.save('serial_dataset_x.npy', self.X) np.save('serial_dataset_y.npy', self.Y) print('shapes: ', self.X.shape, self.Y.shape) def load_dataset(self): self.Y = np.load('serial_dataset_y.npy') self.X = np.load('serial_dataset_x.npy') print('X and Y loaded from files, shapes: ', self.X.shape, self.Y.shape) def load_and_ready_datasets(self): self.load_dataset() self.ready_datasets() def ready_datasets(self): # Here we are dividing the data into training data and test data using train_test_split() from sklearn # which we have already imported. We are going to use 80% of the data for training the model and 20% of the data for testing. # random_state controls the shuffling applied to the data before applying the split. stratify = y splits the data in a stratified fashion, using y as the class labels. self.X_train, self.X_val, self.Y_train, self.Y_val = train_test_split(self.X, self.Y, test_size = 0.95, random_state = 0, stratify = self.Y) self.X_val, self.X_test, self.Y_val, self.Y_test = train_test_split(self.X_val, self.Y_val, test_size = 0.8, random_state = 0, stratify = self.Y_val) print(self.X_train.shape)#Prints train dataset size print(self.X_val.shape)#Prints test dataset size # A CNN only accepts 3 dimentional data so we are going to reshape() our data and just a dimension with a constant value. self.X_train = self.X_train.reshape(self.X_train.shape + (1, )) self.X_val = self.X_val.reshape(self.X_val.shape + (1, )) self.X_test = self.X_test.reshape(self.X_test.shape + (1, )) def create_model(self): n_activities = len(np.unique(self.Y)) ## Create the model self.model = Sequential() self.model.add(Conv2D(4, (3, 1), activation = 'relu', input_shape = (100, 3, 1))) self.model.add(Dropout(0.1)) self.model.add(Conv2D(4, (2, 2), activation='relu')) self.model.add(Dropout(0.2)) self.model.add(Flatten()) self.model.add(Dense(8, activation = 'relu')) self.model.add(Dropout(0.5)) self.model.add(Dense(n_activities, activation='softmax')) def train(self, epochs, plot): #Here we are compiling the model and fitting it to the training data. We will use 200 epochs to train the model. #An epoch is an iteration over the entire data provided. validation_data is the data on which to evaluate the loss and any model metrics at the end of each epoch. #The model will not be trained on this data. As metrics = ['accuracy'] the model will be evaluated based on the accuracy. self.epochs = epochs lr_schedule = keras.optimizers.schedules.ExponentialDecay(initial_learning_rate=1e-4, decay_steps=10000, decay_rate=0.9) self.model.compile(optimizer=Adam(learning_rate = lr_schedule), loss = 'sparse_categorical_crossentropy', metrics = ['accuracy']) self.history = self.model.fit(self.X_train, self.Y_train, epochs = self.epochs, validation_data=(self.X_val, self.Y_val), verbose=1) if plot: # Plot training & validation accuracy values epoch_range = range(1, self.epochs+1) plt.plot(epoch_range, self.history.history['accuracy']) plt.plot(epoch_range, self.history.history['val_accuracy']) plt.title('Model accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Train', 'Val'], loc='upper left') plt.show() # Plot training & validation loss values plt.plot(epoch_range, self.history.history['loss']) plt.plot(epoch_range, self.history.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'Val'], loc='upper left') plt.show() def save_model(self, name: str): self.model.save(name) def load_model(self, name: str): self.model = tf.keras.models.load_model(name) def compile_tflite_model(self, name: str): MODELS_DIR = name+ '/' if not os.path.exists(MODELS_DIR): os.mkdir(MODELS_DIR) MODEL_TF = 'name' MODEL_NO_QUANT_TFLITE = MODELS_DIR + name + '_no_quant.tflite' MODEL_TFLITE = MODELS_DIR + name + '.tflite' MODEL_TFLITE_MICRO = MODELS_DIR + name + '.cc' # Convert the model to the TensorFlow Lite format without quantization converter = tf.lite.TFLiteConverter.from_saved_model(name) converter.optimizations = [] model_no_quant_tflite = converter.convert() # Save the model to disk open(MODEL_NO_QUANT_TFLITE, "wb").write(model_no_quant_tflite) #size_tf = os.path.getsize(MODEL_TF) #print(size_tf) size_no_quant_tflite = os.path.getsize(MODEL_NO_QUANT_TFLITE) print('Size of file ' + str(size_no_quant_tflite) + ' bytes') c_model_name = name with open(c_model_name + '.h', 'w') as file: file.write(self.hex_to_c_array(model_no_quant_tflite, c_model_name)) def hex_to_c_array(self, hex_data, var_name): c_str = '' # Create header guard c_str += '#ifndef ' + var_name.upper() + '_H\n' c_str += '#define ' + var_name.upper() + '_H\n\n' # Add array length at top of file c_str += '\nunsigned int ' + var_name + '_len = ' + str(len(hex_data)) + ';\n' # Declare C variable c_str += 'unsigned char ' + var_name + '[] = {' hex_array = [] for i, val in enumerate(hex_data) : # Construct string from hex hex_str = format(val, '#04x') # Add formatting so each line stays within 80 characters if (i + 1) < len(hex_data): hex_str += ',' if (i + 1) % 12 == 0: hex_str += '\n ' hex_array.append(hex_str) # Add closing brace c_str += '\n ' + format(' '.join(hex_array)) + '\n};\n\n' # Close out header guard c_str += '#endif //' + var_name.upper() + '_H' return c_str def create_train_and_save_model(self, epochs, name: str, plot=False): self.create_model() self.train(epochs, plot) self.save_model(name) def confusion_matrix(self): Y_pred = self.model.predict_classes(self.X_test) array = ['Walking', 'Running'] mat = confusion_matrix(self.Y_test, Y_pred) plot_confusion_matrix(conf_mat=mat, class_names= array, show_normed=True, figsize=(3,3)) plt.show() def predict(self, inp): print('predicting with shape', inp.shape) return self.model.predict(inp) def preprocess_files(self, filenames): datasets = [] for f in filenames: datasets.extend(self.preprocess_file(f)) return datasets def preprocess_file(self, filename): x = [] y = [] z = [] t = [] datasets = [] print(filename) f = open(filename, "r") for i,line in enumerate(f): try: split = line.split(',') if (len(split) >= 4) and i > self.FREQUENCY*10: x.append((int(split[0]) - self.mean[0])/self.scale[0]) y.append((int(split[1]) - self.mean[1])/self.scale[1]) z.append((int(split[2]) - self.mean[2])/self.scale[2]) t.append(int(split[3])) else: # split data df = pd.DataFrame() df["type"] = t df["x"] = x df["y"] = y df["z"] = z x = [] y = [] z = [] t = [] # downsample the dataframe if len(df)/self.FREQUENCY > 5: for j in range(self.DOWNSAMPLE): downsampled = df.iloc[j::self.DOWNSAMPLE, :] datasets.append(downsampled) except: print('error') f.close() return datasets def create_frames(self, df, frame_size, hop_size): N_FEATURES = 3 # Amount of inputs 3 because x, y, z, frames = [] labels = [] for i in range(0, len(df) - frame_size, hop_size): x = df['x'].values[i: i + frame_size] y = df['y'].values[i: i + frame_size] z = df['z'].values[i: i + frame_size] # Retrieve the most often used label in this segment label = stats.mode(df['type'][i: i + frame_size])[0][0] if len(x)==frame_size: frames.append([x, y, z]) labels.append(label) # Bring the segments into a better shape frames = np.asarray(frames).transpose((0, 2, 1)) labels = np.asarray(labels) return frames, labels
# 모델 생성 model=Sequential() model.add(LSTM(units=50,activation="relu",return_sequences=True,input_shape=(window_size, data_size))) model.add(Dropout(0.2)) model.add(LSTM(units=60,activation="relu",return_sequences=True)) model.add(Dropout(0.3)) model.add(LSTM(units=80,activation="relu",return_sequences=True)) model.add(Dropout(0.4)) model.add(LSTM(units=120,activation="relu")) model.add(Dropout(0.5)) model.add(Dense(units=1)) model.summary() model.compile(optimizer='adam', loss='mean_squared_error',metrics=['accuracy']) model.fit(train_x, train_y, epochs=200, batch_size=30) pred_y = model.predict(test_x) # print('##### Test Result #####') # print('loss : ',str(loss_and_metrics[0])) # print('Accuracy : ',str(loss_and_metrics[1])) from sklearn.metrics import mean_squared_error rmse = np.sqrt(mean_squared_error(test_y, pred_y)) print(f"RMSE 값 : {rmse}") # sklearn은 mse만 지원하기 때문에 rmse와 rmsle는 직접 만들어야 합니다. # y_preds는 예측값들이 담긴 데이터, y_test는 실제값 데이터들입니다.
model = Sequential([ baseModel, AveragePooling2D(pool_size=(7, 7)), Flatten(name="flatten"), Dense(128, activation="relu"), Dropout(0.5), Dense(2, activation="softmax") ]) model.summary() # compilation print("[INFO] compiling model...") optimizer = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS) model.compile(loss="binary_crossentropy", optimizer=optimizer, metrics=["accuracy"]) # training print("[INFO] training head...") H = model.fit_generator(train.flow(trainX, trainY, batch_size=BATCH_SIZE), steps_per_epoch=len(trainX) // BATCH_SIZE, validation_data=(testX, testY), validation_steps=len(testX) // BATCH_SIZE, epochs=EPOCHS) # save the model print("[INFO] saving mask detector model...") model.save("MaskDetector.model", save_format="h5") N = EPOCHS
train_univariate = Dataset.from_tensor_slices((datasets_train, labels_train)) train_univariate = train_univariate.shuffle(BUFFER_SIZE).batch( BATCH_SIZE).repeat() val_univariate = Dataset.from_tensor_slices((datasets_test, labels_test)) val_univariate = val_univariate.batch(BATCH_SIZE).repeat() model = Sequential() model.add(layers.Dense(input_interval, input_shape=(input_interval, ))) model.add(layers.Dense(input_interval)) model.add(layers.Dense(int(input_interval / 2))) model.add(layers.Dense(1)) model.compile(optimizer='SGD', loss='mean_squared_error') model.fit(train_univariate, epochs=400, steps_per_epoch=10, validation_data=val_univariate, validation_steps=10) train_predictions = np.array( [value[0] for value in model.predict(datasets_train)]) train_labels_ = np.array([value[0] for value in labels_train]) train_x_arr = x_arr[input_interval + output_offset:train_length] test_predictions = np.array( [value[0] for value in model.predict(datasets_test)]) test_labels_ = np.array([value[0] for value in labels_test])
smooth = 1. def dice_coef(y_true, y_pred): y_true_f = flatten(y_true) y_pred_f = flatten(y_pred) intersection = K.sum(y_true_f * y_pred_f) return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth) from tensorflow.keras.layers import Conv2D from tensorflow.keras import Sequential model = Sequential() model.add( Conv2D(16, 3, activation='relu', padding='same', input_shape=(320, 480, 9)) ) model.add( Conv2D(32, 3, activation='relu', padding='same') ) model.add( Conv2D(1, 5, activation='sigmoid', padding='same') ) model.compile(optimizer = 'Adam', loss = BinaryCrossentropy(), metrics=['accuracy',dice_coef]) print(model.summary()) # Include the epoch in the file name (uses `str.format`) checkpoint_path = "G:/Github/Caravan_challenge/training_tf/naive_org/cp-{epoch:04d}.ckpt" checkpoint_dir = os.path.dirname(checkpoint_path) # Create a callback that saves the model's weights every 5 epochs cp_callback = tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_path, verbose=1, save_weights_only=False, save_freq='epoch') model.fit(X_train, y_train, epochs=15, validation_data=(X_val, y_val), batch_size=5, verbose=2)
sample = next(iter(db)) print(sample[0].shape, sample[1].shape) network = Sequential([ layers.Dense(256, activation='relu'), layers.Dense(128, activation='relu'), layers.Dense(64, activation='relu'), layers.Dense(32, activation='relu'), layers.Dense(10) ]) network.build(input_shape=(None, 28 * 28)) network.summary() network.compile(optimizer=optimizers.Adam(lr=0.01), loss=tf.losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy']) network.fit(db, epochs=3, validation_data=ds_val, validation_freq=2) network.evaluate(ds_val) #保存整个模型 network.save('model.h5') print('saved total model.') del network #删除模型 print('loaded model from file.') network = tf.keras.models.load_model('model.h5', compile=False) network.compile(optimizer=optimizers.Adam(lr=0.01), loss=tf.losses.CategoricalCrossentropy(from_logits=True),
print(x.shape, y.shape) db = tf.data.Dataset.from_tensor_slices((x, y)) db = db.map(preprocess).shuffle(10000).batch(256) db_test = tf.data.Dataset.from_tensor_slices((x_test, y_test)) db_test = db_test.map(preprocess).shuffle(10000).batch(256) db_iter = iter(db) sample = next(db_iter) print('batch:', sample[0].shape, sample[1].shape) network = Sequential([ layers.Dense(256, activation=tf.nn.relu), #[b, 784] => [b, 256] layers.Dense(128, activation=tf.nn.relu), # [b, 256] => [b, 128] layers.Dense(64, activation=tf.nn.relu), # [b, 128] => [b, 64] layers.Dense(32, activation=tf.nn.relu), # [b, 64] => [b, 32] # layers.Dense(16, activation=tf.nn.relu), # [b, 32] => [b, 16] # 尝试加一层 layers.Dense(10, activation=tf.nn.relu), # [b, 32] => [b, 10] ]) network.build(input_shape=[None, 28 * 28]) network.summary() network.compile(optimizer=optimizers.Adam(lr=1e-3), loss=tf.losses.MSE, metrics=['accuracy']) network.fit(db, epochs=10, validation_data=db_test, validation_freq=2) network.save('./model.h5')
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])
BatchNormalization(), ReLU(), Dropout(0.1), Dense(64, use_bias=False), BatchNormalization(), ReLU(), Dropout(0.1), Dense(32, use_bias=False), BatchNormalization(), ReLU(), Dropout(0.1), Dense(Dout) ]) # compile model w/ MAE loss, adam optimizer model.compile(tf.keras.optimizers.Adam(lr=L_RATE), loss='mean_absolute_error') # Fit the model history = model.fit(X, y, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_split=VAL_SPLIT, verbose=1) # validation error over training plt.plot(history.history['loss'], label='Train') plt.plot(history.history['val_loss'], label='Val') plt.legend() plt.xlabel('Epoch') plt.ylabel('MAE')
# 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)
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)) model.add(Dense(2, activation='softmax')) opt = tf.keras.optimizers.Adam(lr=0.001, decay=1e-6) model.compile(loss='sparse_categorical_crossentropy', optimizer=opt, metrics=['accuracy']) history = model.fit(train_x, train_y, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_data=(validation_x, validation_y))
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.')
model ]) plt.figure(figsize=(10, 10)) for i in range(9): plt.subplot(3, 3, i + 1) aug_img = model_(tf.expand_dims(x_train[i], 0)) plt.imshow(aug_img[0, ...].numpy()) plt.grid(False) plt.axis("off") plt.title(class_names[y_train[i].item()]) plt.show() model_.compile( optimizer="Adam", loss = 'sparse_categorical_crossentropy', metrics=['accuracy'] ) train_dataset = train_dataset.batch(16) model_.fit(train_dataset, epochs = 1) tensorflow.keras.layers.experimental.preprocessing - Normalization - RandomFlip("horizontal"), - RandomRotation(0.1), - RandomZoom(0.1),
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 row = [ 100000.0, 85.0, 39.0, 652.0, le_occupancy_status.transform(['I'])[0], le_property_state.transform(['NJ'])[0] ]
test_input[:, :, i] = col_test_input test_target[:, i] = col_test_target print(f"Train input:target shape = {train_input.shape}:{train_target.shape}") print(f"Test input:target shape = {test_input.shape}:{test_target.shape}") # Input has to be in form [samples, time steps, sel_features] # - Samples. One sequence is one sample. A batch is comprised of one or more samples. # - Time Steps. One time step is one point of observation in the sample. # - Features. One feature is one observation at a time step. # create and fit the LSTM network model = Sequential() model.add(LSTM(4, input_shape=(LOOK_BACK, n_features))) model.add(Dense(n_features)) model.compile(loss='mean_squared_error', optimizer='adam') model.summary() model.fit(train_input, train_target, epochs=EPOCHS, batch_size=BATCH_SIZE, verbose=VERBOSE) # make predictions train_predict = model.predict(train_input) test_predict = model.predict(test_input) # invert predictions train_predict = scaler.inverse_transform(train_predict) train_target = scaler.inverse_transform(train_target) test_predict = scaler.inverse_transform(test_predict) test_target = scaler.inverse_transform(test_target)
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 regressior.add(Dense(units=1)) # Compiling the RNN regressior.compile(optimizer='nadam', loss='mean_squared_error') # Fitting the RNN to the Training set history = regressior.fit(X_train, y_train, epochs=120, batch_size=39) # Part 3 - Making the predictions and visualising the results # Getting the real traffic values of Cell_000112 dataset_test = pd.read_csv('Datasets/Cell_000231/test_Cell000231.csv') date_only = dataset_test.drop(['Traffic'], axis=1) past_24_hours = dataset.tail(24) df = past_24_hours.append(dataset_test, ignore_index=True) df = df.drop(['DateTime'], axis=1) # Getting the predicted traffic values of Cell_000112 inputs = scaler.fit_transform(df)
padding='same'), MaxPooling2D(), GaussianNoise(.2), Conv2D(64, (3, 3), activation='relu', padding='same'), MaxPooling2D(), # Conv2D(128, (3, 3), activation='relu'), # MaxPooling2D(), # Conv2D(256, (3, 3), activation='relu'), # MaxPooling2D(), # Dropout(0.2), Flatten(), Dense(size, activation='softmax'), ]) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) print("\nNetwork:") print(model.summary()) # x_train, y_train, x_test, y_test = seed.load_data('data.npz') x_train, y_train = seed.create_data(50000) x_test, y_test = seed.create_data(10000) print("\nData example:") print(x_train[0]) x_train = x_train.reshape((-1, 28, 28, 1)).astype('float32') x_test = x_test.reshape((-1, 28, 28, 1)).astype('float32') x_train /= 255.0
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']) # model.compile(loss=keras.losses.sparse_categorical_crossentropy, # optimizer='adam', # metrics=['accuracy']) model.summary() class AccuracyHistory(keras.callbacks.Callback): def on_train_begin(self, logs={}): self.acc = [] def on_epoch_end(self, batch, logs={}): self.acc.append(logs.get('acc'))
X, y = make_circles(n_samples=1000, noise=0.1, random_state=1) # change y from {0,1} to {-1,1} y[where(y == 0)] = -1 # split into train and test n_train = 500 trainX, testX = X[:n_train, :], X[n_train:, :] trainy, testy = y[:n_train], y[n_train:] # define model - use tanh for activation, use hingeloss model = Sequential() model.add( Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform')) model.add(Dense(1, activation='tanh')) opt = SGD(lr=0.01, momentum=0.9) model.compile(loss='hinge', optimizer=opt, metrics=['accuracy']) # fit model history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0) # evaluate the model _, train_acc = model.evaluate(trainX, trainy, verbose=0) _, test_acc = model.evaluate(testX, testy, verbose=0) print('Train: %.3f, Test: %.3f' % (train_acc, test_acc)) # plot loss during training pyplot.subplot(211) pyplot.title('Loss') pyplot.plot(history.history['loss'], label='train') pyplot.plot(history.history['val_loss'], label='test')
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', batch_size=240, class_mode='binary') validation_generator = data_generator.flow_from_directory( r'.\dataset\transferlearningdata\valid', target_size=(96, 96), color_mode='rgb', batch_size=200, class_mode='binary')
def bert_tensorflow_test(X_train, X_test, Y_train, Y_test): # Model model = Sequential() model.add(Masking(mask_value=0., input_shape=(MAX_SEQUENCE_LEN,VECTOR_DIM))) #forward_layer = LSTM(200, return_sequences=True) forward_layer = GRU(10, return_sequences=False, dropout=0.5) #backward_layer = LSTM(200, activation='relu', return_sequences=True, backward_layer = GRU(10, return_sequences=False, dropout=0.5, go_backwards=True) model.add(Bidirectional(forward_layer, backward_layer=backward_layer, input_shape=(MAX_SEQUENCE_LEN,VECTOR_DIM))) #model.add(TimeDistributed(Dense(NUM_CLASSES))) # Remove TimeDistributed() so that predictions are now made for the entire sentence model.add(Dense(NUM_CLASSES)) model.add(Activation('softmax')) #print('preds shape', model.predict(X_train[:3]).shape) #print('Y_train shape', Y_train[:3].shape) #print(list(Y_train[:3])) classes = [] for y in Y_train: cls = np.argmax(y) classes.append(cls) print(Counter(classes)) model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) print('compiled model') model.fit(X_train, Y_train, batch_size=8, epochs=10)#, validation_split=0.1) print('fit model') eval = model.evaluate(X_test, Y_test, batch_size=8) #print('X_test[0]') #print(X_test[0]) #print(X_train[0]) preds = model.predict_proba(X_test, verbose=1, batch_size=8) print(preds) num_correct = 0 num_incorrect = 0 TP = 0 TN = 0 FP = 0 FN = 0 # idiomatic = 2, non-idiomatic = 3 with open('preds_out_temp.txt', 'w') as tempoutf: for pred, y in zip(preds, Y_test): if np.argmax(y) == 2 or np.argmax(y) == 3: if np.argmax(y) == np.argmax(pred): num_correct += 1 else: num_incorrect += 1 if np.argmax(pred) == 2 and np.argmax(y) == 2: TP += 1 if np.argmax(pred) == 3 and np.argmax(y) == 3: TN += 1 if np.argmax(pred) == 2 and np.argmax(y) == 3: FP += 1 if np.argmax(pred) == 3 and np.argmax(y) == 2: FN += 1 custom_accuracy = num_correct/(num_correct+num_incorrect) print('custom accuracy is', num_correct/(num_correct+num_incorrect)) for y in Y_test: cls = np.argmax(y) classes.append(cls) class_nums = Counter(classes) print(class_nums) default_acc = class_nums[2] / (class_nums[2] + class_nums[3]) print('default accuracy is', default_acc, 'or', 1 - default_acc) return eval, custom_accuracy, default_acc, [TP, TN, FP, FN]
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() plt.grid() plt.plot(history.history['loss'], label='loss') plt.plot(history.history['val_loss'], label='val_loss') plt.yscale('log') plt.xlabel('Epochs') plt.legend(fontsize=13) plt.savefig('losses.png', dpi=10000)
class BiLSTM(BaseModel): _model_name = 'BiLSTMClf' def __init__(self, output_dim=None, input_length=None, run_time=None, X_train=None, y_train=None, save_path=None, epochs=None, batch_size=None, validation_data=None, validation_split=None, verbose=1, embedding_path=None, n_words=10000): super().__init__() self._output_dim = output_dim self._input_length = input_length self._run_time = run_time self._X_train = X_train self._y_train = y_train self._save_path = save_path self._epochs = epochs self._batch_size = batch_size self._validation_data = validation_data self._validation_split = validation_split self._verbose = verbose self._embedding_path = embedding_path self._n_words = n_words self._input_dim = '' self._weights = '' self._tokenizer = '' self._model = None self._history = None def _create_model(self): self._model = Sequential([ Embedding( input_dim=self._input_dim, # vocab_size output_dim=self._output_dim, weights=[self._weights], # embedding_matrix input_length=self._input_length, name='embeddings') ]) # max_len self._model.add(Bidirectional(LSTM(64, return_sequences=True))) self._model.add(GlobalMaxPooling1D()) self._model.add(Dense(16, activation='relu')) self._model.add(Dropout(0.30)) self._model.add(Dense(6, activation='sigmoid')) self._model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[ 'accuracy' ]) # TODO: change to correct metrics once all ok def _preprocess_data(self): self._tokenizer = Tokenizer(num_words=self._n_words, oov_token='<oov>') self._tokenizer.fit_on_texts(self._X_train) self._input_length = max( [len(row) for row in self._X_train] ) if self._input_length is None or self._input_length == 'None' else int( self._input_length) self._X_train = self._tokenize_and_pad(self._X_train, self._tokenizer, self._input_length) self._input_dim = len(self._tokenizer.word_index) + 1 def _tokenize_and_pad(self, data, tokenizer, maxlen, padding='post', truncating='post'): print('tokenizing data') data = tokenizer.texts_to_sequences(data) print('padding tokens') return pad_sequences(data, maxlen=maxlen, padding=padding, truncating=truncating) def _get_embeddings(self): embeddings_index = {} print('reading pre-trained embeddings') glove = open(self._embedding_path, 'r', encoding='utf-8') for line in tqdm(glove): values = line.split(" ") word = values[0] coefs = np.asarray(values[1:], dtype='float32') embeddings_index[word] = coefs glove.close() print('Found %s word vectors.' % len(embeddings_index)) # creating embedding matrix for words dataset print('creating embedding matrix') self._weights = np.zeros( (len(self._tokenizer.word_index) + 1, self._output_dim)) for word, index in tqdm(self._tokenizer.word_index.items()): embedding_vector = embeddings_index.get(word) if embedding_vector is not None: self._weights[index] = embedding_vector def get_summary(self): return self._model.summary() def train(self): # preprocess data print('preprocessing data') self._preprocess_data() # get embeddings print('getting embeddings weights') self._get_embeddings() # create model architecture self._create_model() summary = self.get_summary() print('mode summary:', summary) self._save_path = os.path.join(self._save_path, 'checkpoints', f'{self._model_name}_{self._run_time}') create_folder(self._save_path) cp_callback = ModelCheckpoint( filepath=self._save_path, save_weights_only=False, # verbose=verbose, save_best_only=True, monitor='val_loss', mode='min') self._history = self._model.fit( self._X_train, self._y_train, epochs=self._epochs, validation_data=self._validation_data, validation_split=self._validation_split, batch_size=self._batch_size, callbacks=[cp_callback]) def predict(self, X, threshhold=0.5): pred = self._model.predict(X) return (pred > threshhold).astype(np.int) def evaluate(self, X, y): X = self._tokenize_and_pad(X, self._tokenizer, self._input_length) return self._model.evaluate(X, y) def load_model(self, path): self._model = load_model(path) def save_model(self, mlflow, path): path = os.path.join(path, 'saved_models', f'{self._model_name}_{self._run_time}') create_folder(path) self._save_tokenizer(path) self._save_model(mlflow, path) self._save_embeddings(path) def _save_embeddings(self, path): embeddings = {} model_embeddings = self._model.get_layer('embeddings').get_weights()[0] for word, index in self._tokenizer.word_index.items(): embeddings[word] = model_embeddings[index] with open(os.path.join(path, f'embeddings.pkl'), 'wb') as handle: pickle.dump(embeddings, handle, protocol=pickle.HIGHEST_PROTOCOL) def _save_tokenizer(self, path): tokenizer_json = self._tokenizer.to_json() with io.open(os.path.join(path, f'tokenizer.json'), 'w', encoding='utf-8') as f: f.write(json.dumps(tokenizer_json, ensure_ascii=False)) def _save_model(self, mlflow, path): mlflow.keras.save_model(self._model, os.path.join(path, f'model'))
def train(): #Pre-processing df = pd.read_csv(DATA_PATH) df.drop('Unnamed: 0', axis=1, inplace=True) df.dropna(axis=0, inplace=True) # df.head(10) df['Party'] = pd.Categorical(df.Party) df['Party'] = pd.get_dummies(df['Party'], drop_first=True) X = df['Tweet'] Y = df['Party'] x, y = pre_process(X, Y=Y) X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=420) #Creating a tokenizer t = Tokenizer(oov_token="UNK") t.fit_on_texts(x) vocab_size = len(t.word_index) + 1 print("Vocabulary size: {}".format(vocab_size)) max_sent_len = len(max(x, key=len).split()) + 1 print("Maximum sentence length: {}".format(max_sent_len)) emb_dim = 75 print("Embedding Dimensions: {}".format(emb_dim)) padded_X_train = encode_and_pad(X_train, t, max_sent_len) x_train, x_val, Y_train, y_val = train_test_split(padded_X_train, y_train, test_size=0.1, random_state=420) checkpoint_path = TRAINING_PATH cp_callback = ModelCheckpoint(checkpoint_path, verbose=1, save_weights_only=True, period=20) model = Sequential([ Embedding(input_dim=vocab_size, output_dim=emb_dim, input_length=max_sent_len, trainable=True), Bidirectional(CuDNNLSTM(64, return_sequences=False)), Dropout(0.5), Dense(2, activation='softmax') ]) model.save_weights(checkpoint_path.format(epoch=0)) model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(x_train, Y_train, epochs=200, batch_size=300, shuffle=True, callbacks=[cp_callback], validation_data=(x_val, y_val)) model.save_weights(WEIGHTS_PATH) dic = { 'Vocab Size': vocab_size, 'Max Sent Length': max_sent_len, 'Emb Dim': emb_dim } meta_df = pd.DataFrame(dic, index=['Model 1']) meta_df.to_csv(META_PATH) with open(TOKENIZER_PATH, 'wb') as handle: pickle.dump(t, handle, protocol=pickle.HIGHEST_PROTOCOL) print("Training done.")
model= Sequential([ Dense(512,input_shape=(2,),activation='relu'), Dense(256,activation='relu'), LeakyReLU(alpha='0.01'), Dense(128,activation='relu'), Dense(64,activation='relu'), Dropout(0.1), Dense(2,activation='sigmoid') ]) model.compile(optimizer='adam', loss=SCC(from_logits=True), metrics=['accuracy']) inputs=np.column_stack((train_df['x'].values,train_df['y'].values)) before_training_predictions = model.predict(inputs_test) evolution = model.fit(inputs,train_df['color'].values, batch_size=32,epochs=epochs) predictions = model.predict(inputs_test)
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) print(loss, accuracy) y_predict = model.predict(daily_test).reshape(test_num - wenben_back).tolist()
name="Input_Conv_Layer")) cnn_lstm_model.add( TimeDistributed(MaxPool3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='valid'), name="Pool_Layer_1")) cnn_lstm_model.add(TimeDistributed(Flatten(), name="Flatten_Layer")) with tf.device('/cpu:0'): cnn_lstm_model.add( LSTM(10, dropout=0.3, recurrent_dropout=0.3, name="LSTM_Layer")) with tf.device('/gpu:0'): cnn_lstm_model.add( Dense(1, activation='sigmoid', name="Output_Dense_Layer")) cnn_lstm_model.compile(optimizer=optimizers.Adam(lr=0.0001), loss='binary_crossentropy', metrics=['accuracy']) cnn_lstm_model.fit_generator(generator=training_generator, steps_per_epoch=train_steps_per_epoch, verbose=1, callbacks=callbacks, validation_data=validation_generator, validation_steps=validate_steps_per_epoch, epochs=epochs)
import numpy as np import matplotlib.pyplot as plt import tensorflow as tf from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense from sklearn.model_selection import train_test_split model = Sequential() model.add(Dense(100, activation='sigmoid', input_shape=(784, ))) model.add(Dense(10, activation='softmax')) model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) (x_train_all, y_train_all), (x_text, y_test) = tf.keras.datasets.fashion_mnist.load_data() x_train, x_val, y_train, y_val = train_test_split(x_train_all, y_train_all, stratify=y_train_all, test_size=0.2, random_state=42) x_train = x_train / 255 x_val = x_val / 255 x_train = x_train.reshape(-1, 784) x_val = x_val.reshape(-1, 784)
def train_a_model(trainfile): ''' :param trainfile: :return: ''' x = trainfile.iloc[:,1:].values y = trainfile['emotion'].values x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, stratify=y,random_state=42) generate_images_folderwise(x_train,y_train,x_test,y_test) path = os.getcwd() TRAINING_DIR = path+"/images/train/" training_datagen = ImageDataGenerator( rescale = 1./255, rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') VALIDATION_DIR = path+"/images/test/" validation_datagen = ImageDataGenerator(rescale = 1./255) train_generator = training_datagen.flow_from_directory( TRAINING_DIR, color_mode='grayscale', target_size = (48,48), batch_size = 64, class_mode='categorical', shuffle=True) validation_generator = validation_datagen.flow_from_directory( VALIDATION_DIR, color_mode = 'grayscale', target_size = (48,48), batch_size = 64, class_mode='categorical', shuffle=False) print(train_generator.class_indices) num_classes = 3 epochs = 100 # Creating the model model = Sequential() model.add(Conv2D(32, kernel_size=(5, 5), input_shape=(48,48,1),activation='relu')) model.add(BatchNormalization()) model.add(Conv2D(32, kernel_size=(5, 5),activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2),strides=2)) model.add(Dropout(0.25)) model.add(Conv2D(64, kernel_size=(3, 3),activation='relu')) model.add(BatchNormalization()) model.add(Conv2D(64, kernel_size=(3, 3),activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(3, 3),strides=2)) model.add(Dropout(0.25)) model.add(Conv2D(128, kernel_size=(3, 3),activation='relu')) model.add(BatchNormalization()) model.add(Conv2D(128, kernel_size=(3, 3),activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(1, 1),strides=2)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(3, activation='softmax')) model.compile( loss = 'categorical_crossentropy', optimizer=Adam(), metrics=['accuracy']) steps_per_epoch = train_generator.n//train_generator.batch_size validation_steps = validation_generator.n//validation_generator.batch_size history = model.fit( x=train_generator, steps_per_epoch=steps_per_epoch, epochs=epochs, validation_data = validation_generator, validation_steps = validation_steps, ) model.save('model') pass
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