def final3D(path): checkpoint_dir = os.path.dirname(path) model = Sequential() #encoder #input = 28 x 28 x 1 (wide and thin) model.add( InputLayer(input_shape=(config.NUM_CHANNELS, config.IMG_HEIGHT, config.IMG_WIDTH, 1))) model.add( Conv3D(128, 3, padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10))) model.add(BatchNormalization()) model.add(ReLU()) model.add(MaxPool3D(pool_size=(1, 2, 2))) model.add( Conv3D(64, 3, padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10))) model.add(BatchNormalization()) model.add(ReLU()) model.add(MaxPool3D(pool_size=(2, 2, 2))) model.add( Conv3D(32, 1, padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10))) model.add(BatchNormalization()) model.add(ReLU()) model.add( Conv3D(64, 3, padding="same", stride=(2, 2, 2), kernel_regularizer=tf.keras.regularizers.l2(1e-10))) model.add(BatchNormalization()) model.add(ReLU()) # model.add(UpSampling3D(size=(2,2,2))) model.add( Conv3D(128, 3, padding="same", stride=(1, 2, 2), kernel_regularizer=tf.keras.regularizers.l2(1e-10))) model.add(BatchNormalization()) model.add(ReLU()) model.add(UpSampling3D(size=(1, 2, 2))) model.add(Conv3D(1, 3, activation='sigmoid', padding='same')) model.compile(loss='mean_squared_error', optimizer=Adam()) cp_callback = tf.keras.callbacks.ModelCheckpoint( filepath=path, # monitor='val_loss', save_weights_only=True, # save_best_only=True, verbose=1, save_freq='epoch') latest = tf.train.latest_checkpoint(checkpoint_dir) # print('latestdasdasdas') print(latest) if latest is not None: model.load_weights(latest) print('weights loaded') model.save(path + 'model.h5') return model, cp_callback
OutlierVAE, OutlierVAEGMM, OutlierProphet, SpectralResidual, OutlierSeq2Seq, OutlierAE) from alibi_detect.utils.saving import save_detector, load_detector input_dim = 4 latent_dim = 2 n_gmm = 2 threshold = 10. samples = 5 seq_len = 10 p_val = .05 X_ref = np.random.rand(samples * input_dim).reshape(samples, input_dim) # define encoder and decoder encoder_net = tf.keras.Sequential([ InputLayer(input_shape=(input_dim, )), Dense(5, activation=tf.nn.relu), Dense(latent_dim, activation=None) ]) decoder_net = tf.keras.Sequential([ InputLayer(input_shape=(latent_dim, )), Dense(5, activation=tf.nn.relu), Dense(input_dim, activation=tf.nn.sigmoid) ]) kwargs = {'encoder_net': encoder_net, 'decoder_net': decoder_net} preprocess_kwargs = {'model': UAE(encoder_net=encoder_net)} gmm_density_net = tf.keras.Sequential([
from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Flatten, Dense, SimpleRNN, Conv1D, InputLayer number_of_steps = 50 series = time.generate_time_series(batch_size=10000, number_of_steps=number_of_steps + 1) X_train, y_train = series[:7000, :number_of_steps], series[:7000, -1] X_valid, y_valid = series[7000:9000, :number_of_steps], series[7000:9000, -1] X_test, y_test = series[9000:, :number_of_steps], series[9000:, -1] np.random.seed(42) tf.random.set_seed(42) model = Sequential([ InputLayer(input_shape=[None, 1]), Conv1D(filters=20, kernel_size=2, padding='causal', activation='relu', dilation_rate=[rate for rate in ((1, 2, 4, 8) * 2)]), Conv1D(filters=10, kernel_size=1) ]) model.compile(optimizer='adam', loss='mse') history = model.fit(x=X_train, y=y_train, epochs=20, validation_data=(X_valid, y_valid))
from tensorflow.keras import Sequential from tensorflow.keras.layers import InputLayer, Dense import numpy as np import gym import matplotlib.pylab as plt # Build simple sequential model with one flat hidden layer model = Sequential() model.add(InputLayer(batch_input_shape=(1, 5))) model.add(Dense(10, activation='sigmoid')) model.add(Dense(2, activation='linear')) model.compile(optimizer='adam', loss='mse', metrics=['mae']) # Gym initialization env = gym.make('NChain-v0') num_episodes = 100 y = 0.95 eps = 0.5 decay_factor = 0.999 r_avg_list = [] for i in range(num_episodes): game_step = 0 eps *= decay_factor r_sum = 0 done = False s = env.reset() print("Episode {} of {}".format(i + 1, num_episodes))
def build_model(self) -> None: """ Build and compile a sequential ML model using TensorFlow to detect a single character with convolutional layers, max pooling layers, and fully-connected layers. """ # build ML model to detect a single character by using CNN, max pooling # and fully connected layers model = Sequential() # add input layer that receives a gray-scale image of predefined size model.add(InputLayer(input_shape=consts.IMAGE_SIZE + (1, ))) # add convolutional layers with zero-padding (in order to retain # image size) and rectified linear unit activations model.add( Conv2D(filters=32, kernel_size=(3, 3), activation=relu, padding='same')) model.add( Conv2D(filters=64, kernel_size=(3, 3), activation=relu, padding='same')) # add max pooling layer to reduce image dimensions by a factor of 2 (reduce # total size by 4) and remove unwanted noise model.add(MaxPooling2D(pool_size=(2, 2), strides=2)) # add another set of convolutional and max pooling layers, while # increasing the amount of filters per layer model.add( Conv2D(filters=128, kernel_size=(3, 3), activation=relu, padding='same')) # add dropout layer to prevent overfitting model.add(Dropout(0.15)) model.add(MaxPooling2D(pool_size=(2, 2), strides=2)) model.add( Conv2D(filters=256, kernel_size=(3, 3), activation=relu, padding='same')) model.add(Dropout(0.15)) model.add(MaxPooling2D(pool_size=(2, 2), strides=2)) # flatten the output from max pooling layer (2D output) into a # one-dimensional tensor model.add(Flatten()) # add fully-connected layer after flattening and another dropout layer that # randomly turns off some percentage of neurons model.add(Dense(units=256, activation=relu)) model.add(Dropout(0.40625)) # add final output layer with 36 nodes (26 letters + 10 digits) with # activation of softmax to determine the probability of the input image # being some character model.add(Dense(units=36, activation=softmax)) print(model.summary()) # compile the model topography, set loss function, optimizer, and learning rate model.compile(optimizer=Adam(learning_rate=self.LR), loss=categorical_crossentropy, metrics=['accuracy']) self._model = model self._model_built = True
def make_q_function(): return tf.keras.models.Sequential([InputLayer(input_shape), *model_fn(), Dense(self.n_actions)])
import numpy as np import pytest import tensorflow as tf from tensorflow.keras.layers import Dense, Input, InputLayer from alibi_detect.cd.tensorflow import UAE, HiddenOutput n, n_features, n_classes, latent_dim, n_hidden = 100, 10, 5, 2, 7 shape = (n_features, ) X = np.random.rand(n * n_features).reshape(n, n_features).astype('float32') encoder_net = tf.keras.Sequential( [InputLayer(input_shape=(n_features, )), Dense(latent_dim)]) tests_uae = [encoder_net, latent_dim] n_tests_uae = len(tests_uae) @pytest.fixture def uae_params(request): return tests_uae[request.param] @pytest.mark.parametrize('uae_params', list(range(n_tests_uae)), indirect=True) def test_uae(uae_params): enc = uae_params if isinstance(enc, tf.keras.Sequential): encoder_net, enc_dim = enc, None elif isinstance(enc, int): encoder_net, enc_dim = None, enc X_enc = UAE(encoder_net=encoder_net, shape=X.shape[1:], enc_dim=enc_dim)(X)
X_train =X_train /255.0 X_test =X_test/255.0 X_train = X_train.reshape(X_train.shape[0],28,28,1) X_test = X_test.reshape(X_test.shape[0],28,28,1) Y_train = np_utils.to_categorical(Y_train,TOTAL_CLASS) Y_test = np_utils.to_categorical(Y_test,TOTAL_CLASS) print('======Data Shaping info =====') print('X train shape:', X_train.shape) print('Y train shape:', Y_train.shape) print('X test shape:', X_test.shape) print('Y test shape:', Y_test.shape) model = Sequential() model.add(InputLayer(input_shape = (28,28,1))) model.add(Conv2D(32,kernel_size = (3,3),padding ='same',activation = 'relu')) model.add(MaxPool2D(padding ='same',pool_size =(2,2))) model.add(Conv2D(32,kernel_size = (3,3),padding ='same',activation = 'relu')) model.add(MaxPool2D(padding ='same',pool_size =(2,2))) model.add(Flatten()) model.add(Dense(128,activation ='relu')) model.add(Dense(TOTAL_CLASS,activation ='softmax')) model.summary() sample = X_train[my_sample] sample = sample.reshape(1,28,28,1) pred = model.predict(sample) print('Prediction before learning:',np.argmax(pred),'\n') print('Label is:',np.argmax(Y_train[my_sample]),'\n')
#%% Data augmentation def normal_augmentation(input, output, seed, std=0.2, times=5): aug_input = np.vstack([(input*std*np.random.normal(size=input.shape)+input) for i in range(times)]) aug_input = np.vstack([input, aug_input]) aug_output = np.vstack([output for i in range(times+1)]) return(aug_input, aug_output) X_aug, Y_C_aug = normal_augmentation(X_train, Y_C_train, seed = 1, times = 20) X_aug, Y_T_aug = normal_augmentation(X_train, Y_T_train, seed = 1, times = 20) #%% Create model batch_size = 100 n_hidden = 100 n_in = 2 model_c = Sequential() model_c.add(InputLayer(input_shape=(time_len,2))) model_c.add(BatchNormalization()) #model_c.add(LSTM(n_hidden, batch_input_shape =(None, time_len, 2), model_c.add(LSTM(n_hidden, dropout=0.2, kernel_initializer = 'glorot_uniform',return_sequences=False)) #model_c.add(LSTM(n_hidden, dropout=0.2,kernel_initializer = 'glorot_uniform',return_sequences=True)) #model_c.add(TimeDistributed(Dense(1))) model_c.add(Dense(1)) model_c.add(Activation("relu")) ADAM = optimizers.Adam() model_c.compile(loss='mean_squared_error',optimizer=ADAM) model_c.summary() #%% model_t = Sequential() model_t.add(InputLayer(input_shape=(time_len,2)))
def deep_network_basic(in_n, hidden, out_n, hidden_activation, output_activation, lrate, dropout, l1, l2, metrics_): model = Sequential() # Construct model # First, check for Lx regularizatio if dropout == None: dropout = 0 if l1 != 0 or l2 != 0: model.add(InputLayer(input_shape=(in_n, ))) for idx, layer_n in enumerate(hidden): title = "hidden" + str(idx) # Check for either l1 or l2 regularization # And add hidden layers if l1 != 0: model.add( Dense(layer_n, use_bias=True, name=title, activation=hidden_activation, kernel_initializer="he_normal", kernel_regularizer=keras.regularizers.l1(l1))) if l2 != 0: model.add( Dense(layer_n, use_bias=True, name=title, activation=hidden_activation, kernel_initializer="he_normal", kernel_regularizer=keras.regularizers.l2(l2))) model.add( Dense(out_n, use_bias=True, name="output", activation=output_activation)) # If no LxReg, then build model without it elif dropout == 0: # construct model without dropout model.add(input_shape=(in_n, )) for idx, layer_n in enumerate(hidden): title = "hidden_" + str(idx) model.add( Dense(layer_n, use_bias=True, name=title, activation=hidden_activation)) model.add( Dense(out_n, use_bias=True, name="output", activation=output_activation)) elif dropout != 0: model.add(Dropout(dropout, input_shape=(in_n, ))) # Add dropout in the input layer and in the hidden layers for idx, layer_n in enumerate(hidden): title = "hidden" + str(idx) model.add( Dense(layer_n, use_bias=True, name=title, activation=hidden_activation)) model.add(Dropout(dropout)) model.add( Dense(out_n, use_bias=True, name="output", activation=output_activation)) # other method # Lx regularization # if other == true: # RegularizedDense = partial(keras.layers.Dense, # activation="elu", # kernel_initializer=keras.regularizers.l2(0.01)) # model = keras.models.Sequential([ # keras.layers.Flatten(input_shape=(in_n,), # RegularizedDense(1000), # RegularizedDense(100), # RegularizedDense(10, activation="elu", # kernel_initalizer="glorot_uniform"))) # ]) # Optiemizer opt = tf.keras.optimizers.Adam(lr=lrate, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) # Bind the optimizer and the loss function to the model model.compile(loss='mse', optimizer=opt, metrics=metrics_) # Generate an ASCII representation of the architecture print(model.summary()) return model
def test_ksdrift(ksdrift_params): n_features, n_enc, preprocess, alternative, correction, update_X_ref = ksdrift_params np.random.seed(0) X_ref = np.random.randn(n * n_features).reshape( n, n_features).astype('float32') n_infer = 2 preprocess_fn, preprocess_kwargs = preprocess if isinstance(preprocess_fn, Callable): if preprocess_fn.__name__ == 'uae' and n_features > 1 and isinstance( n_enc, int): tf.random.set_seed(0) encoder_net = tf.keras.Sequential( [InputLayer(input_shape=(n_features, )), Dense(n_enc)]) preprocess_kwargs['encoder_net'] = encoder_net elif preprocess_fn.__name__ == 'hidden_output': model = mymodel((n_features, )) preprocess_kwargs['model'] = model elif preprocess_fn.__name__ == 'pca' and isinstance(n_enc, int): if n_enc < n_features: preprocess_kwargs['n_components'] = n_enc n_infer = n_enc else: preprocess_fn, preprocess_kwargs = None, None else: preprocess_fn, preprocess_kwargs = None, None else: preprocess_fn, preprocess_kwargs = None, None cd = KSDrift(p_val=.05, X_ref=X_ref, update_X_ref=update_X_ref, preprocess_fn=preprocess_fn, preprocess_kwargs=preprocess_kwargs, correction=correction, alternative=alternative, n_infer=n_infer) X = X_ref.copy() preds_batch = cd.predict(X, drift_type='batch', return_p_val=True) assert preds_batch['data']['is_drift'] == 0 k = list(update_X_ref.keys())[0] assert cd.n == X.shape[0] + X_ref.shape[0] assert cd.X_ref.shape[0] == min(update_X_ref[k], X.shape[0] + X_ref.shape[0]) preds_feature = cd.predict(X, drift_type='feature', return_p_val=True) assert preds_feature['data']['is_drift'].shape[0] == cd.n_features preds_by_feature = (preds_feature['data']['p_val'] < cd.p_val).astype(int) assert (preds_feature['data']['is_drift'] == preds_by_feature).all() np.random.seed(0) X_randn = np.random.randn(n * n_features).reshape( n, n_features).astype('float32') mu, sigma = 5, 5 X_low = sigma * X_randn - mu X_high = sigma * X_randn + mu preds_batch = cd.predict(X_high, drift_type='batch') if alternative != 'less': assert preds_batch['data']['is_drift'] == 1 preds_batch = cd.predict(X_low, drift_type='batch') if alternative != 'greater': assert preds_batch['data']['is_drift'] == 1
def test_lsdd(lsdd_params): n_features, n_enc, preprocess, n_permutations, update_x_ref, preprocess_x_ref = lsdd_params np.random.seed(0) x_ref = np.random.randn(n * n_features).reshape(n, n_features).astype( np.float32) preprocess_fn, preprocess_kwargs = preprocess to_list = False if hasattr(preprocess_fn, '__name__') and preprocess_fn.__name__ == 'preprocess_list': if not preprocess_x_ref: return to_list = True x_ref = [_[None, :] for _ in x_ref] elif isinstance(preprocess_fn, Callable): if 'layer' in list(preprocess_kwargs.keys()) \ and preprocess_kwargs['model'].__name__ == 'HiddenOutput': model = mymodel((n_features, )) layer = preprocess_kwargs['layer'] preprocess_fn = partial(preprocess_fn, model=HiddenOutput(model=model, layer=layer)) elif preprocess_kwargs['model'].__name__ == 'UAE' \ and n_features > 1 and isinstance(n_enc, int): tf.random.set_seed(0) encoder_net = tf.keras.Sequential( [InputLayer(input_shape=(n_features, )), Dense(n_enc)]) preprocess_fn = partial(preprocess_fn, model=UAE(encoder_net=encoder_net)) else: preprocess_fn = None else: preprocess_fn = None cd = LSDDDriftTF(x_ref=x_ref, p_val=.05, preprocess_x_ref=preprocess_x_ref if isinstance( preprocess_fn, Callable) else False, update_x_ref=update_x_ref, preprocess_fn=preprocess_fn, n_permutations=n_permutations) perturbation = np.random.normal( size=(n, n_features)) / 100 # LSDD struggles with copies/repeats x = x_ref.copy() + perturbation.astype(np.float32) preds = cd.predict(x, return_p_val=True) assert preds['data']['is_drift'] == 0 and preds['data']['p_val'] >= cd.p_val if isinstance(update_x_ref, dict): k = list(update_x_ref.keys())[0] assert cd.n == len(x) + len(x_ref) assert cd.x_ref.shape[0] == min(update_x_ref[k], len(x) + len(x_ref)) x_h1 = np.random.randn(n * n_features).reshape(n, n_features).astype( np.float32) if to_list: x_h1 = [_[None, :] for _ in x_h1] preds = cd.predict(x_h1, return_p_val=True) if preds['data']['is_drift'] == 1: assert preds['data']['p_val'] < preds['data']['threshold'] == cd.p_val assert preds['data']['distance'] > preds['data']['distance_threshold'] else: assert preds['data']['p_val'] >= preds['data']['threshold'] == cd.p_val assert preds['data']['distance'] <= preds['data']['distance_threshold']
def conv3d(filters, latentDim, path, batch=False, dropout=False, filter_size=3): checkpoint_dir = os.path.dirname(path) model = Sequential() #encoder #input = 28 x 28 x 1 (wide and thin) model.add( InputLayer(input_shape=(config.NUM_CHANNELS, config.IMG_HEIGHT, config.IMG_WIDTH, 1))) for f in filters: model.add( Conv3D(f, filter_size, strides=2, activation='relu', padding="same")) if (dropout): model.add(Dropout(0.2)) if (batch): model.add(BatchNormalization()) # model.add(MaxPool3D(pool_size=(1,2,2))) if (latentDim is not None): # model.add(Flatten()) model.add( Conv3D(latentDim, 1, strides=1, activation='relu', padding="same")) if (batch): model.add(BatchNormalization()) # model.add(Flatten()) # model.add(Dense(latentDim)) for f in reversed(filters): # apply a CONV_TRANSPOSE => RELU => BN operation model.add( Conv3DTranspose(f, filter_size, activation='relu', strides=2, padding="same")) if (dropout): model.add(Dropout(0.2)) if (batch): model.add(BatchNormalization()) model.add(Conv3D(1, filter_size, activation='sigmoid', padding='same')) if (config.NUM_CHANNELS % (2**len(filters)) != 0): dim = config.NUM_CHANNELS for i in range(len(filters)): if (dim % 2 != 0): dim = int(dim / 2) dim += 1 else: dim = int(dim / 2) print(dim) croppingFactor = int( (dim * (2**len(filters)) - config.NUM_CHANNELS) / 2) model.add( Cropping3D(cropping=((croppingFactor, croppingFactor), (0, 0), (0, 0)))) model.summary() model.compile(loss='mean_squared_error', optimizer=Adam()) cp_callback = tf.keras.callbacks.ModelCheckpoint( filepath=path, # monitor='val_loss', save_weights_only=True, # save_best_only=True, verbose=1, save_freq='epoch') latest = tf.train.latest_checkpoint(checkpoint_dir) # print('latestdasdasdas') print(latest) if latest is not None: model.load_weights(latest) print('weights loaded') return model, cp_callback
def modular2d3dims(filters, latentDim, path, batch=False, dropout=False, filter_size=3): checkpoint_dir = os.path.dirname(path) model = Sequential() #encoder #input = 28 x 28 x 1 (wide and thin) model.add( InputLayer(input_shape=(config.NUM_CHANNELS, config.IMG_HEIGHT, config.IMG_WIDTH))) for f in filters: # print('assssdad') model.add( Conv2D(f, filter_size, strides=2, activation='relu', padding="same", data_format="channels_first")) if (dropout): model.add(Dropout(0.2)) if (batch): model.add(BatchNormalization()) # model.add(MaxPooling2D(pool_size=(2, 2))) if (latentDim is not None): # model.add(Flatten()) model.add( Conv2D(latentDim, (1, 1), strides=1, activation='relu', padding="same", data_format="channels_first")) if (batch): model.add(BatchNormalization()) for f in reversed(filters): # apply a CONV_TRANSPOSE => RELU => BN operation model.add( Conv2DTranspose(f, filter_size, activation='relu', strides=2, padding="same", data_format="channels_first")) if (dropout): model.add(Dropout(0.2)) if (batch): model.add(BatchNormalization()) # model.add(Reshape((20, config.IMG_HEIGHT, config.IMG_WIDTH))) model.add( Conv2D(config.NUM_CHANNELS, filter_size, activation='sigmoid', padding='same', data_format="channels_first")) # model.add(Cropping2D((1))) model.summary() model.compile(loss='mean_squared_error', optimizer=Adam()) cp_callback = tf.keras.callbacks.ModelCheckpoint( filepath=path, # monitor='val_loss', save_weights_only=True, # save_best_only=True, verbose=1, save_freq='epoch') latest = tf.train.latest_checkpoint(checkpoint_dir) # print('latestdasdasdas') print(latest) if latest is not None: model.load_weights(latest) print('weights loaded') return model, cp_callback
import tensorflow.keras import pygad.kerasga from pygad.kerasga import KerasGA import numpy import pygad from tensorflow.keras.initializers import Ones, ones from tensorflow.keras.losses import MeanSquaredError, BinaryCrossentropy, MeanAbsoluteError from tensorflow.keras import Model from tensorflow.keras.utils import plot_model, pack_x_y_sample_weight from tensorflow.keras.models import Sequential from tensorflow.keras.activations import sigmoid from pygad.kerasga import predict # Create a Keras model model = Sequential([ InputLayer(input_shape=(2, )), Dense(units=2, use_bias=True, bias_initializer=Ones(), activation=sigmoid), Dense(units=1, use_bias=True, bias_initializer=Ones(), activation=sigmoid) ]) # Create an instance of the pygad.kerasga.KerasGA class. kerasGA = KerasGA(model=model, num_solutions=9) # Prepare the Training Data # XOR problem inputs data_inputs = numpy.array([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]) # XOR problem outputs data_outputs = numpy.array([[0.0], [1.0], [1.0], [0.0]])
#Fit the encoder instance to training label Y_train = le.fit_transform(Y_train.astype(str)) #Encode the test labels Y_test = le.transform(Y_test.astype(str)) #Transform Y_ into a binary vector Y_train = to_categorical(Y_train) Y_test = to_categorical(Y_test) ####......Design the model....######## #Initialize the model model = Sequential() #Create an input layer instance for model model.add(InputLayer(input_shape=(X_train.shape[1],))) #create a hidden layer model.add(Dense(12, activation = 'relu')) #create output layer model.add(Dense(2, activation='softmax')) #Compile model model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) ####.....Train and Evaluate the Model.....###### model.fit(X_train, Y_train, epochs = 100, batch_size = 16, verbose = 1) #model evaluate loss, acc = model.evaluate(X_test, Y_test, verbose=0) print("Loss", loss, "Accuracy", acc)
tag = m.group(2) sent.append(word_to_int[word]) if n == focus_position: int_tag = tag_to_int[tag] n += 1 X.append(sent) y.append(int_tag) X = pad_sequences(X, maxlen=maxlen, padding='post') #y = pad_sequences(y, maxlen=maxlen, padding='post') #X=np.array(X[:300]) #y=np.array(y[:300]) model = Sequential() model.add(InputLayer(input_shape=(maxlen, ))) model.add(Embedding(vocab_len, 128)) model.add(Bidirectional(LSTM(256, return_sequences=True))) model.add(Attention()) model.add(Dense(len(Tags) + 1)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer=Adam(0.001), metrics=['accuracy']) model.summary() #plot_model(model, to_file='LSTM_pos_model.png') X_train, X_test, y_train, y_test = train_test_split(X,
def model_train(model_add, x_train, y_train, x_test, y_test): # build a sequential model model = Sequential() model.add(InputLayer(input_shape=(512, 512, 1))) # 1st conv block model.add( Conv2D(25, (5, 5), activation='relu', strides=(1, 1), padding='same')) model.add(MaxPool2D(pool_size=(2, 2), padding='same')) # 2nd conv block model.add( Conv2D(50, (5, 5), activation='relu', strides=(2, 2), padding='same')) model.add(MaxPool2D(pool_size=(2, 2), padding='same')) model.add(BatchNormalization()) # 3rd conv block model.add( Conv2D(70, (3, 3), activation='relu', strides=(2, 2), padding='same')) model.add(MaxPool2D(pool_size=(2, 2), padding='valid')) model.add(BatchNormalization()) # ANN block model.add(Flatten()) model.add(Dense(units=100, activation='relu')) model.add(Dense(units=100, activation='relu')) model.add(Dropout(0.25)) # output layer model.add(Dense(units=2, activation='softmax')) #optimizer = keras.optimizers.Adam(lr=0.01) #opt = SGD(lr=1) if os.path.isfile(model_add): print('Found saved model, loading now') user_choice = messagebox.askyesno('Found saved model', 'You want to train again?') if (user_choice == True): model.summary() model.compile(loss='categorical_crossentropy', optimizer='adamax', metrics=['accuracy']) # fit on data for 30 epochs es = MyThresholdCallback(threshold=0.89) history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=100, batch_size=1, callbacks=[es]) plot_acc(history) plot_loss(history) model.save(model_add) else: model = tensorflow.keras.models.load_model(model_add) model.summary() else: print('No saved model found, fitting new model with the data') print('Saving to ' + model_add) model.summary() model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) es = MyThresholdCallback(threshold=0.89) history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=100, batch_size=1, callbacks=[es]) # fit on data for 30 epochs plot_acc(history) plot_loss(history) model.save(model_add) return model
def pretrain_dae_nn(train_data, validation_data, hidden_shape_list, n_output, lrate, activation, epochs, callbacks, out_activation=None, metrics=None, loss='mse', pretrain_loss='mse', dropout=None, L2_reg=None, verbose=False, return_params=False): if out_activation is None: out_activation = activation # start by building a nn with the first hidden layer # This probably won't work for 2-D inputs without some modification print('constructing initial model:', train_data.X.shape[1], hidden_shape_list[0], train_data.X.shape[1]) base_model, loss, opt, metrics = build_nn(train_data.X.shape[1], [hidden_shape_list[0]], train_data.X.shape[1], lrate=lrate, activation=activation, out_activation=out_activation, metrics=metrics, loss=pretrain_loss, dropout=dropout, L2_reg=L2_reg, return_params=True) if verbose: base_model.summary() print('training on :') print(train_data.X.shape, train_data.X) print(train_data.y.shape, train_data.y) # now, fit to train data base_model.fit(train_data.X, train_data.y, validation_data=validation_data, epochs=epochs, callbacks=callbacks) # once we're fit, train the next layer for i, h in enumerate(hidden_shape_list[1:]): # freeze the hidden layer base_model.trainable = False # remove the output layer # normally, could just call model.layers.pop() , but this isn't working # construct a new model with just the layers we need model = Sequential() model.add(InputLayer(input_shape=train_data.X.shape[1])) for layer in base_model.layers[: -1]: # up to, but not including, the last layer model.add(layer) # add a new hidden layer if L2_reg is not None: model.add( Dense(h, activation=activation, use_bias=True, kernel_regularizer=L2(L2_reg))) else: model.add(Dense(h, activation=activation, use_bias=True)) if dropout is not None: model.add(Dropout(dropout)) # add the output layer back if L2_reg is not None: model.add( Dense(train_data.X.shape[1], name='output' + str(i + 1), activation=out_activation, use_bias=True, kernel_regularizer=L2(L2_reg))) else: model.add( Dense(train_data.X.shape[1], name='output' + str(i + 1), activation=out_activation, use_bias=True)) # recompile the model model.compile(loss=pretrain_loss, metrics=metrics, optimizer=opt) if verbose: model.summary() # train again model.fit(train_data.X, train_data.y, validation_data=validation_data, epochs=epochs, callbacks=callbacks) # reset for next iteration base_model = model # now, add the real output # remove the output layer model = Sequential() model.add(InputLayer(input_shape=train_data.X.shape[1])) # TODO: dropout for the input layer ? Probably not for layer in base_model.layers[: -1]: # up to, but not including, the last layer model.add(layer) # add dropout between each layers if dropout is not None: model.add(Dropout(dropout)) if L2_reg is not None: model.add( Dense(train_data.X.shape[1], name='output' + str(i + 1), activation=out_activation, use_bias=True, kernel_regularizer=L2(L2_reg))) else: model.add( Dense(train_data.X.shape[1], name='output' + str(i + 1), activation=out_activation, use_bias=True)) # unfreeze everything model.trainable = True model.compile(loss=loss, metrics=metrics, optimizer=opt) # additional returns are for use in modifying and recompiling if return_params: return model, loss, opt, metrics else: return model
output_row[labels.index(docs_y[x])] = 1 training.append(bag) output.append(output_row) training = numpy.array(training) output = numpy.array(output) with open("data.pickle", "wb") as f: pickle.dump((words, labels, training, output), f) ops.reset_default_graph() model = Sequential() model.add(Flatten()) model.add(InputLayer(input_shape=(None, len(training[0])))) model.add(Dense(8, activation="relu")) model.add(Dense(8, activation="relu")) model.add(Dense(len(output[0]), activation="softmax")) model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"]) if os.path.exists("Aphina_model/saved_model" + ".pb"): keras.models.load_model("Aphina_model") else: model.fit(training, output, epochs=1000, batch_size=8) model.save("Aphina_model")
def predict(filename): image_url = url_for('images', filename=filename) image_path = os.path.join(app.config['UPLOAD_FOLDER'], filename) image_data = load_and_prepare(image_path) print(hasattr(image_data, "_getexif")) # keras imports from tensorflow.keras.preprocessing.image import load_img, img_to_array from tensorflow.keras import Sequential from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, GlobalAveragePooling2D from tensorflow.keras.layers import Dropout, InputLayer, BatchNormalization # instantiate the model NN = Sequential() NN.add(InputLayer(input_shape=(150, 150, 3))) # Conv block 1. NN.add(Conv2D(filters=2, kernel_size=3, activation='elu', padding='same')) NN.add(MaxPooling2D(2)) NN.add(BatchNormalization()) NN.add(Dropout(0.2)) # Conv block 2 NN.add(Conv2D(filters=4, kernel_size=3, activation='elu', padding='same')) NN.add(MaxPooling2D(2)) NN.add(BatchNormalization()) # Conv block 3 NN.add(Conv2D(filters=8, kernel_size=3, activation='elu', padding='same')) NN.add(MaxPooling2D(2)) NN.add(BatchNormalization()) NN.add(Dropout(0.5)) # Conv block 4 NN.add(Conv2D(filters=12, kernel_size=3, activation='elu', padding='same')) NN.add(MaxPooling2D(2)) NN.add(BatchNormalization()) # Conv block 5 NN.add(Conv2D(filters=24, kernel_size=3, activation='elu', padding='same')) NN.add(MaxPooling2D(2)) NN.add(BatchNormalization()) # Fully connected block - flattening followed by dense and output layers NN.add(Flatten()) NN.add(Dense(4, activation='elu')) NN.add(BatchNormalization()) NN.add(Dropout(0.5)) NN.add(Dense(2, activation='sigmoid')) # 2 target classes, output layer # define the model and load the weights NEURAL_NET_MODEL_PATH = os.environ['NEURAL_NET_MODEL_PATH'] NN.load_weights(NEURAL_NET_MODEL_PATH) # predict and generate bar graph predictions = NN.predict(image_data)[0] # imports for emotion detection from fer import FER import cv2 detector = FER() image_data = image_data * 255 image_data = image_data[0] image_data = image_data.astype('uint8') emotions = detector.detect_emotions(image_data) emotions_dict = emotions[0]['emotions'] script, div = generate_barplot(emotions_dict) try: return render_template('predict.html', plot_script=script, plot_div=div, image_url=image_url, message=predictions[1]) except IndexError: return render_template( 'predict_no_emotion.html', plot_script=script, plot_div=div, image_url=image_url, message= 'Oops! We could not capture your emotions with that photo. Please try again and make sure your face is clearly visible!' )
T_scaler = MinMaxScaler() temp = C_scaler.fit_transform(CORE_DATA[['CC_', 'TT_']]) CORE_DATA['CC_s'] = C_scaler.fit_transform(CORE_DATA[['CC_']]) CORE_DATA['TT_s'] = T_scaler.fit_transform(CORE_DATA[['TT_']]) #%% state_list = list(set(DATA.state)) state_list.sort() state_list = state_list + ['US'] #%% test = np.arange(40).reshape(-1, 10, 2) #%% def non_adder(x): y = x[0] + x[1] return (y) test = Lambda(non_adder) K.clear_session() model = Sequential() model.add(InputLayer(input_shape=(time_len, 2))) model.add(Lambda(non_adder, output_shape=[1])) model.compile(loss='mean_squared_error') model.predict(test) # %%
print(dataset.describe()) # Luckily, there are no categorical variables in this dataset, so you do not have to perform one-hot encoding. You should always check this, however, before diving into analysis! # dataset = pd.get_dummies(dataset) features = dataset.iloc[:, 0:-1] labels = dataset.iloc[:,1] x_train, x_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=1) # Standardize #numerical_features = features_train.select_dtypes(include=['float64', 'int64']) #only select numerical features types automatically ct = ColumnTransformer([("only numeric", StandardScaler(), features.columns)], remainder='passthrough') x_train_scaled = ct.fit_transform(x_train) x_test_scaled = ct.transform(x_test) # Do extensions code below my_model = Sequential() my_model.add(InputLayer(input_shape=(x_train_scaled.shape[1],))) my_model.add(Dense(16, activation='relu')) my_model.add(Dense(1)) print(my_model.summary()) # optimizer opt = Adam(learning_rate =0.01) my_model.compile(loss='mse', metrics=['mae'], optimizer=opt) #train history = my_model.fit(x_train_scaled, y_train, epochs=40, batch_size=1, verbose=1, validation_split = 0.3) #without validation_split, cannot extract val_mae my_model.evaluate(x_test_scaled, x_test) # PLOT the model loss per epoch as well as the mean-average error per epoch for both training and validation data. This will give you an insight into how the model performs better over time and can also help you figure out better ways to tune your hyperparameters. fig = plt.figure() ax1 = fig.add_subplot(2, 1, 1) ax1.plot(history.history['mae']) ax1.plot(history.history['val_mae'])
X = np.zeros((n, n_features)) class MyModel(tf.keras.Model): def __init__(self): super(MyModel, self).__init__() self.dense = Dense(n_classes, activation='softmax') def call(self, x: np.ndarray) -> tf.Tensor: return self.dense(x) model = MyModel() encoder_net = tf.keras.Sequential( [InputLayer(input_shape=(n_features, )), Dense(latent_dim)]) decoder_net = tf.keras.Sequential( [InputLayer(input_shape=(latent_dim, )), Dense(n_features)]) AutoEncoder = AE(encoder_net, decoder_net) # model, proba, return_class, shape tests_predict = [(model, True, False, None), (model, False, True, None), (model, False, False, (n, n_classes)), (AutoEncoder, False, False, None), (AutoEncoder, True, False, None)] n_tests = len(tests_predict) @pytest.fixture
def test_lsdd_online(lsdd_online_params): n_features, n_enc, ert, window_size, preprocess, n_bootstraps = lsdd_online_params np.random.seed(0) x_ref = np.random.randn(n * n_features).reshape(n, n_features).astype( np.float32) preprocess_fn, preprocess_kwargs = preprocess to_list = False if hasattr(preprocess_fn, '__name__') and preprocess_fn.__name__ == 'preprocess_list': to_list = True x_ref = [_[None, :] for _ in x_ref] elif isinstance(preprocess_fn, Callable): if 'layer' in list(preprocess_kwargs.keys()) \ and preprocess_kwargs['model'].__name__ == 'HiddenOutput': model = mymodel((n_features, )) layer = preprocess_kwargs['layer'] preprocess_fn = partial(preprocess_fn, model=HiddenOutput(model=model, layer=layer)) elif preprocess_kwargs['model'].__name__ == 'UAE' \ and n_features > 1 and isinstance(n_enc, int): tf.random.set_seed(0) encoder_net = tf.keras.Sequential( [InputLayer(input_shape=(n_features, )), Dense(n_enc)]) preprocess_fn = partial(preprocess_fn, model=UAE(encoder_net=encoder_net)) else: preprocess_fn = None else: preprocess_fn = None cd = LSDDDriftOnlineTF(x_ref=x_ref, ert=ert, window_size=window_size, preprocess_fn=preprocess_fn, n_bootstraps=n_bootstraps) x_h0 = np.random.randn(n * n_features).reshape(n, n_features).astype( np.float32) detection_times_h0 = [] test_stats_h0 = [] for x_t in x_h0: if to_list: x_t = [x_t] pred_t = cd.predict(x_t, return_test_stat=True) test_stats_h0.append(pred_t['data']['test_stat']) if pred_t['data']['is_drift']: detection_times_h0.append(pred_t['data']['time']) cd.reset() average_delay_h0 = np.array(detection_times_h0).mean() test_stats_h0 = [ts for ts in test_stats_h0 if ts is not None] assert ert / 3 < average_delay_h0 < 3 * ert cd.reset() x_h1 = 1 + np.random.randn(n * n_features).reshape(n, n_features).astype( np.float32) detection_times_h1 = [] test_stats_h1 = [] for x_t in x_h1: if to_list: x_t = [x_t] pred_t = cd.predict(x_t, return_test_stat=True) test_stats_h1.append(pred_t['data']['test_stat']) if pred_t['data']['is_drift']: detection_times_h1.append(pred_t['data']['time']) cd.reset() average_delay_h1 = np.array(detection_times_h1).mean() test_stats_h1 = [ts for ts in test_stats_h1 if ts is not None] assert np.abs(average_delay_h1) < ert / 2 assert np.mean(test_stats_h1) > np.mean(test_stats_h0)
train_loss(mask_loss) train_accuracy(labels, predictions) #@tf.function def test_step(images, labels, use_mask=True): predictions = model(images, training=False, use_mask=use_mask) t_loss = cross_entropy(labels, predictions) test_loss(t_loss) test_accuracy(labels, predictions) layers = [ InputLayer(input_shape=(28, 28, 1)), BinaryLotteryConv2D(16, kernel_size=3, strides=2, trainable_M=False, const_init_M=20), ReLU(), Conv2D(32, kernel_size=4, strides=2), ReLU(), #BinaryLotteryConv2D(16, kernel_size=3, strides=2, trainable_M=False, const_init_M=20), #ReLU(), Flatten(), Dense(32), ReLU(), Dense(10), Activation('softmax')
Out = TimeDistributed(Lambda(part))(mer) layer_1 = -main_input Out = TimeDistributed(Lambda(part2))([main_input, layer_1]) model = Model(inputs=[main_input, aux_input], outputs=Out) model.compile(loss='mean_squared_error', optimizer='RMSprop') model.predict([DATA, DATA2]) #%% from tensorflow.keras.utils import plot_model plot_model(model) model = Sequential() x = Input model.add(InputLayer(input_shape=(3, 2))) model.add(TimeDistributed(Lambda(lambda x: x[:, 0]))) model.compile(loss='mean_squared_error', optimizer='RMSprop') out = model.predict(DATA) model.predict() # model.add(BatchNormalization()) for i in range(n_layer): if i == n_layer - 1: model.add( LSTM(n_hidden, dropout=dropout, kernel_initializer=init, return_sequences=False)) else: model.add(
test_MSE.update_state(y_test, y_pred) test_MSE_hist.append(test_MSE.result()) def print_dots(epoch): if (epoch % 1 == 0): print('.', end='') if (epoch % 10 == 0): print('.') ######################################################################### ## build and train the model ######################################################################### simple_lstm_model = Sequential([ InputLayer(input_shape=x_train.shape[1:]), Reshape( (x_train.shape[1], 4)), ## collapse the derivative and high/low axes LSTM(int(10), activation='tanh'), Dense(int(2 * TARG_SIZE), activation=None), Reshape((TARG_SIZE, 2)) ]) simple_lstm_model.compile(optimizer=tf.keras.optimizers.Adam(), loss=tf.keras.losses.MSE, metrics=[tf.keras.metrics.MSE]) simple_lstm_model.summary() VALIDATION_STEPS = STEPS_PER_EPOCH for epoch in EPOCHS: train_MSE.reset_states()
def __init__(self, n_features, n_labels=1, hidden_layers=None, input_layer=None, output_layer=None): """ Parameters ---------- n_features : int Number of features (inputs) to train the model on n_labels : int, optional Number of labels (outputs) to the model, by default 1 hidden_layers : list | None, optional List of dictionaries of key word arguments for each hidden layer in the NN. Dense linear layers can be input with their activations or separately for more explicit control over the layer ordering. For example, this is a valid input for hidden_layers that will yield 8 hidden layers (10 layers including input+output): [{'units': 64, 'activation': 'relu', 'dropout': 0.01}, {'units': 64}, {'batch_normalization': {'axis': -1}}, {'activation': 'relu'}, {'dropout': 0.01}, {'class': 'Flatten'}, ] by default None which will lead to a single linear layer input_layer : None | dict Input layer. specification. Can be a dictionary similar to hidden_layers specifying a dense / conv / lstm layer. Will default to a keras InputLayer with input shape = n_features. output_layer : None | list | dict Output layer specification. Can be a list/dict similar to hidden_layers input specifying a dense layer with activation. For example, for a classfication problem with a single output, output_layer should be [{'units': 1}, {'activation': 'sigmoid'}]. This defaults to a single dense layer with no activation (best for regression problems). """ self._i = 0 self._layers = [] self._hidden_layers_kwargs = copy.deepcopy(hidden_layers) self._input_layer_kwargs = copy.deepcopy(input_layer) self._output_layer_kwargs = copy.deepcopy(output_layer) if input_layer is None: self._layers = [InputLayer(input_shape=[n_features])] else: if not isinstance(input_layer, dict): msg = ('Input layer spec needs to be a dict but received: {}' .format(type(input_layer))) raise TypeError(msg) else: self.add_layer(input_layer) if hidden_layers: for layer in hidden_layers: self.add_layer(layer) if output_layer is None: self._layers.append(Dense(n_labels)) else: if isinstance(output_layer, dict): output_layer = [output_layer] if not isinstance(output_layer, list): msg = ('Output layer spec needs to be a dict or list but ' 'received: {}'.format(type(output_layer))) raise TypeError(msg) for layer in output_layer: self.add_layer(layer)
def final2DStacked(path): checkpoint_dir = os.path.dirname(path) model = Sequential() model.add( InputLayer(input_shape=(config.NUM_CHANNELS, config.IMG_HEIGHT, config.IMG_WIDTH))) model.add( Conv2D(128, (3, 3), padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10), data_format="channels_first")) model.add(BatchNormalization()) model.add(ReLU()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D(64, (3, 3), padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10), data_format="channels_first")) model.add(BatchNormalization()) model.add(ReLU()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D(16, (1, 1), padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10), data_format="channels_first")) model.add( Conv2DTranspose(64, (3, 3), strides=2, padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10), data_format="channels_first")) model.add(BatchNormalization()) model.add(ReLU()) model.add( Conv2DTranspose(128, (3, 3), strides=2, padding="same", kernel_regularizer=tf.keras.regularizers.l2(1e-10), data_format="channels_first")) model.add(BatchNormalization()) model.add(ReLU()) model.add(Conv2D(config.NUM_CHANNELS, (3, 3), activation='sigmoid', padding='same'), data_format="channels_first") model.summary() model.compile(loss='mean_squared_error', optimizer=Adam()) cp_callback = tf.keras.callbacks.ModelCheckpoint( filepath=path, # monitor='val_loss', save_weights_only=True, # save_best_only=True, verbose=1, save_freq='epoch') latest = tf.train.latest_checkpoint(checkpoint_dir) # print('latestdasdasdas') print(latest) if latest is not None: model.load_weights(latest) print('weights loaded') model.save(path + 'model.h5') return model, cp_callback