def learn_model(x_train, y_train, x_test, y_test, take_components, save_path=None, do_pca=False): # pca select main features if do_pca: pca = PCA(n_components=take_components) print("Compute pca relevant features with " + str(take_components) + " percent of variance") previous_dims = len(x_train[0]) x_train = pca.fit_transform(x_train) x_test = pca.transform(x_test) print(str(len(x_train[0])) + " dims are used from initially " + str(previous_dims)) # expand dims x_train = np.expand_dims(x_train, axis=2) x_test = np.expand_dims(x_test, axis=2) # change label to categorical y_train = to_categorical(y_train) y_test = to_categorical(y_test) # build model model = Sequential() model.add(Conv1D(256, 8, padding='same', input_shape=(x_train.shape[1], 1))) model.add(Activation('relu')) model.add(Conv1D(256, 8, padding='same')) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Dropout(0.6)) model.add(Conv1D(128, 8, padding='same')) model.add(Activation('relu')) model.add(Conv1D(128, 8, padding='same')) model.add(Activation('relu')) model.add(Conv1D(128, 8, padding='same')) model.add(Activation('relu')) model.add(Conv1D(128, 8, padding='same')) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Dropout(0.6)) model.add(Conv1D(64, 8, padding='same')) model.add(Activation('relu')) model.add(Conv1D(64, 8, padding='same')) model.add(Activation('relu')) model.add(Flatten()) model.add(Dense(4096, activation='relu')) model.add(Dense(4096, activation='relu')) model.add(Dropout(0.6)) model.add(Dense(2)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.SGD(lr=0.001, momentum=0.9, decay=0.0), metrics=['acc']) # fit network model.fit(x_train, y_train, batch_size=16, epochs=33) # evaluate model _, accuracy = model.evaluate(x_test, y_test) # save model if save_path is not None: model.save(save_path) return accuracy
def prueba_2(): cantidad_twits=10 # define class twits test = load_test() twits = preprocesing(test[:cantidad_twits, 0]) print(f"\ntwiters:\n{twits}") # define class labels labels = test[:cantidad_twits, 1].astype('float32') print(f"\nlabels:\n{labels}") # prepare tokenizer t = Tokenizer() t.fit_on_texts(twits) vocab_size = len(t.word_index) + 1 # integer encode the documents encoded_twits = t.texts_to_sequences(twits) print(f"\nencoded_twits:\n{encoded_twits}") # pad documents to a max length of 4 words # Calculo largo maximo mylen = np.vectorize(len) lens=mylen(encoded_twits) max_len=max(lens) #TODO: Contar el twtit mas largo max_length = max_len padded_twits = pad_sequences(encoded_twits, maxlen=max_length, padding='post') print(f"\npadded_twits:\n{padded_twits}") # load the whole embedding into memory embeddings_index = dict() f = open('fasttext.es.300.txt') for line in f: values = line.split() word = values[0] coefs = np.asarray(values[1:], dtype='float32') embeddings_index[word] = coefs f.close() print('Loaded %s word vectors.' % len(embeddings_index)) # create a weight matrix for words in training docs embedding_matrix = np.zeros((vocab_size, 300)) for word, i in t.word_index.items(): embedding_vector = embeddings_index.get(word) if embedding_vector is not None: embedding_matrix[i] = embedding_vector # define model model = Sequential() e = Embedding(vocab_size, 300, weights=[embedding_matrix], input_length=max_length, trainable=False) model.add(e) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) # compile the model model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # summarize the model print(model.summary()) # fit the model model.fit(padded_twits, labels, epochs=50, verbose=0) # evaluate the model loss, accuracy = model.evaluate(padded_twits, labels, verbose=0) print('Accuracy: %f' % (accuracy * 100))
class DNN(BaseTrainer): @Decorator.log(True) def load_data(self, **dict): print(dict) self.traindata = pd.read_csv(dict['train'], header=None) self.testdata = pd.read_csv(dict['test'], header=None) X = self.traindata.iloc[:, 1:42] Y = self.traindata.iloc[:, 0] C = self.testdata.iloc[:, 0] T = self.testdata.iloc[:, 1:42] trainX = np.array(X) testT = np.array(T) trainX.astype(float) testT.astype(float) scaler = Normalizer().fit(trainX) trainX = scaler.transform(trainX) scaler = Normalizer().fit(testT) testT = scaler.transform(testT) self.y_train = np.array(Y) self.y_test = np.array(C) self.X_train = np.array(trainX) self.X_test = np.array(testT) def train(self): batch_size = 64 nb_epoch = 100 if self.has_train: nb_epoch = nb_epoch - self.epoch print('new epoch', nb_epoch) self.model.fit(self.X_train, self.y_train, batch_size=batch_size, epochs=nb_epoch, callbacks=[self.checkpointer, self.csv_logger]) else: # 1. define the network self.model = Sequential() self.model.add(Dense(1024, input_dim=41, activation='relu')) self.model.add(Dropout(0.01)) self.model.add(Dense(1)) self.model.add(Activation('sigmoid')) self.model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) self.model.fit(self.X_train, self.y_train, batch_size=batch_size, epochs=nb_epoch, callbacks=[self.checkpointer, self.csv_logger]) self.model.save("./dnn1layer_model.hdf5") score, acc = self.model.evaluate(self.X_test, self.y_test) print('Test score:', score) print('Test accuracy', acc)
def train_net(steps, epochs): # Get images X = [] for filename in os.listdir('./color_images/Train/'): X.append(img_to_array(load_img('./color_images/Train/' + filename))) # print(filename) X = np.array(X, dtype=float) # Set up training and test data split = int(0.95 * len(X)) Xtrain = X[:split] Xtrain = 1.0 / 255 * Xtrain # Design the neural network model = Sequential() model.add(InputLayer(input_shape=(None, None, 1))) model.add(Conv2D(8, (3, 3), input_shape=(None, None, 1), activation='relu', padding='same', strides=2)) model.add(Conv2D(8, (3, 3), activation='relu', padding='same')) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(Conv2D(16, (3, 3), activation='relu', padding='same', strides=2)) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(Conv2D(32, (3, 3), activation='relu', padding='same', strides=2)) model.add(UpSampling2D((2, 2))) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(16, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(2, (3, 3), activation='tanh', padding='same')) # Finish model model.compile(optimizer='rmsprop', loss='mse') # Image transformer datagen = ImageDataGenerator( shear_range=0.2, zoom_range=0.2, rotation_range=20, horizontal_flip=True) # Generate training data batch_size = 50 def image_a_b_gen(batch_size): for batch in datagen.flow(Xtrain, batch_size=batch_size): lab_batch = rgb2lab(batch) X_batch = lab_batch[:, :, :, 0] Y_batch = lab_batch[:, :, :, 1:] / 128 yield (X_batch.reshape(X_batch.shape + (1,)), Y_batch) # Train model TensorBoard(log_dir='/output') model.fit_generator(image_a_b_gen(batch_size), steps_per_epoch=steps, epochs=epochs) # Test images Xtest = rgb2lab(1.0 / 255 * X[split:])[:, :, :, 0] Xtest = Xtest.reshape(Xtest.shape + (1,)) Ytest = rgb2lab(1.0 / 255 * X[split:])[:, :, :, 1:] Ytest = Ytest / 128 print(model.evaluate(Xtest, Ytest, batch_size=batch_size)) model.save('./result/network.h5') del model
def model(x_test, x_train, y_test, y_train): model = Sequential() model_choice = {{choice(['one', 'two'])}} if model_choice == 'one': model.add(Conv2D(64, kernel_size=3, activation='relu',padding='same', input_shape=(img_rows, img_cols, color_type))) model.add(Conv2D(128, kernel_size=3, activation='relu',padding='same')) model.add(MaxPooling2D(pool_size=2,strides=2)) model.add(Dropout({{uniform(0, 1)}})) model.add(Conv2D(256, kernel_size=3, activation='relu')) model.add(Conv2D(512, kernel_size=3, activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=2,strides=2)) model.add(Dropout({{uniform(0, 1)}})) elif model_choice == 'two': model.add(Conv2D(64, kernel_size=3, activation='relu',padding='same', input_shape=(img_rows, img_cols, color_type))) model.add(Conv2D(128, kernel_size=3, activation='relu',padding='same')) model.add(MaxPooling2D(pool_size=2,strides=2)) model.add(Dropout({{uniform(0, 1)}})) model.add(Conv2D(256, kernel_size=3, activation='relu')) model.add(Conv2D(512, kernel_size=3, activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=2,strides=2)) model.add(Dropout({{uniform(0, 1)}})) model.add(Flatten()) model.add(Dense({{choice([256, 512,1024])}}, activation='relu')) model.add(BatchNormalization()) model.add(Dropout({{uniform(0, 1)}})) choiceval = {{choice(['one', 'two'])}} if choiceval == 'two': model.add(Dense({{choice([256, 512,1024])}}, activation='relu')) model.add(BatchNormalization()) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10, activation='softmax')) adam = keras.optimizers.Adam(lr=0.001) model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=adam) model.fit(x_train, y_train, batch_size=256, nb_epoch=15, verbose=2, validation_data=(x_test, y_test)) score, acc = model.evaluate(x_test, y_test, verbose=0) print('Val accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def prueba_1(): docs = ['Well done!', 'Good work', 'Great effort', 'nice work', 'Excellent!', 'Weak', 'Poor effort!', 'not good', 'poor work', 'Could have done better.'] # define class labels labels = np.array([1,1,1,1,1,0,0,0,0,0]) # integer encode the documents vocab_size = 50 encoded_docs = [one_hot(d, vocab_size) for d in docs] print(encoded_docs) # pad documents to a max length of 4 words max_length = 4 padded_docs = pad_sequences(encoded_docs, maxlen=max_length, padding='post') print(padded_docs) # define the model model = Sequential() model.add(Embedding(vocab_size, 8, input_length=max_length)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) # compile the model model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # summarize the model print(model.summary()) # fit the model model.fit(padded_docs, labels, epochs=50, verbose=0) # evaluate the model loss, accuracy = model.evaluate(padded_docs, labels, verbose=0) print('Accuracy: %f' % (accuracy*100))
class AudioFeaturesModel: def __init__(self, model_name, le, layers): self.le = le self.model = Sequential(name=model_name) # Builds layers based on the structure in model_structures for layer in layers: self.model.add(layer) def compile(self): """Compile the model and print the structure""" self.model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam') self.model.summary() def test_model(self, x_data, y_data): """Calculate the model's accuracy on the input dataset""" score = self.model.evaluate(x_data, y_data, verbose=0) accuracy = 100 * score[1] return accuracy def train_model(self, x_train, y_train, x_val, y_val): """Train and save the model""" early_stopping = EarlyStopping(monitor='val_loss', patience=sounds_config.patience, mode='min') checkpointer = ModelCheckpoint(filepath=f'{sounds_config.sounds_model_dir}/{self.model.name}.hdf5', verbose=1, save_best_only=True) history = self.model.fit(x_train, y_train, batch_size=sounds_config.num_batch_size, epochs=sounds_config.num_epochs, validation_data=(x_val, y_val), callbacks=[checkpointer, early_stopping], verbose=1) self.le.save(self.model.name) return history def calculate_confusion_matrix(self, x_test, y_test): """Calculate the probabilities required for the confusion matrix and create a dataframe""" y_pred = self.model.predict_classes(x_test) y_test = argmax(y_test, axis=1) con_mat = confusion_matrix(labels=y_test, predictions=y_pred).numpy() con_mat_norm = np.around(con_mat.astype('float') / con_mat.sum(axis=1)[:, np.newaxis], decimals=2) classes = self.le.inverse_transform(list(range(0, self.le.encoded_labels.shape[1]))) return pd.DataFrame(con_mat_norm, index=classes, columns=classes)
def trainnet(self): classifier = Sequential([ layers.Dense(4, activation='relu', kernel_initializer='random_normal', input_dim=8), layers.Dense(4, activation='relu', kernel_initializer='random_normal'), layers.Dense(1, activation='sigmoid', kernel_initializer='random_normal') ]) # Compiling the neural network classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # Fitting the data to the training dataset classifier.fit(self.X_train, self.y_train, batch_size=10, epochs=100) eval_model = classifier.evaluate(self.X_train, self.y_train) print(eval_model) nethandler().savenet(model=classifier)
class ImageFeaturesModel: def __init__(self, model_name, le, layers): self.le = le self.model = Sequential(name=model_name) for layer in layers: self.model.add(layer) def compile(self): self.model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam') self.model.summary() def test_model(self, x_data, y_data): score = self.model.evaluate(x_data, y_data, verbose=0) accuracy = 100 * score[1] return accuracy def train_model(self, x_train, y_train, x_val, y_val): early_stop = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=5) checkpointer = ModelCheckpoint(filepath=f'{self.model.name}.hdf5', verbose=1, save_best_only=True) history = self.model.fit(x_train, y_train, batch_size=config.num_batch_size, epochs=config.num_epochs, validation_data=(x_val, y_val), callbacks=[early_stop, checkpointer], verbose=1) self.le.save(self.model.name) return history
def test_crf_viterbi_accuracy(get_random_data): nb_samples = 2 timesteps = 10 embedding_dim = 4 output_dim = 5 embedding_num = 12 crf_loss_instance = ConditionalRandomFieldLoss() x, y = get_random_data(nb_samples, timesteps, x_high=embedding_num, y_high=output_dim) # right padding; left padding is not supported due to the tf.contrib.crf x[0, -4:] = 0 # test with masking, fix length model = Sequential() model.add( Embedding(embedding_num, embedding_dim, input_length=timesteps, mask_zero=True)) model.add(CRF(output_dim, name="crf_layer")) model.compile(optimizer='rmsprop', loss={"crf_layer": crf_loss_instance}, metrics=[crf_viterbi_accuracy]) model.fit(x, y, epochs=1, batch_size=10) # test viterbi_acc y_pred = model.predict(x) _, v_acc = model.evaluate(x, y) np_acc = (y_pred[x > 0] == y[x > 0]).astype('float32').mean() print(v_acc, np_acc) assert np.abs(v_acc - np_acc) < 1e-4
model.add(Embedding(len(vocab), args.embedding_size, input_length=max_answer_len)) model.add(Dropout(args.dropout)) if args.flatten: model.add(Flatten()) model.add(Reshape((1, args.embedding_size * max_answer_len))) if args.lstm_dim_2: model.add(LSTM(args.lstm_dim_1, return_sequences=True)) model.add(LSTM(args.lstm_dim_2, return_sequences=False)) else: model.add(LSTM(args.lstm_dim_1, return_sequences=False)) model.add(Dropout(args.dropout)) model.add(Dense(1, activation="linear")) optimizer = AdamOptimizer() model.compile(optimizer=optimizer, loss='mean_squared_error', metrics=['acc']) # Train the model model.fit(train_x, train_y, epochs=args.epochs, verbose=0) # Validate test_y = test_data.iloc[:, 0] test_x = test_data.iloc[:, 1:] score = model.evaluate(test_x, test_y, verbose=0) print(f"Validation_loss:{score[0]};Validation_accuracy:{score[1]};") ## --- End of your code --- ## # Save the trained model result = tf.contrib.saved_model.save_keras_model(model, os.environ['SM_MODEL_DIR']) print(f"Save Keras Model result: {result}")
# x[train] # print(train) # 2. model frame config model = Sequential() model.add(Dense(20, input_dim=60, activation='relu')) model.add(Dense(10, input_dim=60, activation='relu')) model.add(Dense(2, input_dim=10, activation='softmax')) #model.add(Dense(1, input_dim=10, activation='sigmoid')) # 3. model fitting config model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy']) # 4. model fitting #history = model.fit(x, t, epochs=100, batch_size=5, verbose=1) history = model.fit(x[mask_train], tf.keras.utils.to_categorical(t[mask_train])ㅋ, epochs=200, batch_size=5, verbose=1) t = tf.keras.utils.to_categorical(t) # 5. result result = model.evaluate(x[mask_test],tf.keras.utils.to_categorical(t[mask_test]), verbose=0) accuracies.append(result[1]) #loss = history.history['loss'] #result = model.evaluate(x, t, verbose=0) print(f'\n{nfold} fold accuracies : {accuracies}') #print(f'\n(Loss, Accuracy) = ({result[0], result[1]}') #print(f'\n(Loss, Accuracy) = ({result[0], result[1]}')
test_images = test_images.astype('float32') / 255 train_labels = to_categorical(train_labels) test_labels = to_categorical(test_labels) from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten model = Sequential() model.add( Conv2D(32, kernel_size=(3, 3), input_shape=(28, 28, 1), activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dense(10, activation='softmax')) from tensorflow.keras.optimizers import Adam optimizer = Adam(lr=0.001) model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics='accuracy') model.summary() model.fit(train_images, train_labels, epochs=5, batch_size=200) test_loss, test_acc = model.evaluate(test_images, test_labels) print('test_acc:', test_acc)
class Predictioner: numpy.random.seed(1234) set_seed(1234) def __init__(self): self.model = Sequential() self.setup_default_model() self.compile_model() def save_model(self, path): self.model.save(path) def load_model(self, path): self.model = keras.models.load_model(path) def update_input(self, train_x, train_y): self.push_train_sets(train_x, train_y) self.y_scaler = MinMaxScaler() self.x_scaler = MinMaxScaler() self.reshape_train_sets() self.adjust_scalers() def push_train_sets(self, train_x, train_y): self.train_x = train_x self.train_y = train_y def reshape_train_sets(self): self.train_x = reshaper(self.train_x, self.train_x.shape[1]) self.train_y = reshaper(self.train_y, 1) def adjust_scalers(self): self.train_x = self.x_scaler.fit_transform(self.train_x) self.train_y = self.y_scaler.fit_transform(self.train_y) def setup_default_model(self): self.model.add(Dense(30)) self.model.add(Dense(90, activation='relu')) self.model.add(Dense(45, activation='relu')) self.model.add(Dense(20, activation='relu')) self.model.add(Dense(10, activation='relu')) self.model.add(Dense(1)) def compile_model(self): self.model.compile( optimizer=keras.optimizers.Adam(), loss=keras.losses.mean_squared_error, metrics=[ keras.metrics.mean_squared_error, keras.metrics.mean_squared_logarithmic_error, keras.metrics.mean_absolute_percentage_error, keras.metrics.mean_absolute_error, ] ) def fit_model(self, verbose=0): self.model.fit( self.train_x, # [:int(len(self.train_x) * 0.66)], self.train_y, # [:int(len(self.train_y) * 0.66)], epochs=300, batch_size=10, verbose=verbose, # validation_data=(self.train_y[int(len(self.train_x) * 0.66):], # self.train_x[int(len(self.train_x) * 0.66):]) ) def evaluate(self, x_test, y_test): return self.model.evaluate(x_test, y_test, batch_size=12, verbose=1) def predict(self, prediction_interval_x): prediction_interval_x = self.x_scaler.transform(prediction_interval_x) predicted_y = self.model.predict(prediction_interval_x) self.x_plot = self.x_scaler.inverse_transform(self.train_x) self.y_plot = self.y_scaler.inverse_transform(self.train_y) self.x_pred_plot = self.x_scaler.inverse_transform(prediction_interval_x) self.y_pred_plot = self.y_scaler.inverse_transform(predicted_y) return self.y_pred_plot def visualize(self): pyplot.scatter(self.x_pred_plot, self.y_pred_plot, label='Predicted') pyplot.scatter(self.x_plot, self.y_plot, label='Actual') pyplot.title('Input (x) versus Output (y)') pyplot.xlabel('Input Variable (x)') pyplot.ylabel('Output Variable (y)') pyplot.legend() pyplot.show()
padding='same', activation='relu')) model.add(layers.MaxPooling1D(pool_size=2)) model.add(layers.LSTM(100, recurrent_activation='sigmoid')) model.add(layers.Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() filename = os.path.join(current_dir, 'data', 'complain_model.h5') is_training = False if is_training: model.fit(X_train, Y_train, validation_data=( X_test, Y_test), epochs=20, batch_size=64) # Evaluate the model scores = model.evaluate(X_test, Y_test, verbose=0) print("Evaluation Accuracy: %.2f%%" % (scores[1]*100)) model.save(filename, save_format='tf') else: model.load_weights(filename) t1 = time.time() lstm_upstream = tf.keras.Model( inputs=model.input, outputs=model.get_layer('max_pooling1d').output) lstm_input = lstm_upstream.predict(X_test, batch_size=8) # print(lstm_input.shape) num_records = lstm_input.shape[0] quantized_lstm_input = quanti_convert_float_to_int16( lstm_input.reshape(num_records * 25*32), in_pos).reshape((num_records, 25*32))
iris_train_input, iris_test_input, iris_train_output, iris_test_output = train_test_split(input_data, output_data, test_size=0.20) # Aufbau des Modells mit Keras iris_model = Sequential() iris_model.add(Dense(5,input_shape=(4,),activation="relu")) iris_model.add(Dense(24,activation="relu")) iris_model.add(Dense(3,activation="softmax")) sgd = SGD(lr=0.001) iris_model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy",metrics.mae]) iris_model.fit(x=iris_train_input, y=iris_train_output, batch_size=10, epochs=500, verbose=1) # Evaluation auf Test Daten evaluation_results = iris_model.evaluate(iris_test_input, iris_test_output) print("Loss: {}".format(evaluation_results[0])) print("Accuracy: {}".format(evaluation_results[1])) print("Mean Absolute Error: {}".format(evaluation_results[2])) # Test test = np.array([[5.1,3.5,1.4,0.2], [5.9,3.,5.1,1.8], [4.9,3.,1.4,0.2], [5.8,2.7,4.1,1.]]) predictions = iris_model.predict(test) index_max_predictions = np.argmax(predictions,axis=1) for i in index_max_predictions: print("Iris mit den Eigenschaften {} gehört zur Klasse: {}".format( test[i], iris_label_array[i]))
from tensorflow.python.keras.layers import InputLayer from tensorflow.python.keras.layers import Dense from tensorflow.python.keras.layers import Dropout from tensorflow.python.keras.constraints import maxnorm from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2, random_state= 1234) model = Sequential() model.add(Dense(1024, input_dim=18098, activation='relu', kernel_constraint=maxnorm(3))) model.add(Dropout(rate=0.2)) model.add(Dense(512, activation='relu', kernel_constraint=maxnorm(5))) model.add(Dropout(rate=0.2)) model.add(Dense(256, activation='relu', kernel_constraint=maxnorm(5))) model.add(Dropout(rate=0.2)) model.add(Dense(128, activation='relu', kernel_constraint=maxnorm(5))) model.add(Dropout(rate=0.2)) model.add(Dense(64, activation='relu', kernel_constraint=maxnorm(5))) model.add(Dropout(rate=0.2)) model.add(Dense(32, activation='relu', kernel_constraint=maxnorm(5))) model.add(Dropout(rate=0.2)) model.add(Dense(16, activation='relu', kernel_constraint=maxnorm(5))) model.add(Dropout(rate=0.2)) model.add(Dense(1, activation='sigmoid')) model.compile(loss = "binary_crossentropy", optimizer = 'adam', metrics=['accuracy']) train_acc = model.evaluate(X_train, y_train, verbose=0) test_acc = model.evaluate(X_test, y_test, verbose=0) history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=40, batch_size=50)
model.add(Dense(1, activation='relu')) # compile the keras model #just a test to change the learning rate #we tried with SDG, it didn't work model.compile(loss='mean_squared_error', optimizer='adam', metrics=[ 'mse', 'mean_absolute_error', 'mean_absolute_percentage_error', 'cosine_proximity' ]) # fit the keras model on the dataset #use first one for final model for production #model.fit(X_train, y_train, epochs=50, batch_size=12) model.fit(X_train, y_train, epochs=2000, batch_size=12) #score score = model.evaluate(X_test, y_test, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], score[1] * 100)) #make a prediction prediction1 = model.predict(XAle) print(prediction1) predplusnormalized = np.column_stack([XAle, prediction1[:, -1]]) inverted = scaler.inverse_transform(predplusnormalized) result = inverted[:, 17] print(result) # RICKY TODO Save the model import tensorflow as tf model.save('C:\\Users\\Arturo A\\AguayDrenaje\\modeloDiario') #RICKY Send export scalar to be used by flask later
model.add(Dense(1, activation='sigmoid') ) # sigmoid instead of relu for final probability between 0 and 1 # compile the model, adam gradient descent (optimized) model.compile(loss="binary_crossentropy", optimizer="adam", metrics=['accuracy']) # call the function to fit to the data (training the network) history = model.fit(x_train, y_train, epochs=1000, batch_size=20, validation_data=(x_test, y_test)) scores = model.evaluate(X, Y) print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1] * 100)) plt.figure() plt.isinteractive() plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='best') plt.figure() plt.plot(history.history['acc']) plt.plot(history.history['val_acc'])
# Lapisan tersembunyi pertama 10 node dengan aktivasi rule # Lapisan tersembunyi dua 6 node dengan aktivasi rule # lapisan keluaran 1 node dengan aktivasi sigmoid # Rule berfungsi mengubah nilai negatif menjadi 0 # Sigmoid Berfungsi mengubah nilai aktivasi menjadi nilai antara 0 dan 1 model = Sequential() model.add(Dense(10, input_dim=8, activation='relu')) model.add(Dense(6, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compile Model Keras # membuat argumen kerugian dengan cross entropy # Mengoptimalkan algoritma gradient descent dengan menggunakan adam # Membuat keakrutan klasifikasi dengan argumen metric model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Eksekusi Model # # Epoch : Satu melewati semua baris dalam set data pelatihan. # Batch : Satu atau beberapa sampel yang dipertimbangkan oleh model dalam suatu periode sebelum bobot diperbarui. # Satu epoch terdiri dari satu atau beberapa batch model.fit(X, y, epochs=150, batch_size=20) # Evaluasi Model # Fungsi eval untuk mengembalikan daftar dengan dua nilai. # Yang pertama adalah hilangnya model pada dataset dan yang kedua adalah keakuratan model pada dataset. _, accuracy = model.evaluate(X, y) print('Accuracy: %.2f' % (accuracy * 100))
input_dim=200, bias_initializer='one', kernel_regularizer=l2(0.0003), activation='tanh'), Dropout(0.4), Dense(units=10, input_dim=100, bias_initializer='one', kernel_regularizer=l2(0.0003), activation='softmax'), ]) sgd = SGD(lr=0.1) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) #train model.fit(x_train_data, y_train_data, batch_size=128, epochs=20) model.save("01_tf_keras/sequential_model/weights/mnist_dnn.h5", include_optimizer=False, save_format='h5') #evaluate of test data loss, accuracy = model.evaluate(x_test_data, y_test_data) print("test loss: ", loss) print("test acc: ", accuracy) #evaluate of train data loss, accuracy = model.evaluate(x_train_data, y_train_data) print("train loss:", loss) print("train loss:", accuracy)
class NeuralNetwork(object): def __init__(self): self.model = None def createModel(self): """Create and compile the keras model. See layers-18pct.cfg and layers-params-18pct.cfg for the network model, and https://code.google.com/archive/p/cuda-convnet/wikis/LayerParams.wiki for documentation on the layer format. """ self.model = Sequential() self.model.add( keras.layers.Conv2D(filters=32, kernel_size=5, strides=(1, 1), padding='same', input_shape=(32, 32, 3), data_format="channels_last", dilation_rate=(1, 1), activation=tf.nn.relu)) self.model.add( keras.layers.MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) self.model.add( keras.layers.BatchNormalization( axis=1, momentum=0.99, epsilon=0.001, )) self.model.add( keras.layers.Conv2D(filters=32, kernel_size=5, strides=(1, 1), padding='same', dilation_rate=(1, 1), activation=tf.nn.relu)) self.model.add( keras.layers.AveragePooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) self.model.add( keras.layers.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001)) self.model.add( keras.layers.Conv2D(filters=32, kernel_size=5, strides=(1, 1), padding='same', dilation_rate=(1, 1), activation=tf.nn.relu)) self.model.add( keras.layers.AveragePooling2D(pool_size=(3, 3), strides=(2, 2), padding='same')) self.model.add(keras.layers.Flatten()) self.model.add(keras.layers.Dense(10, activation=tf.nn.softmax)) self.model.compile(optimizer=keras.optimizers.Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy']) def train(self, train_data, train_labels, epochs): """Train the keras model Arguments: train_data {np.array} -- The training image data train_labels {np.array} -- The training labels epochs {int} -- The number of epochs to train for """ self.model.fit(train_data, train_labels, epochs=epochs, batch_size=128) pass def evaluate(self, eval_data, eval_labels): """Calculate the accuracy of the model Arguments: eval_data {np.array} -- The evaluation images eval_labels {np.array} -- The labels for the evaluation images """ return self.model.evaluate(eval_data, eval_labels)[1] pass def test(self, test_data): """Make predictions for a list of images and display the results Arguments: test_data {np.array} -- The test images """ return self.model.predict(test_data) pass ## Exercise 7 Save and load a model using the keras.models API def saveModel(self, saveFile="model.h5"): """Save a model using the keras.models API Keyword Arguments: saveFile {str} -- The name of the model file (default: {"model.h5"}) """ keras.models.save_model(self.model, saveFile) pass def loadModel(self, saveFile="model.h5"): """Load a model using the keras.models API Keyword Arguments: saveFile {str} -- The name of the model file (default: {"model.h5"}) """ self.model = keras.models.load_model(saveFile) pass
#create Model model = Sequential() model.add(Dense(22, input_dim=56, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) #Compile Model model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) #fit the model model.fit(numerical_features, numerical_outcomes, epochs=150, batch_size=10) #evaluate the model scores = model.evaluate(numerical_features, numerical_outcomes) print('\n%s: %.2f%%' % (model.metrics_names[1], scores[1] * 100)) #Ask Questions age = int(input("What's the students age::")) Medu = int(input("What's Medu::")) Fedu = int(input("What's Fedu::")) traveltime = int(input("What's traveltime::")) studytime = int(input("What's studytime::")) failures = int(input("How many failures::")) famrel = int(input("What's famrel::")) freetime = int(input("What's freetime::")) goout = int(input("What's goout::")) Dalc = int(input("What's Dalc::")) Walc = int(input("What's Walc::")) health = int(input("What's health::"))
my_model.add(Dense(2, kernel_initializer='glorot_normal',kernel_regularizer=tf.keras.regularizers.l2(l=0.01))) #Training model using multi-stage optimiser: #Stage 1 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.005,beta1=0.85,beta2=0.95), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=100, verbose=VERBOSE, shuffle=True) #Stage 2 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.001,beta1=0.9,beta2=0.99), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=150, verbose=VERBOSE, shuffle=True)# new #Stage 3 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.0005,beta1=0.9,beta2=0.99), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=200, verbose=VERBOSE, shuffle=True)# new #Stage 4 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.0001,beta1=0.9,beta2=0.99), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=250, verbose=VERBOSE, shuffle=True)# new #Evaluate model on training data print("evaluation on training data", my_model.evaluate(x=X_train, y=Y_train, batch_size=my_batch_size)) # Read testing data and convert target to one-hot for use with categorical cross entropy per documentation ds = np.loadtxt(open(test_dataset_location),delimiter=',') X_test = ds[:,0:30].astype(np.float64) Y_test = ds[:,30].astype(int) Y_test = tf.keras.utils.to_categorical(Y_test) #Evaluate model on test data print("evaluation on test data", my_model.evaluate(x=X_test, y=Y_test, batch_size=my_batch_size))
def train_task( endpoint: str, bucket: str, data: str, epochs: int, batch_size: int ) -> NamedTuple('Model', [('filename', str), ('examples', str)]): """Train CNN model on MNIST dataset.""" from pathlib import Path from tempfile import TemporaryFile from tensorflow.python import keras from tensorflow.python.keras import backend as K from tensorflow.python.keras import Sequential from tensorflow.python.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense from tensorflow.python.keras.utils import to_categorical import numpy as np from minio import Minio mclient = Minio( endpoint, access_key=Path('/secrets/accesskey').read_text(), secret_key=Path('/secrets/secretkey').read_text(), secure=False, ) with TemporaryFile('w+b') as outp: with mclient.get_object(bucket, data) as inp: outp.write(inp.read()) outp.seek(0) mnistdata = np.load(outp) train_x = mnistdata['train_x'] train_y = to_categorical(mnistdata['train_y']) test_x = mnistdata['test_x'] test_y = to_categorical(mnistdata['test_y']) # For example purposes, we don't need the entire training set, just enough # to get reasonable accuracy train_x = train_x[:10000, :, :] train_y = train_y[:10000] num_classes = 10 img_w = 28 img_h = 28 if K.image_data_format() == 'channels_first': train_x.shape = (-1, 1, img_h, img_w) test_x.shape = (-1, 1, img_h, img_w) input_shape = (1, img_h, img_w) else: train_x.shape = (-1, img_h, img_w, 1) test_x.shape = (-1, img_h, img_w, 1) input_shape = (img_h, img_w, 1) train_x = train_x.astype('float32') test_x = test_x.astype('float32') train_x /= 255 test_x /= 255 model = Sequential( [ Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape), Conv2D(64, (3, 3), activation='relu'), MaxPooling2D(pool_size=(2, 2)), Dropout(0.25), Flatten(), Dense(128, activation='relu'), Dropout(0.5), Dense(num_classes, activation='softmax'), ] ) model.compile( loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy'], ) model.fit( train_x, train_y, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(test_x, test_y), ) score = model.evaluate(test_x, test_y) print('Test loss & accuracy: %s, %s' % score) model_name = 'model.h5' model.save(f'/output/{model_name}') mclient.fput_object(bucket, model_name, f'/output/{model_name}') examples = 'examples.npz' np.savez_compressed( f'/output/{examples}', **{ 'X': test_x[:10, :, :, :], 'y': test_y[:10], }, ) mclient.fput_object(bucket, examples, f'/output/{examples}') return model_name, examples
def train_task(data: InputBinaryFile(str), epochs: int, batch_size: int, model_path: OutputBinaryFile(str)): """Train CNN model on MNIST dataset.""" from tensorflow.python import keras from tensorflow.python.keras import Sequential, backend as K from tensorflow.python.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense import numpy as np mnistdata = np.load(data) train_x = mnistdata['train_x'] train_y = mnistdata['train_y'] test_x = mnistdata['test_x'] test_y = mnistdata['test_y'] num_classes = 10 img_w = 28 img_h = 28 if K.image_data_format() == 'channels_first': train_x.shape = (-1, 1, img_h, img_w) test_x.shape = (-1, 1, img_h, img_w) input_shape = (1, img_h, img_w) else: train_x.shape = (-1, img_h, img_w, 1) test_x.shape = (-1, img_h, img_w, 1) input_shape = (img_h, img_w, 1) model = Sequential([ Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape), Conv2D(64, (3, 3), activation='relu'), MaxPooling2D(pool_size=(2, 2)), Dropout(0.25), Flatten(), Dense(128, activation='relu'), Dropout(0.5), Dense(num_classes, activation='softmax'), ]) model.compile( loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy'], ) model.fit( train_x, train_y, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(test_x, test_y), ) score = model.evaluate(test_x, test_y) print('Test loss & accuracy: %s' % (score, )) model.save(model_path)
model.add(Dense(10, input_dim=60, activation='relu')) model.add(Dense(2, input_dim=10, activation='softmax')) #model.add(Dense(1, input_dim=10, activation='sigmoid')) # 3. model fitting config #model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy']) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #softmax 일때 # 4. model fitting history = model.fit(train_x, train_t, epochs=100, batch_size=5, verbose=1) # 5. result loss = history.history['loss'] result = model.evaluate(train_x, train_t, verbose=0) print(f'\n(Train Loss, Train Accuracy) = ({result[0], result[1]}') # 6. save model model_directory = os.path.join(os.getcwd(), 'model') if not os.path.exists(model_directory): os.mkdir(model_directory) model.save(os.path.join(model_directory, 'model.h5')) # 7. overfitting del model model = load_model(os.path.join(model_directory, 'model.h5')) result = model.evaluate(test_x, test_t, verbose=0) print(f'\n(Test Loss, Test Accuracy) = ({result[0], result[1]}')
# preprocess data X_normalized = np.array(X_train / 255.0 - 0.5) from sklearn.preprocessing import LabelBinarizer label_binarizer = LabelBinarizer() y_one_hot = label_binarizer.fit_transform(y_train) # compile and fit the model model.compile('adam', 'categorical_crossentropy', ['accuracy']) history = model.fit(X_normalized, y_one_hot, epochs=15, validation_split=0.2) # evaluate model against the test data with open('small_test_traffic.p', 'rb') as f: data_test = pickle.load(f) X_test = data_test['features'] y_test = data_test['labels'] # preprocess data X_normalized_test = np.array(X_test / 255.0 - 0.5) y_one_hot_test = label_binarizer.fit_transform(y_test) print("Testing") metrics = model.evaluate(X_normalized_test, y_one_hot_test) for metric_i in range(len(model.metrics_names)): metric_name = model.metrics_names[metric_i] metric_value = metrics[metric_i] print('{}: {}'.format(metric_name, metric_value))
model.add(Dense(2, activation='softmax')) # 3. model fitting config model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # 4. model check point config model_directory = os.path.join(os.getcwd(), 'model') if not os.path.exists(model_directory): os.mkdir(model_directory) checkpoint = ModelCheckpoint( filepath=os.path.join(model_directory, '{epoch:03d}-{val_loss: 4f}.h5'), minitor='val_loss', # val_loss(시험셋 오차), loss(학습셋 오차), val_accuracy(시험셋 정확도), accuracy(학습셋 정확도) verbose=1, save_best_only=True ) # 5. model fitting model.fit(x, t, validation_split=0.2, epochs=200, batch_size=100, verbose=1, callbacks=[checkpoint]) # 6. result result = model.evaluate(x, t, verbose=0) print(f'\n(Loss, Accuracy)=({result[0]}, {result[1]})') # 7. predict data = np.array([[8.5, 0.21, 0.26, 9.25, 0.034, 73, 142, 0.9945, 3.05, 0.37, 11.4, 6]]) predict = model.predict(data) index = np.argmax(predict) wines = ['Red Wine', 'White Wine'] print(wines[index])
epochs=500, verbose=VERBOSE, shuffle=True) #Stage 2: my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.9, beta2=0.99), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=300, verbose=VERBOSE, shuffle=True) #Evaluate model on Training Data: print("evaluation on training data", my_model.evaluate(x=X_train, y=Y_train, batch_size=my_batch_size)) #Read the testing dataset and convert target to one-hot as needed for categorical cross entropy per documentation ds = np.loadtxt(open(test_dataset_location), delimiter=',') X_test = ds[:, 0:30].astype(np.float64) Y_test = ds[:, 30].astype(int) Y_test = tf.keras.utils.to_categorical(Y_test) #Evaluate model on testing data: print("evaluation on test data", my_model.evaluate(x=X_test, y=Y_test, batch_size=my_batch_size))