def main(): network = Sequential([ layers.Dense(256, activation=tf.nn.relu), layers.Dense(128, activation=tf.nn.relu), layers.Dense(64, activation=tf.nn.relu), layers.Dense(32, activation=tf.nn.relu), layers.Dense(10, activation=tf.nn.relu) ]) network.build(input_shape=[None, 28*28]) network.summary() network.compile( optimizer=optimizers.Adam(lr=0.01), # 指定优化器 loss=tf.losses.CategoricalCrossentropy(from_logits=True), # 指定loss函数 metrics=['accuracy'] # 指定测试标准 ) network.fit( db, # 要训练的数据集 epochs=10, # 训练的周期 validation_data=db_test, # 用于做测试的数据集,一般写作ds_val validation_freq=2 ) network.evaluate(db_test) # 训练完后对模型的评估,传入一个数据集 pred = network(x)
def apk_cnn(): x = [] y = [] data = np.array(concat_to_tab()) batch_size = 2 for element in data: if (len(element[0]) == 600): #print(element[0]) #print(len(element[0])) y.append(np.asarray(element[1]).astype(np.float32)) x.append(np.asarray(element[0]).astype(np.float32)) x = np.array(x) y = np.array(y) print(x) print(len(x)) print(len(y)) X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, train_size=0.8) print(len(X_train)) model = Sequential() model.add(layers.Conv1D(filters=10, kernel_size=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=100, verbose=True, validation_data=(X_test, y_test), batch_size=batch_size) model.summary() print(history) loss, accuracy = model.evaluate(X_train, y_train, verbose=False) #print("************************Results for class :"+str(curr_class)+"*********************") print("Training Accuracy: {:.4f}".format(accuracy)) print("ok") loss, accuracy = model.evaluate(X_test, y_test, verbose=False) print("Testing Accuracy: {:.4f}".format(accuracy)) return (x, y)
def use_Sequential_model(): from tensorflow.keras import Sequential, callbacks, regularizers BATCH_SIZE = 8 simple_model = Sequential([ Input(shape=(33, )), Dense(128, activation='relu'), Dropout(0.5), Dense(64, activation='sigmoid'), Dense(32, activation='relu'), Dense(1, activation='sigmoid') ]) stop = callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True) simple_model.compile(optimizer=optimizer, loss=loss_fn, metrics=['accuracy']) hist_simple = simple_model.fit(train_features, train_labels, epochs=500, callbacks=stop, validation_split=0.15, batch_size=BATCH_SIZE) predictions = simple_model.predict(test_features) for i in range(10): print(f"Prediction: {label_names[int(np.round(predictions[i][0]))]}") test_loss, test_acc = simple_model.evaluate(test_features, test_labels) simple_model.save('simple_model')
def function( snn_results, labels, output_path, input_layer_N_num=600, hidden_layer_N_num=19, output_layer_N_num=2 # Generic output configuration will be implemented ): model = Sequential() model.add( Dense(units=input_layer_N_num, input_dim=input_layer_N_num, activation="relu")) model.add(Dense(units=hidden_layer_N_num, activation="relu")) model.add(Dense(units=output_layer_N_num, activation="relu")) model.compile(loss='sparse_categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) snn_results_x = list(map(lambda x: x["fire_rate"].ravel(), snn_results)) snn_results_x = np.vstack(snn_results_x) X_train, X_test, y_train, y_test = train_test_split(snn_results_x, labels, test_size=0.20, random_state=42) model.fit(X_train, y_train, batch_size=1000, epochs=1000, verbose=0) model.save(os.path.join(output_path, "ann-model.h5")) loss, acc = model.evaluate(X_test, y_test, verbose=0) print("loss: %.2f%%; acc: %.2f%%" % (loss * 100, acc * 100))
def fashion_model(): model = Sequential([ Conv2D(input_shape=x_train.shape[1:], filters=50, kernel_size=(3, 3), padding='same', kernel_initializer='he_normal'), MaxPooling2D(pool_size=(2, 2)), Dropout(0.25), Flatten(), Dense(128, activation=tf.nn.relu), Dense(10, activation=tf.nn.softmax) ]) model.summary() model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001), metrics=['accuracy']) early_stopping = EarlyStopping(monitor='val_loss', patience=10) history = model.fit(x_train, y_train, batch_size=64, epochs=25, validation_data=(x_test, y_test), shuffle=True, callbacks=[early_stopping]) loss, acc = model.evaluate(x_test, y_test) predictions = model.predict(x_test) print("\nLoss: {}, Acc: {}".format(loss, acc))
def evaluate(model: keras.Sequential, dataset: PreppedDataset, config: Config): model_result = model.evaluate( dataset.test_set, dataset.test_labels, verbose=0, return_dict=True ) # we could handle multiple metrics here but we are only measuring the # model loss (mean abs error) for now. metrics = { config.get('model.hyperparameters.loss'): model_result['loss'] } run = Run( timestamp=datetime.now(), dataset_name=config.get('dataset.name'), preprocessing_cfg=config.get( 'dataset.preprocessing', as_primitive=True), model_type=config.get('model.type'), model_hyperparameters=dict(config.get( 'model.hyperparameters', as_primitive=True)), metric_scores=metrics ) # store run and compare it to previous best runs metric = config.get('model.hyperparameters.loss') data_store = DataStore(config) best_run = data_store.get_best_run(run.dataset_name, metric) data_store.save_run(run) runs_info = [] if best_run: runs_info.append({'label': 'Previous best', 'run': best_run}) runs_info.append({'label': 'New run', 'run': run}) print_run_overview(runs_info, metric)
def main(): train_ds, test_ds, vocab_size = load_dataset() model = Sequential([ Embedding(vocab_size, 64), Bidirectional(LSTM(64, return_sequences=True)), # Bidirectionalなので出力ユニット数は64 Bidirectional(LSTM(32)), Dense(64, activation='relu'), Dropout(0.5), Dense(1, activation='sigmoid') ]) model.compile(optimizer=Adam(1e-4), loss='binary_crossentropy', metrics=['accuracy']) model.summary() with experiment.train(): model.fit(train_ds, epochs=NUM_EPOCHS, validation_data=test_ds) with experiment.test(): test_loss, test_acc = model.evaluate(test_ds) print('Test Loss: {}'.format(test_loss)) print('Test Accuracy: {}'.format(test_acc))
def main(): (x, y), (x_val, y_val) = keras.datasets.mnist.load_data() print(x.shape, y.shape) print(x_val.shape, y_val.shape) batchsz = 128 db = tf.data.Dataset.from_tensor_slices((x, y)) db = db.map(preprocess).shuffle(60000).batch(batchsz) ds_val = tf.data.Dataset.from_tensor_slices((x_val, y_val)) ds_val = ds_val.map(preprocess).batch(batchsz) network = Sequential([ layers.Dense(256, activation='relu'), layers.Dense(128, activation='relu'), layers.Dense(64, activation='relu'), layers.Dense(32, activation='relu'), layers.Dense(10), ]) network.build(input_shape=(4, 28 * 28)) # 模型装配,指定优化器、损失函数、度量标准 network.compile(optimizer=optimizers.Adam(lr=0.01), loss=losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy']) network.summary() history = network.fit(db, epochs=5, validation_data=ds_val, validation_freq=2) print(history.history) x, y = next(iter(ds_val)) # predict用一组数据进行预测 out = network.predict(x) print(out) # evaluate返回loss和度量结果 result = network.evaluate(ds_val) print(result)
def compute_results(train_dataset: PrefetchDataset, test_dataset: PrefetchDataset, model: Sequential) -> History: """ Configures and trains the model, then evaluates its accuracy against the test dataset. The trained model is saved to the outputs folder. :param train_dataset: A PrefetchDataset that the model will be trained on. :param test_dataset: A PrefetchDataset that the model's accuracy will be evaluated against. :param model: The Sequential object to be trained. :return: A History object containing information about the model's metrics during the training process. """ model.compile(loss=BinaryCrossentropy(from_logits=True), optimizer=Adam(), metrics=["accuracy"]) # Here we introduce an early stopping callback function that will cease training once the validation loss # stops decreasing. This is to minimize over-fitting (i.e. reduce the difference between training loss # and validation loss). # Idea retrieved from https://machinelearningmastery.com/early-stopping-to-avoid-overtraining-neural-network-models/ es_callback = EarlyStopping(monitor="val_loss", patience=3) # Train the model history = model.fit(train_dataset, validation_data=test_dataset, batch_size=BATCH_SIZE, epochs=EPOCHS, callbacks=[es_callback]) # Get the loss values and metrics once evaluating the model against the test dataset test_loss, test_accuracy = model.evaluate(test_dataset) print(f"Test Loss: {test_loss}") print(f"Test Accuracy: {test_accuracy}") model.save(ROOT / "outputs/my_model") return history
def create_mlp_for_binary_classification(): from pandas import read_csv from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense # load the dataset ionosphere_dataset_path = '.\KerasToTensorFlow\ionosphere.csv' ionosphere_df = read_csv(ionosphere_dataset_path, header=None) # split dataset into input and output columns X, y = ionosphere_df.values[:, :-1], ionosphere_df.values[:, -1] # ensure all data are floating point values X = X.astype('float32') # encode strings to integer y = LabelEncoder().fit_transform(y) # split dataset into train and test datasets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33) # determine the number of input features num_input_features = X_train.shape[1] # define model model = Sequential() model.add( Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(num_input_features, ))) model.add(Dense(8, activation='relu', kernel_initializer='he_normal')) model.add(Dense(1, activation='sigmoid')) # compile the model model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # fit the model model.fit(X_train, y_train, epochs=150, batch_size=32, verbose=0) # evaluate the model loss, model_accuracy = model.evaluate(X_test, y_test, verbose=0) print('Test Accuracy: %.3f' % model_accuracy) # make a prediction row = [ 1, 0, 0.99539, -0.05889, 0.85243, 0.02306, 0.83398, -0.37708, 1, 0.03760, 0.85243, -0.17755, 0.59755, -0.44945, 0.60536, -0.38223, 0.84356, -0.38542, 0.58212, -0.32192, 0.56971, -0.29674, 0.36946, -0.47357, 0.56811, -0.51171, 0.41078, -0.46168, 0.21266, -0.34090, 0.42267, -0.54487, 0.18641, -0.45300 ] yhat = model.predict([row]) print('Predicted: %.3f' % yhat) return model_accuracy
def create_CNN_model(X_train, y_train, X_test, y_test, X_val, y_val): # Reshape data X_train_flattened = X_train.reshape(len(X_train), 28 * 28) X_test_flattened = X_test.reshape(len(X_test), 28 * 28) X_val_flattened = X_val.reshape(len(X_val), 28 * 28) cnn = Sequential() cnn.add(Dense(units=128, activation='relu')) cnn.add(Dense(units=64, activation='relu')) cnn.add(Dense(units=10, activation='softmax')) callback = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True) cnn.compile(optimizer=Adam(), loss=SparseCategoricalCrossentropy(), metrics=['accuracy']) history = cnn.fit(x=X_train_flattened, y=y_train, validation_data=(X_val_flattened, y_val), epochs=600, batch_size=32, verbose=False, callbacks=[callback]) test_loss, test_acc = cnn.evaluate(x=X_test_flattened, y=y_test) print(f"Test loss: {test_loss}") print(f"Test accuracy: {test_acc}") predictions = cnn.predict(X_test_flattened) cnn.save('trained_model.h5') return predictions
def train_test_model(hparams, logdir): model = Sequential( [Dense(units=hparams[HP_HIDDEN], activation='relu'), Dense(units=1)]) model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam( hparams[HP_LEARNING_RATE]), metrics=['mean_squared_error']) model.fit( X_scaled_train, y_train, validation_data=(X_scaled_test, y_test), epochs=hparams[HP_EPOCHS], verbose=False, callbacks=[ tf.keras.callbacks.TensorBoard(logdir), # log metrics hp.KerasCallback(logdir, hparams), # log hparams tf.keras.callbacks.EarlyStopping( monitor='val_loss', min_delta=0, patience=200, verbose=0, mode='auto', ) ], ) _, mse = model.evaluate(X_scaled_test, y_test) pred = model.predict(X_scaled_test) r2 = r2_score(y_test, pred) return mse, r2
def evaluate_model(trainX, trainy, testX, testy): verbose, epochs, batch_size = 0, 15, 64 n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[ 2], trainy.shape[1] model = Sequential() model.add( LSTM(100, input_shape=(n_timesteps, n_features), return_sequences=False)) model.add(Dropout(0.5)) model.add(Dense(100, activation='relu')) model.add(Dense(n_outputs, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # fit network model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose) # evaluate model _, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0) return accuracy
def create_mlp_for_multiclass_classification(): from numpy import argmax from pandas import read_csv from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense # load the dataset iris_dataset_path = '.\KerasToTensorFlow\iris.csv' iris_df = read_csv(iris_dataset_path, header=None) # split into input and output columns X, y = iris_df.values[:, :-1], iris_df.values[:, -1] # ensure all data are floating point values X = X.astype('float32') # encode strings to integer y = LabelEncoder().fit_transform(y) # split into train and test datasets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33) print(X_train.shape, X_test.shape, y_train.shape, y_test.shape) # determine the number of input features num_input_features = X_train.shape[1] # define model model = Sequential() model.add( Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(num_input_features, ))) model.add(Dense(8, activation='relu', kernel_initializer='he_normal')) model.add(Dense(3, activation='softmax')) # compile the model model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) # fit the model model.fit(X_train, y_train, epochs=150, batch_size=32, verbose=0) # evaluate the model loss, model_accuracy = model.evaluate(X_test, y_test, verbose=0) print('Test Accuracy: %.3f' % model_accuracy) # make a prediction row = [5.1, 3.5, 1.4, 0.2] yhat = model.predict([row]) print('Predicted: %s (class=%d)' % (yhat, argmax(yhat))) return model_accuracy
def main(): # Cannot do stacked ConditionalRNN with Sequential. Have to rely on the functional API. See below. model = Sequential(layers=[ ConditionalRNN( NUM_CELLS, cell='LSTM', return_sequences=True, name='cond_rnn_0'), LSTM(NUM_CELLS), Dense(units=NUM_CLASSES, activation='softmax') ]) # Stacked ConditionalRNN with the functional API. i = Input(shape=[TIME_STEPS, INPUT_DIM], name='input_0') c = Input(shape=[NUM_CLASSES], name='input_1') # add the condition tensor here. x = ConditionalRNN(NUM_CELLS, cell='LSTM', return_sequences=True, name='cond_rnn_0')([i, c]) # and here too. x = ConditionalRNN(NUM_CELLS, cell='LSTM', return_sequences=False, name='cond_rnn_1')([x, c]) x = Dense(units=NUM_CLASSES, activation='softmax')(x) model2 = Model(inputs=[i, c], outputs=[x]) # Define (dummy) data. train_inputs = np.random.uniform(size=(NUM_SAMPLES, TIME_STEPS, INPUT_DIM)) test_inputs = np.random.uniform(size=(NUM_SAMPLES, TIME_STEPS, INPUT_DIM)) test_targets = train_targets = create_conditions() model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model2.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(x=[train_inputs, train_targets], y=train_targets, validation_data=([test_inputs, test_targets], test_targets), epochs=3) model2.fit(x=[train_inputs, train_targets], y=train_targets, validation_data=([test_inputs, test_targets], test_targets), epochs=3) assert abs( model.evaluate([test_inputs, test_targets], test_targets)[1] - 1) < 1e-5 assert abs( model2.evaluate([test_inputs, test_targets], test_targets)[1] - 1) < 1e-5
def evaluate_model(model: Sequential, testSet: DataSet, verbose=2): mean, std = sf.read_std_from_csv('std') test_std = sf.standardize_dataset(testSet.features, mean, std) results = model.evaluate(x=test_std, y=testSet.labels, batch_size=128, verbose=verbose) accuracy = results[-1] loss = results[0] return accuracy, loss
def train( label: Label = Label.title, name: Model = Model.vit32, num_layers: int = 3, epochs: int = 5, dropout_prob: float = 0.4, batch_size: int = TEST_EXAMPLES, ): log_dir = LOG_PATH.format( model=name.name, label=label.name, num_layers=num_layers, dropout_prob=dropout_prob, ) model_dir = MODEL_PATH.format( model=name.name, label=label.name, num_layers=num_layers, dropout_prob=dropout_prob, ) if path.exists(log_dir): rmtree(log_dir, ignore_errors=True) if path.exists(model_dir): rmtree(model_dir, ignore_errors=True) data = prepare(model=name, label=label) model = Sequential() model.add(layers.Flatten()) for l in range(num_layers): model.add(layers.Dense(SIZE[name])) model.add(layers.Activation(activations.relu)) model.add(layers.Dropout(dropout_prob)) model.add(layers.Dense(SIZE[name])) model.compile( loss=losses.cosine_similarity, metrics=[metrics.CosineSimilarity()], optimizer=optimizers.Adam(), ) training = model.fit( x=data.X_train, y=data.Y_train, batch_size=batch_size, callbacks=[callbacks.TensorBoard( log_dir=log_dir, histogram_freq=1, )], epochs=epochs, validation_data=(data.X_dev, data.Y_dev), ) results = model.evaluate(data.X_test, data.Y_test, batch_size=batch_size) model.save(model_dir)
class FeaturesBasedModel: def __init__(self, model_path=None): self.name = 'features_based_model' self.log_dir = "logs/fit/" + self.name self.encoder = pickle.load(open('save/encoder.pickle', 'rb')) if model_path is not None: self.model = models.load_model(model_path) self.scaler = pickle.load(open('save/f_scaler.pickle', 'rb')) else: self.model = None self.scaler = StandardScaler() def train(self, csv_file): data = pd.read_csv(csv_file, encoding='ISO-8859-1') data.drop(['title'], axis=1, inplace=True) # obtaining target column genre_column = data['genre'] y = self.encoder.transform(genre_column) n_classes = len(self.encoder.classes_) # obtaining feature columns and scaler X = np.array(data.drop(['genre'], axis=1), dtype=float) X = self.scaler.fit_transform(X) with open('save/f_scaler.pickle', 'wb') as pickle_out: pickle.dump(self.scaler, pickle_out) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) self.model = Sequential() self.model.add(layers.Dense(256, activation='relu', input_shape=(X_train.shape[1],))) self.model.add(layers.Dense(128, activation='relu')) self.model.add(layers.Dense(64, activation='relu')) self.model.add(layers.Dense(n_classes, activation='softmax')) self.model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) tb_callback = callbacks.TensorBoard(log_dir=self.log_dir, histogram_freq=1) self.model.fit(X_train, y_train, epochs=20, callbacks=[tb_callback]) print('training done\n') test_loss, test_acc = self.model.evaluate(X_test, y_test) print('test_acc: ', test_acc) print(self.model.summary()) self.model.save('./save/fb_model') def predict(self, features_set): scaled_features = self.scaler.transform(np.array(features_set, dtype=float)) return self.model.predict(scaled_features)
def f_build_ANN(arg_X_train, arg_y_train, arg_X_test, arg_y_test, arg_in_layers, arg_out_layers, arg_compile_parms, arg_fit_parms): # -------------------------------------------------------------------- # Initializing the model # -------------------------------------------------------------------- model = Sequential() # ---------------------------------------------------------------------------------------------- # Neural Netwoek Architecture # ---------------------------------------------------------------------------------------------- for in_layer in arg_in_layers: model.add( Dense(units=in_layer[0], activation=in_layer[1], input_shape=in_layer[2])) model.add(Flatten()) # -------------------------------------------------------------------- # Adding the output layer # -------------------------------------------------------------------- for out_layer in arg_out_layers: model.add(Dense(out_layer[0], activation=out_layer[1])) # ---------------------------------------------------------------------------------------------- # Generating Model Summary # ---------------------------------------------------------------------------------------------- model.summary() # ---------------------------------------------------------------------------------------------- # Neural Netwoek Model Compilation # ---------------------------------------------------------------------------------------------- model.compile(optimizer=arg_compile_parms[0][0], loss=arg_compile_parms[0][1], metrics=arg_compile_parms[0][2]) # -------------------------------------------------------------------- # Fitting the Model # -------------------------------------------------------------------- model_history = model.fit(arg_X_train, arg_y_train, epochs=arg_fit_parms[0][0], batch_size=arg_fit_parms[0][1], validation_data=(arg_X_test, arg_y_test)) # -------------------------------------------------------------------- # Printing the model Accuracy # -------------------------------------------------------------------- model_accuracy = model.evaluate(arg_X_test, arg_y_test, verbose=0)[1] print('Model Accuracy is ', model_accuracy) return model
def predictIncompleteFusion(x_train, y_train, x_test, y_test): classifier = Sequential() classifier.add(Dense(45, activation='sigmoid', kernel_initializer='random_normal', input_dim=13)) classifier.add(Dropout(0.6)) classifier.add(Dense(45, activation='sigmoid', kernel_initializer='random_normal')) classifier.add(Dropout(0.6)) classifier.add(Dense(1, activation='sigmoid', kernel_initializer='random_normal')) optimizer=optimizers.SGD(lr=0.9, momentum=0.4) classifier.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy']) history = classifier.fit(x_train, y_train, validation_data=(x_test, y_test), batch_size=1, epochs=250) plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title("IncomFus' accuracy graph") plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['accuracy', 'validation accuracy'], loc='upper left') plt.show() plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title("IncomFus' loss graph") plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['loss', 'validation loss'], loc='upper left') plt.show() y_pred = classifier.predict(x_test) pd.DataFrame(y_pred).to_csv("C:\\Users\\nurizdau\\Desktop\\predicted_probs_incomfus.csv") y_pred[:] = (y_pred[:] > 0.5) # pd.DataFrame(y_pred).to_csv("C:\\Users\\nurizdau\\Desktop\\predicted_results_incomfus.csv") eval_model = classifier.evaluate(x_test, y_test) resultString = "Accuracy (incomplete fusion) is printed here: " + str(eval_model[1]) new_test_y = y_test.values.flatten() new_pred_y = y_pred.astype(int).flatten() cm = confusion_matrix(new_test_y, new_pred_y) print(cm) print("accuracy of Incomplete Fusion is: ", ((cm[0][0] + cm[1][1]) / np.sum(cm)) * 100) print("sensitivity of Incomplete Fusion is: ", (cm[0][0] / np.sum(cm[0])) * 100) print("specificity of Incomplete Fusion is: ", (cm[1][1] / np.sum(cm[1])) * 100) return resultString
def main(config="../../config.yaml", param="param_conf.yaml"): if isinstance(param, str): param = JobConfig.load_from_file(param) if isinstance(config, str): config = JobConfig.load_from_file(config) data_base_dir = config["data_base_dir"] else: data_base_dir = config.data_base_dir epoch = param["epoch"] lr = param["lr"] batch_size = param.get("batch_size", -1) optimizer_name = param.get("optimizer", "Adam") loss = param.get("loss", "categorical_crossentropy") metrics = param.get("metrics", ["accuracy"]) layers = param["layers"] is_multy = param["is_multy"] data = dataset[param.get("dataset", "vehicle")] model = Sequential() for layer_config in layers: layer = getattr(tensorflow.keras.layers, layer_config["name"]) layer_params = layer_config["params"] model.add(layer(**layer_params)) model.compile( optimizer=getattr(optimizers, optimizer_name)(learning_rate=lr), loss=loss, metrics=metrics, ) data_path = pathlib.Path(data_base_dir) data_with_label = pandas.concat([ pandas.read_csv(data_path.joinpath(data["guest"]), index_col=0), pandas.read_csv(data_path.joinpath(data["host"]), index_col=0), ]).values data = data_with_label[:, 1:] if is_multy: labels = to_categorical(data_with_label[:, 0]) else: labels = data_with_label[:, 0] if batch_size < 0: batch_size = len(data_with_label) model.fit(data, labels, epochs=epoch, batch_size=batch_size) evaluate = model.evaluate(data, labels) metric_summary = {"accuracy": evaluate[1]} data_summary = {} return data_summary, metric_summary
def main(): # Загружаем данные (x_training, y_training), (x_test, y_test) = fashion_mnist.load_data() # Список с названиями классов classes = [ 'футболка', 'брюки', 'свитер', 'платье', 'пальто', 'туфли', 'рубашка', 'кроссовки', 'сумка', 'ботинки' ] # Преобразование размерности изображений x_training = x_training.reshape(60000, 784) x_test = x_test.reshape(10000, 784) # Нормализация данных x_training = x_training / 255 x_test = x_test / 255 # Преобразуем метки в категории y_training = utils.to_categorical(y_training, 10) y_test = utils.to_categorical(y_test, 10) # Создаем последовательную модель model = Sequential() # Добавляем уровни сети model.add(Dense(800, input_dim=784, activation="relu")) model.add(Dense(10, activation="softmax")) # Компилируем модель model.compile(loss="categorical_crossentropy", optimizer="SGD", metrics=["accuracy"]) print(model.summary()) # Обучаем сеть history = model.fit(x_training, y_training, batch_size=200, epochs=100, validation_split=0.2, verbose=1) # Оцениваем качество обучения сети на тестовых данных scores = model.evaluate(x_test, y_test, verbose=1) print("Доля верных ответов на тестовых данных, в процентах:", round(scores[1] * 100, 4))
class Classifier: def __init__(self): self.classif = Sequential() self.classif.add(Dense(20, activation='relu', kernel_initializer='random_normal', input_dim=1)) # self.classif.add(Activation(custom_activation, name='SpecialActivation')) self.classif.add(Dense(20, activation='relu', kernel_initializer='random_normal', input_dim=20)) self.classif.add(Dense(20, activation='sigmoid', kernel_initializer='random_normal', input_dim=20)) self.classif.add(Dense(1, activation='sigmoid', kernel_initializer='random_normal', input_dim=20)) self.classif.compile(optimizer='Nadam', loss=MeanSquaredError(), metrics=["mean_squared_error"]) def train(self, x_train, y_train): batch_size = 1000 self.classif.fit(x_train, y_train, batch_size=batch_size, epochs=5000, shuffle=True) return self.classif.evaluate(x_train, y_train) def test(self, x_test): y_pred = self.classif.predict(x_test) return y_pred def save(self): self.classif.save('data/classifier.h5') print("classifier is saved") def load(self, classifier_name: str = 'classifier'): self.classif = load_model(f'data/{classifier_name}.h5') print("classifier is loaded")
def create_mlp_for_regression_predictions(): from numpy import sqrt from pandas import read_csv from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense boston_dataset_path = '.\\KerasToTensorFlow\\boston.csv' boston_df = read_csv(boston_dataset_path, header=None) # split into input and output columns X, y = boston_df.values[:, :-1], boston_df.values[:, -1] # encode strings to integer y = LabelEncoder().fit_transform(y) # split into train and test datasets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33) print(X_train.shape, X_test.shape, y_train.shape, y_test.shape) # determine the number of input features num_input_features = X_train.shape[1] # define model model = Sequential() model.add( Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(num_input_features, ))) model.add(Dense(8, activation='relu', kernel_initializer='he_normal')) model.add(Dense(1)) # compile the model model.compile(optimizer='adam', loss='mse') # fit the model model.fit(X_train, y_train, epochs=150, batch_size=32, verbose=0) # evaluate the model error = model.evaluate(X_test, y_test, verbose=0) print('MSE: %.3f, RMSE: %.3f' % (error, sqrt(error))) return model
def dnn_model(training=(), val=(), test=(), epochs = 100, layers=[1024, 512, 128]): #Performance dictionary performance = {} #Earlystopping callback = callbacks() i=0 for layer in layers: #model model = Sequential() model.add(Flatten(input_shape=(32,32))) model.add(Dense(layer, activation='relu')) model.add(Dense(46, activation='softmax')) #Compliling the model model.compile(optimizer='adam', loss=SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) #Training the model history = model.fit(training[0], training[1], epochs=epochs, callbacks=[callback], validation_data=(val[0], val[1]), verbose=3) #Visualizing the model vs.training_visualize(history, title='DNN {} layer'.format(layer)) #Save model save_model(model, title='{}'.format(layer)) #Evaluate model evaluation = model.evaluate(test[0], test[1]) #Record Performance. performance[i] = [evaluation[0], evaluation[1], layer] i = i+1 performance = pd.DataFrame(data=performance) performance = performance.transpose() performance.columns = ['loss', 'accuracy', 'layer'] performance.to_csv('../src/models/performance_DNN.csv') return performance
def ANN(X_train, y_train, X_test, y_test): model = Sequential() model.add(tf.keras.layers.Dense(40, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(40, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(20, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(20, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(10, activation=tf.nn.relu)) model.add(tf.keras.layers.Dense(1, activation=tf.nn.sigmoid)) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) X_train_fit = np.expand_dims(X_train, axis=2) X_test_fit = np.expand_dims(X_test, axis=2) model.fit(X_train, y_train, epochs=100, validation_data=(X_test, y_test)) accuracy_NN = model.evaluate(X_test, y_test) model.save('Cancer_predictor_nn.h5') return accuracy_NN
def train_conv(request): (x_train, y_train), (x_test, y_test) = load_happy() x_train = list(x_train) y_train = list(y_train) x_test = list(x_test) y_test = list(y_test) model = Sequential() # TODO: Why doesn't this work? model.add(keras.layers.ZeroPadding2D((3, 3))) model.add( Conv2D(32, kernel_size=(7, 7), strides=(1, 1), activation='relu', input_shape=(64, 64, 3))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (11, 11), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(1000, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(loss=keras.losses.binary_crossentropy, optimizer=keras.optimizers.SGD(lr=0.01), metrics=['accuracy']) history = model.fit(x_train, y_train, batch_size=5, epochs=2, verbose=1, shuffle='batch', validation_data=(x_test, y_test)) test_loss, test_acc = model.evaluate(x_test, y_test) return Response({ 'params': history.params, 'history': history.history, 'test': { 'test_loss': test_loss, 'test_acc': test_acc } })
class BinClassifier: def __init__(self): self.classif = Sequential() self.classif.add( Dense(28 * 28, activation='relu', kernel_initializer='random_normal', input_dim=28 * 28, name='features1')) self.classif.add( Dense(10, activation='sigmoid', kernel_initializer='random_normal', input_dim=28 * 28, name='features')) self.classif.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) def train(self, x_train, y_train): batch_size = 1000 self.classif.fit(x_train, y_train, batch_size=batch_size, epochs=100, shuffle=True) return self.classif.evaluate(x_train, y_train) def test(self, x_test, full_return: bool = False): y_pred = self.classif.predict(x_test) return y_pred if full_return else np.maximum(y_pred - 0.5, 0) def save(self): self.classif.save('data/classifier.h5') print("classifier is saved") def load(self, classifier_name: str = 'classifier'): self.classif = load_model(f'data/{classifier_name}.h5') print("classifier is loaded")
def train_LSTM(X_train, Y_train, X_test, Y_test, NAME): model = Sequential() model.add(LSTM(128, input_shape=(X_train.shape[1:]), return_sequences=True)) model.add(Dropout(0.2)) model.add(BatchNormalization()) model.add(LSTM(128, return_sequences=True)) model.add(Dropout(0.1)) model.add(BatchNormalization()) model.add(LSTM(128)) model.add(Dropout(0.1)) model.add(BatchNormalization()) model.add(Dense(32, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) EPOCHS = 200 BATCH_SIZE = 64 opt = tf.keras.optimizers.RMSprop(learning_rate=0.001, rho=0.9) model.compile( loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'] ) filepath = "LSTM-{epoch:02d}-{val_acc:.3f}" history = model.fit( X_train, Y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_data=(X_test, Y_test), ) score = model.evaluate(X_test, Y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) model.save("{}.model".format(NAME))
def classify(): data = pd.read_csv("malware_dataset.csv") data['Type'] = data['Api'].map({ 'GetSystemTimeAsFileTime': 'Trojan', '__exception__': 'Backdoor', 'NtAllocateVirtualMemory': 'Downloader', 'LdrLoadDll': 'Adware', 'WriteConsoleA': 'Spyware', 'NtQueryValueKey': 'Worms', 'WSAStartup': 'Dropper', 'NtCreateMutant': 'Virus', 'LoadStringA': 'Rootkit', 'CreateThread': 'Ransomware', 'NtProtectVirtualMemory': 'Keylogger', 'SetUnhandledExceptionFilter': 'grayware', 'LdrGetDllHandle': 'Crimeware' }) from sklearn.preprocessing import LabelEncoder labelencoder = LabelEncoder() X = labelencoder.fit_transform(data.Type) y = labelencoder.fit_transform(data.Api) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.22) from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense model = Sequential() model.add(Dense(2, input_dim=1, activation='relu')) model.add(Dense(2, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.fit(X_train, y_train, batch_size=30, epochs=100) eval_model = model.evaluate(X_train, y_train) eval_model y_pred = model.predict(X_test) y_pred = (y_pred > 0.5) y_pred result = model.predict([X_test]) result print(model.predict(X_train)) model.save('model.h5')