def create(cls, tokenizer: Tokenizer, hidden: int, dropout: float) -> "LanguageModel": from keras import Sequential from keras.layers import LSTM, Dropout, Dense if tokenizer.vocabulary_size == 0: logging.warning("Creating a model using a codec with an empty vocabulary.") model = Sequential() model.add(LSTM(hidden, input_shape=(tokenizer.context_size, 1))) model.add(Dropout(dropout)) model.add(Dense(tokenizer.vocabulary_size, activation="softmax")) model.compile(loss="categorical_crossentropy", optimizer="adam") return cls(model, tokenizer)
def __init__(self, input_nodes, hidden_nodes, output_nodes, lr=None): self.input_nodes = input_nodes self.hidden_nodes = hidden_nodes self.output_nodes = output_nodes self.lr = lr self.scales_x = [] self.scales_y = [] input_kernel_range = np.sqrt(6) / (np.sqrt(input_nodes) + np.sqrt(hidden_nodes)) input_kernel_initializer = RandomUniform(minval=-input_kernel_range, maxval=input_kernel_range) input_layer = Dense(input_nodes, kernel_initializer=input_kernel_initializer, name='input') hidden_kernel_range = np.sqrt(6) / (np.sqrt(hidden_nodes) + np.sqrt(output_nodes)) hidden_kernel_initializer = RandomUniform(minval=-hidden_kernel_range, maxval=hidden_kernel_range) hidden_layer = Dense(hidden_nodes, kernel_initializer=hidden_kernel_initializer, name='hidden') output_layer = Dense(output_nodes, name='output') self.model = Sequential() self.model.add(input_layer) self.model.add(hidden_layer) self.model.add(output_layer)
def function_set(self): self.__net = Sequential() self.__net.add(GRU(units=5, input_length=5, input_dim=3)) self.__net.add(Dense(units=1, activation="sigmoid"))
max_features = 10000 maxlen = 500 batch_size = 32 (input_train, y_train), (input_test, y_test) = imdb.load_data(num_words=max_features) print(len(input_train), 'train sequences') print(len(input_test), 'test sequences') print('Pad sequences (samples x time)') input_train = sequence.pad_sequences(input_train, maxlen=maxlen) input_test = sequence.pad_sequences(input_test, maxlen=maxlen) print('input_train shape ', input_train.shape) print('input_test shape ', input_test.shape) model = Sequential() model.add(Embedding(max_features, 32)) model.add(SimpleRNN(32)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) history = model.fit(input_train, y_train, epochs=10, batch_size=128, validation_split=0.2) acc = history.history['acc'] val_acc = history.history['val_acc'] loss = history.history['loss'] val_loss = history.history['val_loss']
def build_lstm_model(X): # init sequential model model = Sequential() # vectorize input # input_dim (size of vocabulary) is 2500 because we have only 2500 most common words (line 53) # embed_dim (shape of output) # input_length (length of input sequences), just get shape of first value because lenghts of all values are same (line 59), also could be replaced with maxlen value model.add(Embedding(2500, embed_dim, input_length=X.shape[1])) # prevent from overfitting model.add(Dropout(0.2)) # add LSTM layer with specified shape of output model.add(LSTM(lstm_out)) # prevent from overfitting model.add(Dropout(0.2)) # add Dense layer with specified shape of output, there are only 2 outputs, because review can be only positive or negative model.add(Dense(2, activation='softmax')) # compile model model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def training(file_path, epochs, noise_std, do_gif=False): def create_gif(path, title, step=1): images = [] for i, filename in enumerate(os.listdir(path)): if i % step == 0: images.append(imageio.imread(os.path.join(path, filename))) imageio.mimsave(os.path.join(ENC_PLOT_DATA_PATH, title), images, duration=0.1) shutil.rmtree(path) def get_data(file_path): # TODO: try using 2 proteins: train on the first one test on the other one data = read_data(file_path, normalize='std') x_train, x_test = train_test_split(data, test_size=0.1, random_state=42) return x_train, x_test def add_noise(x, std): return x + normal(0, std, size=x.shape) for file in os.listdir(file_path): if not (file.endswith(".csv")): continue name = file.replace(".csv", "") print("Analysing %s" % name) x_train, x_test = get_data(os.path.join(file_path, file)) x_train_noisy, x_test_noisy = add_noise( x_train, std=noise_std), add_noise(x_test, std=noise_std) network_model = Sequential(input_size=x_train.shape[1], encoded_size=2) network_model.add( Bidirectional(LSTM(10, return_sequences=True), input_shape=(5, 10))) network_model.add(Bidirectional(LSTM(10))) network_model.add(Dense(5)) network_model.add(Activation('softmax')) network_model.compile(loss='categorical_crossentropy', optimizer='rmsprop') data = read_data(os.path.join(file_path, file), normalize='std') # encoded = AutoEncoder(load_model("encoding/models/proteins-autoencoder_6EQE_Angles_And_RSA.h5")).encode(data) # df = pd.DataFrame(encoded) # df.to_csv("encoding/models/6EQE_Angles_And_RSA_result.csv", index=False, header=False) network_model.plot(data, title=name, file=os.path.join(ENC_PLOT_DATA_PATH, name + "_" + str(epochs) + ".jpg"))
def firstbuild(): model = Sequential() model.add( Embedding(maxvocab + 1, embedding_size, input_length=maxseqlen)) model.add( LSTM(128, dropout=0.4, recurrent_dropout=0.4, return_sequences=True)) model.add( LSTM(64, dropout=0.4, recurrent_dropout=0.4, return_sequences=True)) model.add( LSTM(64, dropout=0.4, recurrent_dropout=0.4, return_sequences=True)) model.add(LSTM(32, dropout=0.4, recurrent_dropout=0.4)) model.add(Dense(1, activation='sigmoid')) print(model.summary()) return model
''' # for now we set max word length to 500 max_words = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_words) X_test = sequence.pad_sequences(X_test, maxlen=max_words) # Now run max_length and see both training and testing data have a max length of 500 n_classes = 2 print("Shape before one-hot encoding: ", y_train.shape) y_train = np_utils.to_categorical(y_train, n_classes) y_test = np_utils.to_categorical(y_test, n_classes) print("Shape after one-hot encoding: ", y_train.shape) # 100 and 500 are more common embedding_size embedding_size=32 model=Sequential() model.add(Embedding(vocabulary_size, embedding_size, input_length=max_words)) # the output of embedding layer is 500*32 model.add(CuDNNLSTM(100)) model.add(Dense(2, activation='softmax')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X_train , y_train , epochs=5 , validation_split=0.2) test_loss , test_accuracy = model.evaluate(X_test , y_test) print(test_loss , (test_accuracy)*100) # saving the model
def createWord2VecModel(texts, targets, epochs_model): # WORD2VEC W2V_SIZE = 300 W2V_WINDOW = 4 W2V_EPOCH = 40 W2V_MIN_COUNT = 8 # KERAS SEQUENCE_LENGTH = 32 EPOCHS = epochs_model BATCH_SIZE = 1024 w2v_model = gensim.models.word2vec.Word2Vec(size=W2V_SIZE, window=W2V_WINDOW, min_count=W2V_MIN_COUNT, workers=8) w2v_model.build_vocab(texts) words = w2v_model.wv.vocab.keys() vocab_size = len(words) print("Vocab size", vocab_size) train_x, test_x, train_y, test_y = train_test_split(texts, targets, test_size=0.20, random_state=63) # train_x, valid_x, train_y, valid_y = train_test_split(train_x, train_y, test_size=0.20, random_state=63) w2v_model.train(texts, total_examples=len(texts), epochs=W2V_EPOCH) tokenizer = Tokenizer() tokenizer.fit_on_texts(train_x) vocab_size = len(tokenizer.word_index) + 1 train_x_seq = pad_sequences(tokenizer.texts_to_sequences(train_x), maxlen=SEQUENCE_LENGTH) test_x_seq = pad_sequences(tokenizer.texts_to_sequences(test_x), maxlen=SEQUENCE_LENGTH) embedding_matrix = np.zeros((vocab_size, W2V_SIZE)) # %% for word, i in tokenizer.word_index.items(): if word in w2v_model.wv: embedding_matrix[i] = w2v_model.wv[word] embedding_layer = Embedding(vocab_size, W2V_SIZE, weights=[embedding_matrix], input_length=SEQUENCE_LENGTH, trainable=False) model = Sequential() model.add(embedding_layer) model.add(Dropout(0.25)) model.add( LSTM(128, dropout=0.1, recurrent_dropout=0.1, return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(64, dropout=0.1, recurrent_dropout=0.1)) model.add(Dense(1, activation='sigmoid')) #ACCURACY: 0.8107593655586243 model.summary() model.compile(loss='binary_crossentropy', optimizer="adam", metrics=['accuracy']) callbacks = [ ReduceLROnPlateau(monitor='val_loss', patience=5, cooldown=0), EarlyStopping(monitor='val_accuracy', min_delta=1e-2, patience=5) ] history = model.fit(train_x_seq, train_y, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_split=0.1, verbose=1, callbacks=callbacks) score = model.evaluate(test_x_seq, test_y, batch_size=BATCH_SIZE) print() print("ACCURACY:", score[1]) print("LOSS:", score[0]) return model
def get_network(network="nvidia", input_shape=PROJECT_SHAPE, dropout_rate=0.): """ Get the desired network. Args: network: up to now only the "nvidia" network is implemented input_shape: (height, width, channels) shape tuple of the input image dropout_rate: dropout probability for all implemented layers """ if network.lower() == "nvidia": nvidia_model = Sequential() nvidia_model.add( Lambda(lambda x: x / 255. - 0.5, input_shape=input_shape)) nvidia_model.add( Conv2D(filters=24, kernel_size=5, strides=2, padding='valid', activation='relu')) # nvidia_model.add(BatchNormalization()) nvidia_model.add( Conv2D(filters=36, kernel_size=5, strides=2, padding='valid', activation='relu')) # nvidia_model.add(BatchNormalization()) nvidia_model.add( Conv2D(filters=48, kernel_size=5, strides=2, padding='valid', activation='relu')) # nvidia_model.add(BatchNormalization()) nvidia_model.add( Conv2D(filters=64, kernel_size=3, strides=1, padding='valid', activation='relu')) # nvidia_model.add(BatchNormalization()) nvidia_model.add( Conv2D(filters=64, kernel_size=3, strides=1, padding='valid', activation='relu')) # nvidia_model.add(BatchNormalization()) nvidia_model.add(Flatten()) nvidia_model.add(Dense(units=100, activation='relu')) nvidia_model.add(Dropout(rate=dropout_rate)) nvidia_model.add(Dense(units=50, activation='relu')) nvidia_model.add(Dropout(rate=dropout_rate)) nvidia_model.add(Dense(units=10, activation='relu')) nvidia_model.add(Dense(units=1)) return nvidia_model
class MyModel: def build_model(self,lr=0.001,decay = 0.01): self.model = Sequential(); init = initializers.RandomNormal(mean=0, stddev=1, seed=None); self.model.add(Dense(1024, input_shape=(2622,), activation='relu',kernel_initializer= init)); self.model.add(Dense(512, activation="relu")); self.model.add(Dense(256,activation="relu")); self.model.add(Dense(128,activation="relu")); self.model.add(Dense(64,activation="relu")); self.model.add(Dense(32,activation="relu")); self.model.add(Dense(16,activation="relu")); self.model.add(Dense(1,activation="sigmoid")); # learning rate 0.001 optimizer_adam = optimizers.Adam(lr=lr,decay = decay) self.model.compile(loss='binary_crossentropy', optimizer= optimizer_adam, metrics = ["accuracy"]) return self.model
def MLP(name, input_dir, best_dir, output): if not os.path.exists(best_dir): os.makedirs(best_dir) best_dir_dat = "/".join((best_dir, name)) if not os.path.exists(best_dir_dat): os.makedirs(best_dir_dat) colnames = "HType,ABType,dimension,learnFac,margin,constr,LType,MLP_acc,MLP_wF1,MLP_epoch" with open(output, "w") as file: file.write(colnames) file.write("\n") models = sorted(os.listdir(input_dir)) for model in models: modelpath = "/".join((input_dir, model)) files = sorted(os.listdir(modelpath)) # create model subdir to store best MLP models best_subdir = "/".join((best_dir_dat, model)) if not os.path.exists(best_subdir): os.makedirs(best_subdir) for i, file in enumerate(files): print(i) # embedding datasets labelpath = "/".join((modelpath, file)) dataset = pd.read_csv(labelpath, index_col=0) # specify file path to store best MLP model [for later] filepath = best_subdir + "/" + file[:-4] + ".hdf5" ################################################################################ ############################# DATA SPLIT ############################## ################################################################################ lb = preprocessing.LabelBinarizer() lb.fit(list(dataset["class"])) X_train = dataset[dataset["split"] == "LRN"].iloc[:, 1:-2].values y_train = dataset[dataset["split"] == "LRN"].iloc[:, -1].values # get weights first weights = compute_class_weight("balanced", np.unique(y_train), y_train) # then transform y_train = lb.transform(y_train) X_valid = dataset[dataset["split"] == "VLD"].iloc[:, 1:-2].values y_valid = dataset[dataset["split"] == "VLD"].iloc[:, -1].values y_valid = lb.transform(y_valid) X_test = dataset[dataset["split"] == "TST"].iloc[:, 1:-2].values y_test = dataset[dataset["split"] == "TST"].iloc[:, -1].values y_test = lb.transform(y_test) ################################################################################ ############################# CLASSIFIER STRUCTURE ############################## ################################################################################ classifier = Sequential() dim = len(dataset.iloc[0, 1:-2]) nodes = dim * 2 # Hidden layer classifier.add( Dense(nodes, activation="sigmoid", kernel_initializer="uniform", input_dim=dim)) # Output layer classifier.add( Dense(9, activation="softmax", kernel_initializer="uniform")) # compile the model sgd = optimizers.SGD(lr=0.01, decay=0.0, momentum=0.0, nesterov=False) classifier.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"]) ################################################################################ ############################# MODEL FITTING ############################## ################################################################################ # checkpoint best model checkpoint = ModelCheckpoint(filepath, monitor="val_acc", verbose=0, save_best_only=True, mode="auto") # model settings and fit history = classifier.fit(X_train, y_train, validation_data=(X_valid, \ y_valid), epochs=5000, verbose=0, callbacks=[checkpoint], \ class_weight=weights) ################################################################################ ############################# MAKE PREDICTIONS ############################## ################################################################################ #load best model final_model = load_model(filepath) # get accuracy scores = final_model.evaluate(X_test, y_test, verbose=0) # get weighted F1-by-class le = preprocessing.LabelEncoder() le.fit(list(dataset["class"])) y_test2 = dataset[dataset["split"] == "TST"].iloc[:, -1].values y_test2 = le.transform(y_test2) y_pred = final_model.predict_classes(X_test, verbose=0) weighted_f1 = f1_score(y_test2, y_pred, average="weighted") # get best epoch acc_history = history.history["val_acc"] best_epoch = acc_history.index(max(acc_history)) + 1 K.clear_session() # destroy TF graph to avoid loop slowing down ################################################################################ ############################# ASSEMBLE W/ CONFIG ############################## ################################################################################ # get model type (H1-4, A/B) modelType = model.split("-")[1] # ["H1A"] HType = modelType[0:2] ABType = modelType[-1] # get dimension filenamesplit = file.split("-") dimension = int([s for s in filenamesplit if "D00" in s][0][1:]) # get learnFac learnFac = int([s for s in filenamesplit if "LF0" in s][0][3:]) # get margin margin = float([s for s in filenamesplit if "LM" in s][0][2:]) # get constraint constr = [s for s in filenamesplit if "_VALUE" in s][0][:-6].lower() # get LType LType = filenamesplit[-1][:2] with open(output, "a") as file: file.write("%s,%s,%d,%d,%.1f,%s,%s,%.17f,%.17f,%d" % (HType, ABType, dimension, learnFac, margin, constr, LType, scores[1], weighted_f1, best_epoch)) file.write("\n")
def model(cls): model = Sequential() model.add(cls._init_conv2D()) model.add(Flatten()) model.add(cls._dense(config.NUM_PAINTERS)) model.add(Activation("softmax")) model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.000074), metrics=['accuracy']) return model
class AutoEncoder: def __init__(self, date_range, symbol="AAPL", data_file="calibration_data"): self.data = None for day in date_range: path = "fundamental_{}_{}.bz2".format(symbol, day.strftime("%Y%m%d")) path = os.path.join(data_file, path) if os.path.exists(path): prices = pd.read_pickle(path, compression="bz2") if self.data is None: self.data = prices.values.T else: self.data = np.vstack([self.data, prices.values.T]) scaler = MinMaxScaler() self.data_scaled = np.array( [scaler.fit_transform(d.reshape(-1, 1)) for d in self.data]) self.data_scaled = self.data_scaled[:, :, 0] print("The data shape is", self.data_scaled.shape) def build_model(self, encode_length=16, activation="relu"): n_in = self.data_scaled.shape[1] self.encode_length = encode_length self.model = Sequential() self.model.add(Dense(128, activation=activation, name="encoder_l1")) self.model.add(Dense(64, activation=activation, name="encoder_l2")) self.model.add( Dense(encode_length, name="encoder_output", activation=None)) self.model.add(Dense(64, activation=activation)) self.model.add(Dense(128, activation=activation)) self.model.add(Dense(n_in, activation=None)) self.model.compile(optimizer='adam', loss='mse') self.model.build() return self.model def _reshape_data(self, data): if len(data.shape) == 3: return data if len(data.shape) == 2: return data[:, :, np.newaxis] if len(data.shape) == 1: return data[np.newaxis, :, np.newaxis] def train_model(self, test_size=0.1, val_size=0.1, batch_size=16, epochs=200, stop_patience=10, plot_test=True, plot_history=True): x = self.data_scaled if test_size != 0.: x_train, x_test, y_train, y_test = train_test_split( x, x, test_size=test_size, random_state=42) print(x_train.shape, x_test.shape, y_train.shape, y_test.shape) else: x_train, y_train = x, x early_stopping = EarlyStopping(monitor='val_loss', patience=stop_patience, mode="min", verbose=2, restore_best_weights=True) result = self.model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_split=val_size / (1 - test_size), callbacks=[early_stopping]) if plot_test: y_test_predict = self.model.predict(x_test) print( "test loss:", np.sum((y_test_predict - y_test)**2) / (y_test.shape[0] * y_test.shape[1])) plt.plot(y_test[0]) plt.plot(y_test_predict[0]) plt.ylabel("Scaled Price") plt.xlabel("Minutes") plt.title("Encode length {}".format(self.encode_length)) plt.legend(["Real", "Predict"]) plot_name = "sample" plt.savefig('{}_{}.png'.format(plot_name, self.encode_length)) plt.show() if plot_history: self.loss_plot(result.history) return result def loss_plot(self, history, plot_name='Loss'): loss = np.asarray(history['loss']) val_loss = np.asarray(history['val_loss']) plt.style.use('seaborn') plt.figure(figsize=(12, 9), dpi=100) plt.grid(True) plt.plot(loss) plt.plot(val_loss) plt.legend(['loss', 'val_loss']) plt.title("Encode length {}".format(self.encode_length)) plt.xlabel("Epochs") plt.ylabel("MSE") plt.savefig('{}_{}.png'.format(plot_name, self.encode_length)) plt.show() def save_feature(self, plot_feature=False): feature_name = "AutoEncoderFeature_{}.npy".format(self.encode_length) encoder = Model(inputs=self.model.input, outputs=self.model.get_layer('encoder_output').output) feature = encoder.predict(self.data_scaled) np.save("feature/" + feature_name, feature) if plot_feature: if self.encode_length == 8: fig, ax = plt.subplots(ncols=4, nrows=2, figsize=(12, 9)) axes = ax.flatten() for i in range(feature.shape[1]): sns.distplot(feature[:, i], ax=axes[i]) plt.show() return for i in range(feature.shape[1]): sns.distplot(feature[:, i]) plt.show() return def save_model(self): self.model.save("model/AutoEncoder_{}.h5".format(self.encode_length)) def save_encoder_ws(self): w1, b1 = self.model.get_layer('encoder_l1').get_weights() w2, b2 = self.model.get_layer('encoder_l2').get_weights() w3, b3 = self.model.get_layer('encoder_output').get_weights() with open("model/AutoEncoder_w_{}.h5".format(self.encode_length), "wb") as f: pickle.dump([w1, b1, w2, b2, w3, b3], f) def encode(self, x): encoder = Model(inputs=self.model.input, outputs=self.model.get_layer('encoder_output').output) return encoder.predict(x)
def create_model(): model = Sequential() model.add(Conv2D(LAYER1_SIZE, activation="relu", kernel_size=(3, 3), input_shape=(2, BOARD_SIZE, BOARD_SIZE), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(Conv2D(LAYER1_SIZE, activation="relu", kernel_size=(3, 3), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(MaxPooling2D((2, 2), data_format="channels_first")) model.add(Conv2D(LAYER1_SIZE * 2, activation="relu", kernel_size=(3, 3), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(Conv2D(LAYER1_SIZE * 2, activation="relu", kernel_size=(3, 3), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(MaxPooling2D((2, 2), data_format="channels_first")) model.add(Flatten()) model.add(Dense(LAYER2_SIZE, activation='relu', kernel_regularizer=l2(L2_REGULARISATION))) model.add(Dense(1, activation='tanh')) optimizer = Adam(decay=DECAY, lr=LR) model.compile(loss='mse', optimizer=optimizer, metrics=['accuracy', 'mae']) model.summary() return model
# In[] ''' voc_classes = ['Aeroplane', 'Bicycle', 'Bird', 'Boat', 'Bottle', 'Bus', 'Car', 'Cat', 'Chair', 'Cow', 'Diningtable', 'Dog', 'Horse','Motorbike', 'Person', 'Pottedplant', 'Sheep', 'Sofa', 'Train', 'Tvmonitor'] NUM_CLASSES = len(voc_classes) + 1 ''' # In[] from keras import Sequential from keras.layers import Conv2D, ZeroPadding2D, MaxPooling2D model = Sequential() # Block 1 model.add(Conv2D(64, (3, 3), name='conv1_1', padding='same', activation='relu', input_shape=(300,300,3))) first_layer = model.layers[-1] # this is a placeholder tensor that will contain our generated images input_img = first_layer.input # build the rest of the network model.add(Conv2D(64, (3, 3), name='conv1_2', padding='same',
from keras import applications, optimizers from keras.layers import Input, Dense, Conv2D, MaxPooling2D, Flatten, Dropout from keras import Model, Sequential base_model = applications.VGG16(include_top=False, weights='imagenet', input_shape=(150, 150, 3)) top_model = Sequential() top_model.add(Flatten(input_shape=base_model.output_shape[1:])) top_model.add(Dense(512, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(256, activation='relu')) top_model.add(Dropout(0.2)) top_model.add(Dense(2, activation='softmax')) model = Model(inputs = base_model.input, outputs = top_model(base_model.output))
def build_binary_classifier(): #10000/10000 [==============================] - 18s 2ms/step #[0.17787481148242951, 0.92800000000000005] nn = Sequential() conv1 = Conv2D(32, (3, 3), activation='relu', padding="same", input_shape=(32, 32, 3)) conv2 = Conv2D(32, (3, 3), activation='relu', padding="same") nn.add(conv1) nn.add(conv2) pool1 = MaxPooling2D(pool_size=(2, 2)) nn.add(pool1) drop1 = Dropout(0.25) nn.add(drop1) conv3 = Conv2D(32, (3, 3), activation='relu', padding="same") conv4 = Conv2D(32, (3, 3), activation='relu', padding="same") nn.add(conv3) nn.add(conv4) pool2 = MaxPooling2D(pool_size=(2, 2)) nn.add(pool2) drop2 = Dropout(0.25) nn.add(drop2) nn.add(Flatten()) hidden1 = Dense(units=250, activation="relu") nn.add(hidden1) hidden2 = Dense(units=600, activation="relu") nn.add(hidden2) output = Dense(units=1, activation="sigmoid") nn.add(output) return nn
import numpy as np from keras import Sequential from keras.layers import Dense data = np.random.random((1000, 32)) label = np.random.random((1000, 10)) model = Sequential() model.add(Dense(64, activation='relu', input_shape=(32, ))) model.add(Dense(64, activation='relu')) model.add(Dense(10, activation='softmax')) model.compile('adam', 'categorical_crossentropy') model.fit(data, label, epochs=100) model.save('my_model.h5')
def build_convolution_nn(): #10000/10000 [==============================] - 18s 2ms/step #[0.7925042769432068, 0.72289999999999999] nn = Sequential() conv1 = Conv2D(32, (3, 3), activation='relu', padding="same", input_shape=(32, 32, 3)) conv2 = Conv2D(32, (3, 3), activation='relu', padding="same") nn.add(conv1) nn.add(conv2) pool1 = MaxPooling2D(pool_size=(2, 2)) nn.add(pool1) drop1 = Dropout(0.25) nn.add(drop1) conv3 = Conv2D(32, (3, 3), activation='relu', padding="same") conv4 = Conv2D(32, (3, 3), activation='relu', padding="same") nn.add(conv3) nn.add(conv4) pool2 = MaxPooling2D(pool_size=(2, 2)) nn.add(pool2) drop2 = Dropout(0.25) nn.add(drop2) nn.add(Flatten()) hidden1 = Dense(units=250, activation="relu") nn.add(hidden1) hidden2 = Dense(units=600, activation="relu") nn.add(hidden2) output = Dense(units=10, activation="softmax") nn.add(output) return nn
#%% #estamos pegando todas as colunas, menos a útlima como o X train X_train = np.expand_dims(dataset.values[:, :-1], axis=2) #a última coluna é o label (ou o dev set) y_train = dataset.values[:, -1:] #o test set serão as últimas colunas X_test = np.expand_dims(dataset.values[:, 1:], axis=2) print(X_train.shape, y_train.shape, X_test.shape) #%% import keras from keras import Sequential from keras.layers import Dense from keras.layers import Dense, LSTM, RepeatVector, TimeDistributed, Flatten, Dropout #%% model = Sequential() model.add(LSTM(units=64, input_shape=(X_train.shape[1], X_train.shape[2]))) model.add(Dense(units=1)) model.compile(optimizer="adam", loss="mse", metrics=["mean_squared_error"]) model.summary() #%% model.fit(X_train, y_train, batch_size=4096, nb_epoch=5) #%% from sklearn.metrics import confusion_matrix, accuracy_score precisão = accuracy_score(y_true, y_pred) #%% # creating submission file predição = model.predict(X_test) # we will keep every value between 0 and 20
def mlp(sample_dim): model = Sequential() model.add(Dense(512, kernel_initializer='glorot_uniform', activation='relu', input_dim=sample_dim)) model.add(Dense(128, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dense(64, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dense(32, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dense(1)) model.compile(loss=losses.mae, optimizer='adam') return model
#Build input array, where a sounding and its neighbours are stacked dbdt_train = build_array_skytem(3, dbdt_train) dbdt_test = build_array_skytem(3, dbdt_test) else: from sklearn.model_selection import train_test_split #normalize by sign and log dbdt_norm = np.sign(dbdt) * np.log(np.abs(dbdt)) sc = StandardScaler() dbdt_norm = sc.fit_transform(dbdt_norm) dbdt_norm = build_array_skytem(3, dbdt_norm) X = range(dbdt_norm.shape[1]) X_train_idx, X_test_idx, lbl_train, lbl_test = train_test_split(X, lbl[1:-1], test_size=0.2) dbdt_train = dbdt_norm[:, X_train_idx] dbdt_test = dbdt_norm[:, X_test_idx] model = Sequential() model.add(Dense(30, input_shape=(dbdt_train.shape[0],), activation='tanh')) model.add(Dense(1, activation='tanh')) model.compile(loss='binary_crossentropy', optimizer='Adam',#Adam(lr=0.0005, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False), metrics=['accuracy']) print(model.summary()) history = model.fit(dbdt_train.T, lbl_train, epochs=30, batch_size = 100, verbose = 2, validation_split=0.1) # network = join( # Input(51), # Tanh(30), # Tanh(1), # ) #
ObjData = [ObjData] * 6 PoseData = [PoseData] * 6 p = np.append(RGBData, ObjData, 1) p = np.append(p, BGData, 1) p = np.append(p, PoseData, 1) # p = RGBData if train_data is not None: train_data = np.append(train_data, p, 0) else: train_data = p gt = pickle_filename.split('_')[1] ## coarse classify train_label = np.append(train_label, [catagories.index(gt)] * 6) train_label = np_utils.to_categorical(train_label, 15) print(train_data.shape) model = Sequential() model.add( Dense(128, input_shape=(train_data.shape[1], ), activation='relu', kernel_regularizer=regularizers.l2(0.001))) model.add(Dropout(0.6)) model.add(Dense(15, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='RMSprop', metrics=['accuracy']) ## model fit model.fit(train_data, train_label, shuffle=True, batch_size=128,
def getLModel(dims): if K.image_data_format() == 'channels_first': input_shape = (3, dims[0], dims[1]) else: input_shape = (dims[0], dims[1], 3) model = Sequential() model.add(Conv2D(32, (3, 3), strides=(2, 2), input_shape=input_shape)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3), strides=(2, 2))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dropout(.2)) model.add(Dense(4, activation='softmax')) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
def classifier_model(): model = Sequential() model.add(LSTM(512, input_dim=4096, kernel_initializer='glorot_normal', kernel_regularizer=l2(0.01), activation='relu')) model.add(Dropout(0.6)) model.add(Dense(64, kernel_initializer='glorot_normal', kernel_regularizer=l2(0.01), activation='sigmoid')) model.add(Dropout(0.6)) model.add(Dense(32, kernel_initializer='glorot_normal', kernel_regularizer=l2(0.01))) model.add(Dropout(0.6)) model.add(Dense(1, kernel_initializer='glorot_normal', kernel_regularizer=l2(0.01), activation='sigmoid')) return model
print(dimData) train_data = train_images.reshape(train_images.shape[0], dimData) test_data = test_images.reshape(test_images.shape[0], dimData) #convert data to float and scale values between 0 and 1 #train_data = train_data.astype('float') #test_data = test_data.astype('float') #scale data #train_data /=255.0 #test_data /=255.0 #change the labels frominteger to one-hot encoding. to_categorical is doing the same thing as LabelEncoder() train_labels_one_hot = to_categorical(train_labels) test_labels_one_hot = to_categorical(test_labels) #creating network model = Sequential() model.add(Dense(512, activation='relu', input_shape=(dimData, ))) model.add(Dense(512, activation='relu')) model.add(Dense(512, activation='tanh')) # Adding hidden layer model.add(Dense(10, activation='softmax')) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit(train_data, train_labels_one_hot, batch_size=256, epochs=10, verbose=1, validation_data=(test_data, test_labels_one_hot))
from sklearn import metrics print("Accuracy:", metrics.accuracy_score(y_test, y_pred)) ############################################################################################################# # # 3.1. Predicting results using Neural Networks import keras from keras import Sequential from keras.layers import Dense # In[35]: classifier = Sequential() # In[36]: # First Hidden Layer classifier.add( Dense(7, activation='relu', kernel_initializer='random_normal', input_dim=13)) # In[37]: # Second Hidden Layer classifier.add(Dense(7, activation='relu', kernel_initializer='random_normal'))
class YApplyTimeSeries(object): def __init__(self): # data prepare self.__df = None self.__train_feature_label, self.__test_feature_label = None, None self.__train_feature, self.__train_label = None, None self.__test_feature, self.__test_label = None, None self.__mms = None # function set self.__net = None # optimizer function # pick the best function def data_prepare(self): self.__df = pd.read_csv("C:\\Users\\Dell\\Desktop\\time_series.csv", encoding="utf-16") self.__df = self.__df.dropna() self.__train_feature_label = self.__df.loc[( self.__df["is_oot"] == 0), :] self.__test_feature_label = self.__df.loc[( self.__df["is_oot"] == 1), :] self.__train_feature_label = self.__train_feature_label.drop( ["id_no", "is_oot"], axis=1) self.__test_feature_label = self.__test_feature_label.drop( ["id_no", "is_oot"], axis=1) self.__train_feature = self.__train_feature_label[[ i for i in self.__train_feature_label.columns if i != "is_overdue" ]].values self.__train_label = self.__train_feature_label["is_overdue"].values self.__test_feature = self.__test_feature_label[[ i for i in self.__test_feature_label.columns if i != "is_overdue" ]].values self.__test_label = self.__test_feature_label["is_overdue"].values # 标准化 self.__mms = MinMaxScaler() self.__mms.fit(self.__train_feature) self.__train_feature = self.__mms.transform(self.__train_feature) self.__test_feature = self.__mms.transform(self.__test_feature) # reshape samples × input_length × input_dim self.__train_feature = self.__train_feature.reshape((-1, 5, 3)) self.__test_feature = self.__test_feature.reshape((-1, 5, 3)) def function_set(self): self.__net = Sequential() self.__net.add(GRU(units=5, input_length=5, input_dim=3)) self.__net.add(Dense(units=1, activation="sigmoid")) def optimizer_function(self): self.__net.summary() self.__net.compile(loss=keras.losses.binary_crossentropy, optimizer=keras.optimizers.Adam(), metrics=["accuracy"]) def pick_the_best_function(self): self.__net.fit(self.__train_feature, self.__train_label, epochs=2, batch_size=256) print( roc_auc_score(self.__test_label, self.__net.predict_proba(self.__test_feature)))
class DNN(Model): """ This class is parent class for all Deep neural network models. Any class inheriting this class should implement `make_default_model` method which creates a model with a set of hyper parameters. """ def __init__(self, input_shape, num_classes, **params): """ Constructor to initialize the deep neural network model. Takes the input shape and number of classes and other parameters required for the abstract class `Model` as parameters. Args: input_shape (tuple): shape of the input num_classes (int): number of different classes ( labels ) in the data. **params: Additional parameters required by the underlying abstract class `Model`. """ super(DNN, self).__init__(**params) self.input_shape = input_shape self.model = Sequential() self.make_default_model() self.model.add(Dense(num_classes, activation='softmax')) self.model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # print(self.model.summary(), file=sys.stderr) self.save_path = self.save_path or self.name + '_best_model.h5' def load_model(self, to_load): """ Load the model weights from the given path. Args: to_load (str): path to the saved model file in h5 format. """ try: self.model.load_weights(to_load) except: sys.stderr.write("Invalid saved file provided") sys.exit(-1) def save_model(self): """ Save the model weights to `save_path` provided while creating the model. """ self.model.save_weights(self.save_path) def train(self, x_train, y_train, x_val=None, y_val=None, n_epochs=50): """ Train the model on the given training data. Args: x_train (numpy.ndarray): samples of training data. y_train (numpy.ndarray): labels for training data. x_val (numpy.ndarray): Optional, samples in the validation data. y_val (numpy.ndarray): Optional, labels of the validation data. n_epochs (int): Number of epochs to be trained. """ best_acc = 0 if x_val is None or y_val is None: x_val, y_val = x_train, y_train for i in range(n_epochs): # Shuffle the data for each epoch in unison inspired # from https://stackoverflow.com/a/4602224 p = np.random.permutation(len(x_train)) x_train = x_train[p] y_train = y_train[p] self.model.fit(x_train, y_train, batch_size=32, epochs=1) loss, acc = self.model.evaluate(x_val, y_val) if acc > best_acc: best_acc = acc self.trained = True def predict_one(self, sample): if not self.trained: sys.stderr.write( "Model should be trained or loaded before doing predict\n") sys.exit(-1) return self.model.predict(np.array([sample]))[0] def make_default_model(self): """ Make the model with default hyper parameters """ # This has to be implemented by child classes. The reason is that the # hyper parameters depends on the model. raise NotImplementedError()
def build_model(spec, X_train): model = Sequential() # create first layer layer = spec[0] num_posts, bow_dim = X_train[0].shape model.add(InputLayer(input_shape=(num_posts, bow_dim))) model.add(Flatten()) if 'none' in layer: model.add(Dense( # input_dim=1, units=int(layer.split('none')[1]), activation=None )) elif 'relu' in layer: model.add(Dense( # input_shape=train_X[0].shape, units=int(layer.split('relu')[1]), activation='relu' )) elif 'sig' in layer: model.add(Dense( # input_shape=train_X[0].shape, units=int(layer.split('sig')[1]), activation='sigmoid' )) else: return None for layer in spec[1:]: if 'none' in layer: model.add(Dense(int(layer.split('none')[1]), activation=None)) elif 'relu' in layer: model.add(Dense(int(layer.split('relu')[1]), activation='relu')) elif 'sig' in layer: model.add(Dense(int(layer.split('sig')[1]), activation='sigmoid')) elif 'drop' in layer: model.add(Dropout(float(layer.split('drop')[1]), seed=None)) elif 'l1' in layer: model.add(ActivityRegularization(l1=float(layer.split('l1')[1]))) elif 'l2' in layer: model.add(ActivityRegularization(l2=float(layer.split('l2')[1]))) else: return None # add softmax layer model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def gener_model01(maxlen, len_chars, word_size, num_lstm, model_file_name): ''' :param maxlen: 输入长度 :param len_chars: 字典长度 :param word_size: 字向量长度 :param num_lstm: lstm节点数 :param model_file_name: 模型的保持文件 :return: ''' model = Sequential() model.add(Embedding(len_chars + 1, word_size, input_length=maxlen)) '''len_chars+1是输入维度,word_size是输出维度,input_length是节点数''' model.add(LSTM(num_lstm, return_sequences=True)) model.add(LSTM(num_lstm, return_sequences=True)) # model.add(Dropout(0.3)) # model.add(Dense(5,activation='softmax')) model.add(TimeDistributed(Dense(5, activation='softmax'))) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # tb_cb = keras.callbacks.TensorBoard(log_dir=log_filepath, write_images=1, histogram_freq=1) # 设置log的存储位置,将网络权值以图片格式保持在tensorboard中显示,设置每一个周期计算一次网络的权值,每层输出值的分布直方图 model.save(model_file_name) model.summary() return model
def build_model(in_dim=20, drate=0.5, out=64): mdl = Sequential() mdl.add(Dense(out, input_dim=in_dim, activation='relu')) if drate: mdl.add(Dropout(drate)) mdl.add(Dense(out, activation='relu')) if drate: mdl.add(Dropout(drate)) mdl.add(Dense(1, activation='sigmoid')) return mdl
def gener_model03(maxlen, len_chars, word_size, num_lstm, model_file_name): model = Sequential() model.add(Embedding(len_chars + 1, word_size, input_length=maxlen)) '''len_chars+1是输入维度,word_size是输出维度,input_length是节点数''' model.add( Bidirectional(LSTM(num_lstm, return_sequences=True), merge_mode='sum')) # model.add(Dropout(0.3)) model.add( Bidirectional(LSTM(num_lstm, return_sequences=True), merge_mode='sum')) model.add( Bidirectional(LSTM(num_lstm, return_sequences=True), merge_mode='sum')) model.add(TimeDistributed(Dense(5, activation='softmax'))) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.save(model_file_name) model.summary() return model
def create_lstm_model(num_features): model = Sequential() # "Encode" the input sequence using an RNN, producing an output of HIDDEN_SIZE. # Note: In a situation where your input sequences have a variable length, # use input_shape=(None, num_feature). # By setting return_sequences to True, return not only the last output but # all the outputs so far in the form of (num_samples, timesteps, # output_dim). This is necessary as TimeDistributed in the below expects # the first dimension to be the timesteps. model.add(RNN(HIDDEN_SIZE, input_shape=(None, num_features), return_sequences=True)) # Apply a dense layer to the every temporal slice of an input. For each of step # of the output sequence, decide which character should be chosen. model.add(layers.TimeDistributed(layers.Dense(len(LABEL_CLASS_MAPPING) + 1))) model.add(layers.Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() return model
def model(cls, input_shape: (int, int)): model = Sequential() model.add( layers.Conv2D(filters=6, kernel_size=(3, 3), activation='relu', input_shape=(input_shape[0], input_shape[1], 1))) model.add(layers.AveragePooling2D()) model.add( layers.Conv2D(filters=16, kernel_size=(3, 3), activation='relu')) model.add(layers.AveragePooling2D()) model.add(layers.Flatten()) model.add(layers.Dense(units=120, activation='relu')) model.add(layers.Dense(units=84, activation='relu')) model.add(layers.Dense(units=10, activation='softmax')) return model
import pandas as pd from keras import Sequential from keras.layers.core import Dense,Activation,Dropout from sklearn.model_selection import train_test_split # from matplotlib.pyplot import plt train_data=pd.read_csv('D:\sufe\A\contest_basic_train.tsv',sep='\t') train_data=train_data.drop(['REPORT_ID',"ID_CARD",'LOAN_DATE'],1) train_data=train_data.dropna() # print(train_data.info()) X=train_data.drop(['Y'],1).as_matrix()#7 y=train_data['Y'].as_matrix()#1 X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1) model=Sequential() model.add(Dense(14,input_shape=(7,))) model.add(Activation('relu')) model.add(Dense(1)) model.add((Dropout(0.3))) model.compile(loss='mean_squared_error', optimizer='adam') model.summary() model.fit(X_train,y_train,epochs=10000,batch_size=16) t=model.predict(X_test) rate=0 for i in range(len(t)): if t[i]==y_test[i]: rate+=1 else: pass
test_labels = labels[train_size:, :] test_labels = np.reshape(test_labels, (test_labels.shape[0], 1)) train_data = train_data.reshape(train_data.shape[0], train_data.shape[1], 1) test_data = test_data.reshape(test_data.shape[0], test_data.shape[1], 1) num_filters = 2 kernel_size = (5) conv_strides = 2 pool_kernel = (2) pool_strides = 2 dense_units = 1 learning_rate = 0.01 # ONE CONVOLUTION, ONE POOLING, 2 FC LAYERS model = Sequential() model.add( Conv1D(num_filters, kernel_size, input_shape=(1000, 1), strides=conv_strides, padding='valid', activation='relu')) model.add( AveragePooling1D(pool_size=pool_kernel, strides=pool_strides, padding='same')) model.add(Flatten()) model.add(Dense(1, activation='softmax')) model.compile(optimizer='adam',
class NeuralNetwork(object): def __init__(self, input_nodes, hidden_nodes, output_nodes, lr=None): self.input_nodes = input_nodes self.hidden_nodes = hidden_nodes self.output_nodes = output_nodes self.lr = lr self.scales_x = [] self.scales_y = [] input_kernel_range = np.sqrt(6) / (np.sqrt(input_nodes) + np.sqrt(hidden_nodes)) input_kernel_initializer = RandomUniform(minval=-input_kernel_range, maxval=input_kernel_range) input_layer = Dense(input_nodes, kernel_initializer=input_kernel_initializer, name='input') hidden_kernel_range = np.sqrt(6) / (np.sqrt(hidden_nodes) + np.sqrt(output_nodes)) hidden_kernel_initializer = RandomUniform(minval=-hidden_kernel_range, maxval=hidden_kernel_range) hidden_layer = Dense(hidden_nodes, kernel_initializer=hidden_kernel_initializer, name='hidden') output_layer = Dense(output_nodes, name='output') self.model = Sequential() self.model.add(input_layer) self.model.add(hidden_layer) self.model.add(output_layer) def train(self, x_train, y_train): self.set_normalize_scales(x_train, y_train) x_train = self.normalize(x_train, self.scales_x) y_train = self.normalize(y_train, self.scales_y) optimizer = SGD(lr=self.lr) self.model.compile(loss='mse', optimizer=optimizer) self.model.fit(x_train, y_train, batch_size=20, epochs=500) def evaluate(self, x_test, y_test): x_test = self.normalize(x_test, self.scales_x) y_test = self.normalize(y_test, self.scales_y) return self.model.evaluate(x_test, y_test) def predict(self, x): x = self.normalize(x, self.scales_x) y = self.model.predict(x) return self.unnormalize(y, self.scales_y) def set_normalize_scales(self, x, y): for i in range(x.shape[1]): mean, std = x[:, i].mean(), x[:, i].std() self.scales_x.append([mean, std]) for i in range(y.shape[1]): mean, std = y[:, i].mean(), y[:, i].std() self.scales_y.append([mean, std]) @staticmethod def normalize(data, scales): for i in range(0, len(scales)): mean, std = scales[i] data[:, i] = (data[:, i] - mean) / std return data @staticmethod def unnormalize(data, scales): for i in range(0, len(scales)): mean, std = scales[i] data[:, i] = data[:, i] * std + mean return data
Cells = Cells[s] labels = labels[s] X_train = Cells[(int)(0.2 * len(labels)):] X_val = Cells[:(int)(0.2 * len(labels))] X_train = X_train.astype('float32') / 255 X_val = X_val.astype('float32') / 255 # Normalization y_train = labels[(int)(0.2 * len(labels)):] y_val = labels[:(int)(0.2 * len(labels))] # # # Up until here it's the same, regardless of the type of network to be used. #Rec-NN from keras import Sequential from keras.layers import Dense, Dropout, LSTM, CuDNNLSTM # long short term memory model = Sequential() model.add( LSTM(32, input_shape=X_train.shape[1:], activation='relu', return_sequences=True)) model.add(Dropout(0.25)) model.add(LSTM(64, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(64, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(43, activation='softmax'))
print(y_train[6]) print('Maximum review length: {}'.format(len(max((X_train + X_test), key=len)))) print('Minimum review length: {}'.format(len(min((X_test + X_test), key=len)))) from keras.preprocessing import sequence max_words = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_words) X_test = sequence.pad_sequences(X_test, maxlen=max_words) from keras import Sequential from keras.layers import Embedding, LSTM, Dense, Dropout embedding_size=32 model=Sequential() model.add(Embedding(vocabulary_size, embedding_size, input_length=max_words)) model.add(LSTM(100)) model.add(Dense(1, activation='sigmoid')) print(model.summary()) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) batch_size = 64 num_epochs = 3 X_valid, y_valid = X_train[:batch_size], y_train[:batch_size] X_train2, y_train2 = X_train[batch_size:], y_train[batch_size:] model.fit(X_train2, y_train2, validation_data=(X_valid, y_valid), batch_size=batch_size, epochs=num_epochs)
def train_model(train_test_path): """ Creates a model and performs training. """ # Load train/test data train_test_data = np.load(train_test_path) x_train = train_test_data['X_train'] y_train = train_test_data['y_train'] print("x_train:", x_train.shape) print("y_train:", y_train.shape) del train_test_data x_train = np.expand_dims(x_train, axis=3) # Create network model = Sequential() model.add(Conv1D(128, 5, input_shape=x_train.shape[1:], padding='same', activation='relu')) model.add(MaxPooling1D(5)) model.add(Conv1D(128, 5, padding='same', activation='relu')) model.add(MaxPooling1D(5)) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(1024, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(512, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(256, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(128, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(len(language_codes), kernel_initializer='glorot_uniform', activation='softmax')) model_optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) model.compile(loss='categorical_crossentropy', optimizer=model_optimizer, metrics=['accuracy']) # Train model.fit(x_train, y_train, epochs=10, validation_split=0.10, batch_size=64, verbose=2, shuffle=True) model.save(model_path)