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 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 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 make_model(n_in, n_out): print(n_in, n_out) mode = "ML_SOFTMAX" model = Sequential() if mode == "MLBIN": model.add(Dropout(0.5, input_shape=(n_in, ))) model.add(Dense(4800, activation='relu', input_dim=n_in)) model.add(Dropout(0.5)) model.add(Dense(2400, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1200, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(n_out, activation='sigmoid')) # sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # optimiser = Adam(0.0002, 0.5) optimiser = Adam() model.compile(loss="binary_crossentropy", optimizer='rmsprop') elif mode == "MLBIN_SMALL": model.add(Dropout(0.5, input_shape=(n_in, ))) model.add(Dense(8 * n_out, activation='relu', input_dim=n_in)) model.add(Dropout(0.5)) model.add(Dense(8 * n_out, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(8 * n_out, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(8 * n_out, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(n_out, activation='sigmoid')) # sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # optimiser = Adam(0.0002, 0.5) optimiser = Adam() model.compile(loss="binary_crossentropy", optimizer='rmsprop') elif mode == "ML_SOFTMAX": model.add(Dropout(0.5, input_shape=(n_in, ))) model.add(Dense(8 * n_out, activation='relu', input_dim=n_in)) model.add(Dropout(0.5)) model.add(Dense(8 * n_out, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(8 * n_out, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(4 * n_out, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(n_out, activation='softmax')) # sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # optimiser = Adam(0.0002, 0.5) optimiser = Adam() model.compile(loss="categorical_crossentropy", optimizer='rmsprop') return model
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 build_model(): model = Sequential() # Reshape In:[Batch_size,28,28] Out:[Batch_size,28,28,1] model.add( Reshape(name="Reshape", input_shape=(28, 28), target_shape=(28, 28, 1))) # Conv2D In:[Batch_size,28,28,1] Out:[Batch_size,28,28,32] model.add( Conv2D(name="Conv_1", filters=32, input_shape=(28, 28, 1), kernel_size=(5, 5), padding="same", activation="relu", kernel_initializer="glorot_uniform", kernel_regularizer=l2(0.0001))) # Max_pool2D In:[Batch_size,28,28,32] Out:[Batch_size,14,14,32] model.add(MaxPooling2D(name="MaxPool_1", pool_size=(2, 2), strides=(2, 2))) # Conv2D In:[Batch_size,14,14,32] Out:[Batch_size,14,14,64] model.add( Conv2D(name="Conv_2", filters=64, kernel_size=(5, 5), padding="same", activation="relu", kernel_regularizer=l2(0.0001))) # Max_pool2D In:[Batch_size,14,14,64] Out:[Batch_size,7,7,64] model.add(MaxPooling2D(name="MaxPool_2", pool_size=(2, 2), strides=(2, 2))) # Flattern In:[Batch_size,7,7,64] Out:[Batch_size,7*7*64] model.add(Flatten(name="Flattern")) # Dense In:[Batch_size,7*7*64] Out:[Barch_size,1024] model.add( Dense(name="Dense_1", units=1024, activation="relu", kernel_regularizer=l2(0.0001))) # DropOut In:[Batch_size,108] model.add(Dropout(name="DropOut_1", rate=0.4)) # Dense In:[Batch_size,1024] Out:[Batch_size,10] model.add(Dense(name="Soft_max_1", activation="softmax", units=10)) optim = optimizers.Adadelta() model.compile(optimizer=optim, loss=keras.losses.categorical_crossentropy, metrics=['accuracy']) return model
def train_lstm(train_data, test_data, val_data, word_vectors, emb_len): backend.clear_session() # print("LSTM Training") x_train, y_train, x_test, y_test, x_val, y_val = split_train_test( train_data, test_data, val_data) tokenizer = Tokenizer(num_words=MAX_NUMBER_WORDS, filters='!"#$%&()*+,-./:;<=>?@[\\]^_`{|}~\t\n\'', lower=True) tokenizer.fit_on_texts(x_train) word_index = tokenizer.word_index # print('\tFound %s unique tokens.' % len(word_index)) x_train = tokenizer.texts_to_sequences(x_train) x_train = pad_sequences(x_train, maxlen=EMBEDDINGS_MAX_LEN_SEQ) x_val = tokenizer.texts_to_sequences(x_val) x_val = pad_sequences(x_val, maxlen=EMBEDDINGS_MAX_LEN_SEQ) # print('\tShape of data tensor:', x_train.shape) y_train = pd.get_dummies(y_train).values y_val = pd.get_dummies(y_val).values # if embeddings.find("glove") != -1: # glove_file = datapath(embeddings) # embeddings = get_tmpfile("glove2word2vec.txt") # glove2word2vec(glove_file, embeddings) # # print("Loading embeddings", embeddings) # word_vectors = KeyedVectors.load_word2vec_format(embeddings, binary=False) vocabulary_size = min(len(word_index) + 1, MAX_NUMBER_WORDS) embedding_matrix = np.zeros((vocabulary_size, emb_len)) vec = np.random.rand(emb_len) for word, i in word_index.items(): if i >= MAX_NUMBER_WORDS: continue try: embedding_vector = word_vectors[word] embedding_matrix[i] = embedding_vector except KeyError: embedding_matrix[i] = vec del word_vectors model = Sequential() model.add( Embedding(MAX_NUMBER_WORDS, emb_len, input_length=x_train.shape[1], weights=[embedding_matrix], trainable=False)) model.add(SpatialDropout1D(0.2)) model.add(LSTM(200, dropout=0.2, recurrent_dropout=0.2)) model.add(Dense(4, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=[metrics.categorical_accuracy]) epochs = 25 batch_size = 32 print("\tTraining...") history = model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(x_val, y_val), shuffle=True) print("\tEvaluating....") sequences_test = tokenizer.texts_to_sequences(x_test) x_test = pad_sequences(sequences_test, maxlen=EMBEDDINGS_MAX_LEN_SEQ) y_pred = model.predict(x_test) y_pred = [np.argmax(y) for y in y_pred] print(np.array(y_test)) print(np.array(y_pred)) _acc = classifier_evaluation.evaluate_accuracy(y_test, y_pred) _f1 = classifier_evaluation.evaluate_f_score(y_test, y_pred) _auc_roc = classifier_evaluation.evaluate_roc_auc(y_test, y_pred) _precision = classifier_evaluation.evaluate_precision(y_test, y_pred) _recall = classifier_evaluation.evaluate_recall(y_test, y_pred) classifier_evaluation.full_evaluation(y_test, y_pred) del embedding_matrix, embedding_vector, x_train, y_train, x_test, y_test, y_pred, history return _acc, _f1, _auc_roc, _precision, _recall
def LeNet(input_shape): model = Sequential() model.add( Conv2D(6, (5, 5), padding='valid', activation='relu', kernel_initializer='he_normal', input_shape=input_shape)) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add( Conv2D(16, (5, 5), padding='valid', activation='relu', kernel_initializer='he_normal')) model.add(MaxPooling2D((2, 2), strides=(2, 2))) model.add(Flatten()) model.add(Dense(120, activation='relu', kernel_initializer='he_normal')) model.add(Dense(84, activation='relu', kernel_initializer='he_normal')) return model
from keras import Sequential from keras.layers import Conv2D, Activation, MaxPooling2D, Flatten, Dense, Dropout from keras.preprocessing.image import ImageDataGenerator dimensions = [64, 64, 3] batch_size = 16 model = Sequential() model.add( Conv2D(32, (3, 3), input_shape=(dimensions[0], dimensions[1], dimensions[2]), data_format="channels_last")) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, (3, 3))) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, (3, 3))) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(32)) model.add(Activation("relu")) model.add(Dropout(0.5)) model.add(Dense(4)) model.add(Activation("softmax"))
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=seed) print y_train[3] y_train = to_categorical(y_train) y_test = to_categorical(y_test) print len(X_train) print len(y_train) print y_train[1] cls = Sequential() cls.add(Dense(7,input_dim=7,activation='relu',kernel_initializer='random_uniform')) cls.add(Dense(30,activation='relu',kernel_initializer='random_uniform')) cls.add(Dense(3,activation='softmax',kernel_initializer='random_uniform')) opt = Adam(lr=INIT_LR) cls.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) print ("TRAINING MODEL") history = cls.fit(X_train,y_train,epochs=EPOCHS,steps_per_epoch=10,validation_split=0.2,validation_steps=50)
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
def keras_model_provider(optimizer='adam'): model = Sequential() model.add(Dense(1, input_dim=1, activation='sigmoid')) model.compile(optimizer, loss='mse') return model
def keras_model_provider(): model = Sequential() model.add(Dense(1, input_dim=1, activation='sigmoid')) model.compile(optimizer='Adam', loss=loss_provider("bar")) return model, loss_provider("bar")
X_TRAIN.append(sentence) X_TRAIN = sequence.pad_sequences(X_TRAIN, maxlen=30, value=0.0, padding='post', dtype='float32') X_TRAIN = np.asarray(X_TRAIN) from keras.layers import Dense, Dropout from keras import Sequential model = Sequential() from keras.layers.embeddings import Embedding from keras.layers import LSTM model.add(Dense(30, input_shape=(30, 100))) model.add(LSTM(30)) model.add(Dense(1, activation='relu')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) batch_size = 128 model.fit(X_TRAIN, ytrain, batch_size=batch_size, epochs=30) model.save('abusive.h5') X_TEST = [] for i in xtest: sentence = [] for words in i.split(): temp = model1[words]
def init(self, num_words, embedding_matrix): print("Creating RNN model") model_glove = Sequential() model_glove.add( Embedding(num_words, EMBEDDING_DIMENSION, input_length=MAX_SEQUENCE_LENGTH, weights=[embedding_matrix], trainable=False)) model_glove.add(Dropout(0.2)) model_glove.add(Conv1D(64, 5, activation='relu')) model_glove.add(MaxPooling1D(pool_size=4)) model_glove.add(LSTM(100)) model_glove.add(Dense(1, activation='sigmoid')) model_glove.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) self.model = model_glove
#create multiexample X1_test = np.tile(th, (100, 1)) Y1_test = np.tile(test3, (100, 1)) X_test = np.tile(tg, (100, 1)) Y_test = np.tile(test, (100, 1)) p_test = np.tile(test3, (100, 1)) Xf_test = np.append(X_test, X1_test, axis=0) Yf_test = np.append(Y_test, Y1_test, axis=0) Xf_test = np.append(Xf_test, Xf_test, axis=0) Yf_test = np.append(Yf_test, Yf_test, axis=0) t1 = time.time() #model model = Sequential() model.add(Dense(units=64, activation='relu', input_dim=5)) model.add(Dense(units=64, activation='relu')) model.add(Dense(units=4)) model.add(Activation('linear')) model.compile(loss='mse', optimizer='adam', metrics=['mae']) #model fit model.fit(Yf_test, Xf_test, epochs=180, validation_split=0.2, verbose=0) t2 = time.time() model.save('stupid_model.h5') #save model print(t2 - t1, 'seconds') #score of model score = model.predict(test) print(score)
test_tweets = [] for test in X_test: tweet = clean_tweet(test) words = [ token for grp, token, token_num, (start_index, end_index) in ht.tokenize(tweet) ] vector = [dict.token2id[word] for word in words] test_tweets.append(vector) test_tweets = sequence.pad_sequences(np.array(test_tweets), maxlen=150) # LSTM model = Sequential() model.add(Embedding(len(dict.keys()), 256, dropout=0.2)) model.add(LSTM(100, dropout_W=0.2, dropout_U=0.2)) model.add(Dense(2)) model.add(Activation('softmax')) # model.load_weights("lstm_model.hdf5") model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) checkpointer = callbacks.ModelCheckpoint( filepath="checkpoint-{epoch:02d}.hdf5", verbose=1, save_best_only=True, monitor='loss') csv_logger = CSVLogger('training_set_iranalysis1.csv', separator=',',
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
def get_model(model_name, input_shape): """ Generate the required model and return it :return: Model created """ # Models are inspired from # CNN - https://yashk2810.github.io/Applying-Convolutional-Neural-Network-on-the-MNIST-dataset/ # LSTM - https://github.com/harry-7/Deep-Sentiment-Analysis/blob/master/code/generatePureLSTM.py model = Sequential() if model_name == 'CNN': model.add(Conv2D(8, (13, 13), input_shape=(input_shape[0], input_shape[1], 1))) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(Conv2D(8, (13, 13))) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 1))) model.add(Conv2D(8, (13, 13))) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(Conv2D(8, (2, 2))) model.add(BatchNormalization(axis=-1)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 1))) model.add(Flatten()) model.add(Dense(64)) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Dropout(0.2)) elif model_name == 'LSTM': model.add(LSTM(128, input_shape=(input_shape[0], input_shape[1]))) model.add(Dropout(0.5)) model.add(Dense(32, activation='relu')) model.add(Dense(16, activation='tanh')) model.add(Dense(len(class_labels), activation='softmax')) #model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) return model
def VGG(X, Y): model = Sequential() #layer_1 model.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=X.shape[1:], padding='same', data_format='channels_last', activation='relu', kernel_initializer='uniform')) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', kernel_initializer='uniform', activation='relu')) model.add(MaxPooling2D((2, 2))) #layer_2 model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', kernel_initializer='uniform')) model.add( Conv2D(128, (2, 2), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', kernel_initializer='uniform')) model.add(MaxPooling2D((2, 2))) #layer_3 model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add( Conv2D(256, (1, 1), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add(MaxPooling2D((2, 2))) #layer_4 model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add( Conv2D(512, (1, 1), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add(MaxPooling2D((2, 2))) #layer_5 model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add( Conv2D(512, (1, 1), strides=(1, 1), padding='same', data_format='channels_last', activation='relu')) model.add(MaxPooling2D((2, 2))) #全连接层+ model.add(Flatten()) #拉平 model.add(Dense(4096, activation='relu')) model.add(Dense(4096, activation='relu')) model.add(Dense(1000, activation='relu')) model.add(Dense(10, activation='softmax')) model.summary() model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
import sys sys.path.append("I:/New Folder/utils") import regression_utils as rutils from keras.layers import Dense from keras import Sequential, metrics import keras_utils as kutils from sklearn import model_selection #linear pattern in 2d X, y = rutils.generate_linear_synthetic_data_regression(n_samples=200, n_features=1, n_informative=1, noise = 100) X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.1, random_state=1) rutils.plot_data_2d_regression(X_train, y_train) model = Sequential() model.add(Dense(units=1, input_shape=(1,), activation='linear')) model.compile(optimizer='sgd', loss='mean_squared_error', metrics=[metrics.mean_squared_error]) history = model.fit(x=X_train, y=y_train, verbose=3, epochs=100, batch_size=10, validation_split=0.1) print(model.summary()) print(model.get_weights()) kutils.plot_loss(history) rutils.plot_model_2d_regression(model, X_train, y_train) y_pred = model.predict(X_test) rutils.regression_performance(model, X_test, y_test)
def get_model(n, model_type, dropout_value, lr_rate): model = Sequential() model.add( LSTM(types[model_type][0], kernel_initializer=tf.keras.initializers.Identity(), return_sequences=True, input_shape=(1, n))) model.add(Activation(custom1)) for i in types[model_type][1:len(types[model_type]) - 1]: model.add(LSTM(i, dropout=dropout_value, return_sequences=True)) model.add(Activation(custom1)) model.add(LSTM(types[model_type][-1])) model.add(Activation(custom1)) model.add(Dense(1)) model.add(Activation(custom1)) model.compile(loss=tf.keras.losses.MeanAbsoluteError(), optimizer=keras.optimizers.Adam(lr_rate), metrics=[tf.keras.metrics.MeanAbsoluteError()]) return model
def neural_network_regression(): n_dim = 368 data = pd.read_csv('./data/train_data_salary.csv') # data = data.iloc[:10000, :] # print(data) train_data_x = data.iloc[:, 1:-1] train_data_y = data.iloc[:, n_dim:] train_data_x = train_data_x.values train_data_y[str(n_dim)] = (train_data_y - np.min(train_data_y)) / (np.max(train_data_y) - np.min(train_data_y)) train_data_y2 = np.array(train_data_y[str(n_dim)].tolist()) max_val = np.max(train_data_y[str(n_dim - 1)]) min_val = np.min(train_data_y[str(n_dim - 1)]) print(max_val) print(min_val) x_train, x_test, y_train, y_test = train_test_split(train_data_x, train_data_y2, test_size=0.2) # 需要做标准化处理对于特征值处理 # try: # std_x = joblib.load('./data/model/std2.model') # except Exception as e: # std_x = StandardScaler() std_x = StandardScaler() x_train = std_x.fit_transform(x_train) x_test = std_x.transform(x_test) joblib.dump(std_x, './data/model/std2.model') # 创建模型,Sequential(): 多个网络层的线性堆叠模型 model = Sequential() # 添加神经网络层,并指定,input_dim:输入维度的个数,units:神经元的个数 model.add(Dense(input_dim=n_dim-1, units=256, activation='relu')) model.add(Dropout(0.1)) # model.add(Dense(input_dim=n_dim - 1, units=256)) model.add(Dense(units=128, activation='relu')) model.add(Dropout(0.1)) model.add(Dense(units=1, )) rmsprop = RMSprop(lr=0.0001, rho=0.9, epsilon=1e-08, decay=0.0) # 选择损失函数,优化器 model.compile(optimizer=rmsprop, loss='mse'), # optimizer='sgd') model.fit(x_train, y_train, epochs=50, batch_size=100) print('testing...') # 评估测试集 cost = model.evaluate(x_test, y_test, batch_size=400) tail_line() print('test cost is: ', cost) y_predict = model.predict(x_test) y_predict = np.array([i[0] for i in y_predict]) y_rd_predict = y_predict * (np.max(train_data_y[str(n_dim - 1)]) - np.min(train_data_y[str(n_dim - 1)])) + np.min( train_data_y[str(n_dim - 1)]) y_test = y_test * (np.max(train_data_y[str(n_dim - 1)]) - np.min(train_data_y[str(n_dim - 1)])) + np.min( train_data_y[str(n_dim - 1)]) print(y_rd_predict) print(y_test) percent = [(y_rd_predict[a] - b) / y_rd_predict[a] for a, b in enumerate(y_test)] di = defaultdict(int) for i in percent: # if -200 < i < 200: di[round(i, 2)] += 1 dis = {a: b for a, b in sorted(di.items(), key=lambda x: x[1], reverse=True)} dis2 = {a: b for a, b in sorted(di.items(), key=lambda x: x[1], reverse=True) if a <= 0.3} per = sum(dis2.values()) / sum(dis.values()) print(di) tail_line() print("概率为:", per) t = sorted(di.items(), key=lambda x: x[0], reverse=True) t = [(a, b) for a, b in t if -5 <= a <= 5] plt.plot([a for a, b in t], [b for a, b in t]) plt.show() tail_line() model.save('./data/model/neural_network_regression.model')
X_test_ones = X_test_ones.reshape((X_test_ones.shape[0], 300, 100)) X_test_zeros = X_test_zeros.reshape((X_test_zeros.shape[0], 300, 100)) #classifier = LogisticRegression() #classifier.fit(X_train, y_train) #score = classifier.score(X_test, y_test) print(X_test_ones.shape) print(X_test_zeros.shape) print(Y_test_ones) print(Y_test_zeros) input_dim = X_train.shape[1] model = Sequential() #model.add(layers.Embedding(300,100,input_length=30000)) #model.add(layers.Conv1D(10,100,activation='relu')) #model.add(layers.MaxPool1D(pool_size=2, strides=1)) #model.add(layers.Flatten()) model.add(layers.Conv1D(40, 100, activation='relu')) model.add(layers.GlobalMaxPool1D()) #model.add(layers.Flatten()) model.add(layers.Dense(10, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.1, nesterov=True) model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy']) history = model.fit(X_train, y_train, epochs=50, verbose=True, validation_data=(X_test, y_test), batch_size=batch_size) model.summary() loss, accuracy = model.evaluate(X_train, y_train, verbose=False)
def define_model_snn_cifar10(): model = Sequential() model.add(Conv1D(16, 3, strides=2, padding='same', input_shape=[128, 1], kernel_initializer='lecun_normal', bias_initializer='zeros')) model.add(Activation('selu')) model.add(Conv1D(16, 3, kernel_initializer='lecun_normal', bias_initializer='zeros')) model.add(Activation('selu')) model.add(MaxPooling1D(pool_size=2)) model.add(AlphaDropout(0.1)) model.add(Conv1D(32, 3, padding='same', kernel_initializer='lecun_normal', bias_initializer='zeros')) model.add(Activation('selu')) model.add(Conv1D(32, 3, kernel_initializer='lecun_normal', bias_initializer='zeros')) model.add(Activation('selu')) model.add(MaxPooling1D(pool_size=2)) model.add(AlphaDropout(0.1)) model.add(Flatten()) model.add(Dense(41, kernel_initializer='lecun_normal', bias_initializer='zeros')) model.add(Activation('selu')) model.add(AlphaDropout(0.2)) model.add(Dense(41, kernel_initializer='lecun_normal', bias_initializer='zeros')) model.add(Activation('softmax')) # initiate RMSprop optimizer opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6) # Let's train the model using RMSprop model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy', 'top_k_categorical_accuracy']) print(model.summary()) return model
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 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(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=20, verbose=1, validation_data=(test_data, test_labels_one_hot)) # Accuracy plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show()
# Now build the Training / Test data sets by splitting off this month. # The last 20 rows of the dataframe represent Nov, 2017. We'll use that to test with and the # rest will be used for training spxTestData = spxData[-20:] spxData = spxData[0:-20] # Convert them into NumPy arrays for processing train_input_data_ = np.asarray(spxData[input_cols]) train_output_data = np.asarray(spxData["next10DaysPrice"]) test_input_data = np.asarray(spxTestData[input_cols]) test_output_data = np.asarray(spxTestData["next10DaysPrice"]) # We build a sequential NN model = Sequential() model.add(Dense(units=20, input_shape=(len(input_cols),), kernel_initializer="uniform", activation="tanh")) # If we over fit, can regularize by dropping some samples model.add(Dropout(0.1)) model.add(Dense(units=300, kernel_initializer="uniform", activation="tanh")) model.add(Dense(units=1, kernel_initializer="uniform", activation="tanh")) # Stochastic gradient descent optimizer with some sensible defaults. sgd = optimizers.SGD(lr=0.01, momentum=0.9) model.compile(loss='mean_squared_error', optimizer=sgd) # Uncomment this to view the model summary # model.summary() # Train the model. hist = model.fit(train_input_data_, train_output_data, epochs=15)
def model_builder(model_input, model_output): model = Sequential() # 2*[Convolution operation > Nonlinear activation (relu)] > Pooling operation model.add(Conv2D(32, (3, 3), activation='relu', padding='valid', input_shape=tuple(model_input.shape[1:]))) model.add(Conv2D(16, (3, 3), activation='relu', padding='valid')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Conv2D(64, (3, 3), activation='relu', padding='valid')) model.add(Conv2D(32, (3, 3), activation='relu', padding='valid')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(model_output.shape[1], activation='softmax')) # Nesterov momentum included for parameters update, makes correction to parameters update values # by taking into account the approximated future value of the objective function # However does not account for the importance for each parameter when performing updates # op = optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True) # Nesterov Momentum Adaptive Moment Estimation # op = optimizers.Nadam() # RMSProp op = optimizers.RMSprop() model.compile(optimizer=op, metrics=['accuracy'], loss='categorical_crossentropy') return model
height = len(cm[0]) for x in range(width): for y in range(height): ax.annotate(str(cm[x][y]), xy=(y, x), horizontalalignment='center', verticalalignment='center', color=getFontColor(cm[x][y])) # add genres as ticks alphabet = mods plt.xticks(range(width), alphabet[:width], rotation=30) plt.yticks(range(height), alphabet[:height]) return plt from keras import layers from keras import Sequential,layers model=Sequential() model.add(layers.LSTM(128,dropout=0.7,return_sequences=True,input_shape=(128,2))) model.add(layers.LSTM(128,dropout=0.7)) model.add(layers.Dense(len(mods),activation="sigmoid")) model.compile(loss='categorical_crossentropy', optimizer='adam',metrics=['accuracy']) nb_epoch = 80 # number of epochs to train on batch_size = 256 # training batch size ###################################################train the network################################################# history = model.fit(X_train, Y_train, batch_size=batch_size, epochs=nb_epoch, verbose=1, validation_data=(X_test, Y_test) ) # we re-load the best weights once training is finished
class ChatDNN: def __init__(self, input_dim, embedding_dim=None, embedding_weights=None): self.input_dim = input_dim self.embedding_dim = embedding_dim self.embedding_weights = embedding_weights self.model = None def dnn_create(self, n_classes, input_shape): self.model = Sequential() if self.embedding_weights is not None: self.model.add( Embedding(input_dim=self.input_dim, output_dim=self.embedding_dim, input_shape=input_shape, weights=[self.embedding_weights ])) # Adding Input Length else: self.model.add( Embedding(input_dim=self.input_dim, output_dim=self.embedding_dim, input_shape=input_shape)) # Adding Input Length self.model.add(Dense(512, activation='relu')) self.model.add(Dropout(0.5)) self.model.add(Flatten()) self.model.add(Dense(512, activation='relu')) self.model.add(Dropout(0.5)) self.model.add(Dense(n_classes, activation='softmax')) print('Compiling the Model...') self.model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) self.model.summary() return self def train(self, x_train, y_train, x_test, y_test): print('Defining a Simple Keras Model...') n_classes = len(set(y_train.tolist() + y_test.tolist())) print(n_classes) y_train = np_utils.to_categorical(y_train, n_classes) y_test = np_utils.to_categorical(y_test, n_classes) print((x_train.shape[1], )) self.dnn_create(n_classes, (x_train.shape[1], )) print("Train...") self.model.fit(x_train, y_train, batch_size=setting.BATCH_SIZE, epochs=setting.N_EPOCH, verbose=1, validation_data=(x_test, y_test)) print("Evaluate...") score = self.model.evaluate(x_test, y_test, batch_size=setting.BATCH_SIZE) print('Test score:', score) return self def predict(self): pass
class Network(object): def __init__(self, input_size, hidden_size, output_size, lr): ''' Train and validate network using notMNIST data. Args: input_size: size of input feature hidden_size: size of hidden layer output_size: size of output layer lr: learning rate name: network's scope name Returns: nothing ''' self.model = Sequential() self.model.add( Dense(hidden_size, kernel_initializer=TruncatedNormal(stddev=input_size**-0.5), bias_initializer=Zeros(), activation='relu', input_shape=(input_size, ))) self.model.add( Dense(output_size, kernel_initializer=TruncatedNormal(stddev=hidden_size**-0.5), bias_initializer=Zeros(), activation='softmax')) self.model.compile(loss='sparse_categorical_crossentropy', optimizer=SGD(lr=lr), metrics=['accuracy']) def train(self, num_epochs, batch_size, train_features, train_labels, valid_features, valid_labels, checkpoint_fn): ''' Train and validate network using notMNIST data. Args: num_epochs: number of epochs to train batch_size: batch_size train_features: training features with shape [batch_size, feature_size] train_labels: training labels with shape [batch_size, label_size] valid_features: validation features with shape [batch_size, feature_size] valid_labels: validation labels with shape [batch_size, label_size] checkpoint_fn: checkpoint filename to save after training Returns: train_losses: training losses val_losses: validation losses ''' num_of_batches = len(train_features) // batch_size history = self.model.fit(x=train_features, y=train_labels, validation_data=(valid_features, valid_labels), epochs=num_epochs, batch_size=batch_size) self.model.save(checkpoint_fn) print('[INFO] Training weights have been ' 'successfully saved to {}.'.format(checkpoint_fn)) return history.history['loss'], history.history['val_loss'] def inference(self, test_features, checkpoint_fn): ''' Test network using notMNIST test data. Args: test_features: test features with shape [batch_size, feature_size] checkpoint_fn: trained checkpoint filename Returns: predictions: predictions made by the network ''' model = models.load_model(checkpoint_fn) print('[INFO] Training weights have been ' 'successfully loaded from {}.'.format(checkpoint_fn)) predictions = model.predict(test_features).argmax(axis=1) return predictions
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
from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype("float32") x_test = x_test.reshape(x_test.shape[0], 28, 28, 1).astype("float32") x_train /= 255 x_test /= 255 y_train = keras.utils.to_categorical(y_train, 10) y_test = keras.utils.to_categorical(y_test, 10) model = Sequential() conv = Conv2D(32, (3, 3), activation="relu", input_shape=(28, 28, 1)) model.add(conv) conv_2 = Conv2D(64, (3, 3), activation="relu") model.add(conv_2) pool = MaxPooling2D((2, 2)) model.add(pool) dropout = Dropout(0.25) model.add(dropout) flatten = Flatten() model.add(flatten) dense = Dense(128, activation="relu") model.add(dense)
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))
else: x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) model = Sequential() model.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) #in case overfitting model.add(Dropout(0.25)) model.add(Flatten()) #full connected output128 model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) #optimizing model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.Adadelta(), metrics=['accuracy']) model.fit(x_train,
def create_model(num_frame, num_joint): model = Sequential() model.add( CuDNNLSTM(50, input_shape=(num_frame, num_joint), return_sequences=False)) model.add(Dropout(0.4)) #使用Dropout函数可以使模型有更多的机会学习到多种独立的表征 model.add(Dense(256)) model.add(Dropout(0.4)) model.add(Dense(64)) model.add(Dropout(0.4)) model.add(Dense(4, activation='softmax')) return model
def build_discriminator(): dis_model = Sequential() dis_model.add(Conv2D(128, (5, 5), padding="same", input_shape=(64, 64, 3))) dis_model.add(LeakyReLU(alpha=0.2)) dis_model.add(MaxPooling2D(pool_size=(2, 2))) dis_model.add(Conv2D(256, (3, 3))) dis_model.add(LeakyReLU(alpha=0.2)) dis_model.add(MaxPooling2D(pool_size=(2, 2))) dis_model.add(Conv2D(512, (3, 3))) dis_model.add(LeakyReLU(alpha=0.2)) dis_model.add(MaxPooling2D(pool_size=(2, 2))) dis_model.add(Flatten()) dis_model.add(Dense(1024)) dis_model.add(LeakyReLU(alpha=0.2)) dis_model.add(Dense(1)) dis_model.add(Activation("sigmoid")) return dis_model
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_model(): _model = Sequential() _model.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=tuple(map(sum, zip(TARGET_SIZE, (0, 0, 2)))))) _model.add(Conv2D(64, (3, 3), activation='relu')) _model.add(MaxPooling2D(pool_size=(2, 2))) _model.add(Dropout(0.25)) _model.add(Flatten()) _model.add(Dense(128, activation='relu')) _model.add(Dropout(0.5)) _model.add(Dense(dic.__len__(), activation='softmax')) _model.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['accuracy']) return _model
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)