def __init__(self, cfg=Config()): super(CVAE, self).__init__() self.cfg = cfg self.width = cfg.img_shape[0] self.height = cfg.img_shape[1] self.inference_net = tf.keras.Sequential([ layers.InputLayer(input_shape=cfg.img_shape), layers.Conv2D(cfg.filters, 3, 2, 'same', activation='relu'), layers.Conv2D(cfg.filters*2, 3, 2, 'same', activation='relu'), layers.Flatten(), layers.Dense(cfg.z_dim+cfg.z_dim) ]) self.generative_net = tf.keras.Sequential([ layers.InputLayer(input_shape=(cfg.z_dim)), layers.Dense(self.width//4*self.height//4*cfg.filters*2, activation='relu'), layers.Reshape([self.width//4, self.height//4, cfg.filters*2]), layers.Conv2DTranspose(cfg.filters*2, 3, 2, 'same', activation='relu'), layers.Conv2DTranspose(cfg.filters, 3, 2, 'same', activation='relu'), layers.Conv2DTranspose(1, 3, 1, 'same') ]) self.label_net = tf.keras.Sequential([ tf.keras.layers.InputLayer(input_shape=(10,)), tf.keras.layers.Dense(cfg.z_dim) ])
def __init__(self, latent_dim): super(CVAE, self).__init__() self.latent_dim = latent_dim self.encoder = tf.keras.Sequential( [ layers.InputLayer(input_shape=(28, 28, 1)), layers.Conv2D(filters=32, kernel_size=3, strides=(2, 2), activation='relu'), layers.Conv2D(filters=64, kernel_size=3, strides=(2, 2), activation='relu'), layers.Flatten(), # No activation layers.Dense(latent_dim + latent_dim), ] ) self.decoder = tf.keras.Sequential( [ layers.InputLayer(input_shape=(latent_dim,)), layers.Dense(units=7*7*32, activation=tf.nn.relu), layers.Reshape(target_shape=(7, 7, 32)), layers.Conv2DTranspose(filters=64, kernel_size=3, strides=2, padding='same', activation='relu'), layers.Conv2DTranspose(filters=32, kernel_size=3, strides=2, padding='same', activation='relu'), # No activation layers.Conv2DTranspose(filters=1, kernel_size=3, strides=1, padding='same'), ] )
def create_seq_model(nodes=[], weight_init="glorot_normal", hidden_activation="relu", opt_name="adam", metric_list=["acc"], output_activation="softmax", loss_name="categorical_crossentropy"): # Create Sequential Model model = Sequential() if nodes != []: # Create Input Layer model.add(layers.InputLayer(input_shape=nodes[0], name="input")) # Create Hidden Layers for i in range(1, len(nodes) - 1): hidden_name = "hidden_{}".format(i) model.add( layers.Dense(units=nodes[i], kernel_initializer=weight_init, activation=hidden_activation, name=hidden_name)) # Create Output Layers model.add( layers.Dense(units=nodes[-1], kernel_initializer=weight_init, activation=output_activation, name="output")) # Compile Neural Network model.compile(optimizer=opt_name, loss=loss_name, metrics=metric_list) # Return built model return model
def create_model(self): self.model = tf.keras.Sequential([ layers.InputLayer(input_shape=(self.num_of_frames, self.frame_size)), layers.Conv1D(128, kernel_size=3), layers.Conv1D(128, kernel_size=3), layers.ReLU(), layers.Dropout(.5), layers.MaxPooling1D(), layers.Conv1D(256, kernel_size=3), layers.ReLU(), layers.Dropout(.5), layers.MaxPooling1D(), layers.Conv1D(512, kernel_size=3), layers.ReLU(), layers.Dropout(.5), layers.MaxPooling1D(), layers.Flatten(), layers.Dense(512), layers.ReLU(), layers.Dropout(.5), layers.Dense(256), layers.ReLU(), layers.Dropout(.5), layers.Dense(self.num_of_classes, activation='softmax') ])
def get_compiled_model(self): model = models.Sequential([ layers.InputLayer(input_shape=(IMAGE_SIZE, IMAGE_SIZE, 1)), layers.Conv2D(16, (3, 3), activation='relu', padding='same'), layers.Conv2D(32, (3, 3), activation='relu', padding='same'), layers.MaxPool2D(2), layers.Conv2D(64, (3, 3), activation='relu', padding='same'), layers.Conv2D(128, (3, 3), activation='relu', padding='same'), layers.MaxPool2D(2), layers.Conv2D(256, (3, 3), activation='relu', padding='same'), layers.Conv2D(512, (3, 3), activation='relu', padding='same'), layers.MaxPool2D(2), layers.Conv2D(256, (3, 3), activation='relu', padding='same'), layers.UpSampling2D(2), layers.Conv2D(128, (3, 3), activation='relu', padding='same'), layers.UpSampling2D(2), layers.Conv2D(64, (3, 3), activation='relu', padding='same'), layers.UpSampling2D(2), layers.Conv2D(32, (3, 3), activation='relu', padding='same'), layers.Conv2D(16, (3, 3), activation='relu', padding='same'), layers.Conv2D(2, (3, 3), activation='relu', padding='same'), ]) model.compile( optimizer=optimizers.Adam(), loss='mse', # run_eagerly=True, # metrics=['accuracy'] ) return model
def define_model(nchan, L, Fs): model = tf.keras.Sequential() model.add(layers.InputLayer((L, nchan), batch_size=1)) model.add(layers.LayerNormalization(axis=[1, 2], center=False, scale=False)) model.add( MorletConvRaw([L, nchan], Fs, input_shape=[L, nchan, 1], etas=etas, wtime=wtime)) model.add( layers.Conv2D(filters=filters, kernel_size=[1, nchan], activation='elu')) model.add(layers.Permute((3, 1, 2), name="second_permute")) model.add( layers.AveragePooling2D(pool_size=(1, 71), strides=(1, 15), name="pooling")) model.add(layers.Dropout(0.75)) model.add(layers.Flatten()) model.add(layers.Dense(3)) model.add(layers.Activation('softmax')) model.compile(loss=losses.CategoricalCrossentropy(), optimizer=optimizers.Adam(), metrics=['accuracy'], run_eagerly=False) return model
def define_1DCNN(nchan, L, Fs): model = tf.keras.Sequential() model.add(layers.InputLayer((L, nchan), batch_size=None)) model.add(layers.Conv1D(filters=30, kernel_size=64, padding="causal")) model.add(layers.LayerNormalization()) model.add(layers.Activation('elu')) model.add(layers.AveragePooling1D(pool_size=(2))) model.add(layers.Dropout(0.2)) model.add(layers.Conv1D(filters=15, kernel_size=32, padding="causal")) model.add(layers.LayerNormalization()) model.add(layers.Activation('elu')) model.add(layers.AveragePooling1D(pool_size=(2))) model.add(layers.Dropout(0.3)) model.add(layers.Conv1D(filters=10, kernel_size=16, padding="causal")) model.add(layers.LayerNormalization()) model.add(layers.Activation('elu')) model.add(layers.AveragePooling1D(pool_size=(2))) model.add(layers.Dropout(0.4)) model.add(layers.Flatten()) model.add(layers.Dense(15, activation="tanh")) model.add(layers.LayerNormalization()) model.add(layers.Dense(3)) model.add(layers.Activation('softmax')) model.compile(loss=losses.CategoricalCrossentropy(), optimizer=optimizers.Adam(), metrics=['accuracy'], run_eagerly=False) return model
def cnn_network(opts): model = models.Sequential() model.add( layers.InputLayer(input_shape=(opts['siz'], opts['siz'], 1), name='input')) model.add( layers.Conv2D(opts['F1N'], (opts['F1S'], opts['F1S']), padding='same', name='conv_1', activation='relu')) model.add(layers.BatchNormalization(name='BN_1')) model.add(layers.MaxPooling2D(pool_size=2, strides=2)) model.add( layers.Conv2D(opts['F2N'], (opts['F2S'], opts['F2S']), strides=2, padding='same', name='conv_2', activation='relu')) model.add(layers.BatchNormalization(name='BN_2')) model.add(layers.MaxPooling2D(pool_size=2, strides=2)) model.add( layers.Conv2D(opts['F3N'], (opts['F3S'], opts['F3S']), padding='same', name='conv_3', activation='relu')) model.add(layers.BatchNormalization(name='BN_3')) model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu', name='dense_1')) model.add(layers.Dense(2, name='dense_2', activation='softmax')) model.compile( optimizer=tf.keras.optimizers.SGD(learning_rate=opts['lr'], momentum=0.9), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy']) return model
def fit(self, X, y=None): kernel_size = self.kernel_size filters = self.filters optimizer = self.optimizer epochs = self.epochs # Define input shapes self.n_steps = X.shape[1] X = X.reshape((X.shape[0], X.shape[1], self.n_features)) self.labels, ids = np.unique(y, return_inverse=True) y_cat = to_categorical(ids) num_classes = y_cat.shape[1] self.model = Sequential() self.model.add(layers.InputLayer(input_shape=(self.n_steps, self.n_features))) self.model.add(layers.Conv1D(100, 6, activation='relu')) self.model.add(layers.Conv1D(100, 6, activation='relu')) self.model.add(layers.MaxPooling1D(3)) self.model.add(layers.Conv1D(160, 6, activation='relu')) self.model.add(layers.Conv1D(160, 6, activation='relu')) self.model.add(layers.GlobalAveragePooling1D(name='G_A_P_1D')) self.model.add(layers.Dropout(0.5)) self.model.add(layers.Dense(num_classes)) self.model.add(layers.Activation('softmax')) self.model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=["categorical_accuracy"]) self.model.fit(X, y_cat, epochs=epochs, verbose=False)
def get_model(bidirectional = False, seqModelType = "SimpleRNN", RNNunits = 32): model = keras.Sequential() model.add(layers.InputLayer(input_shape=(None,s))) if seqModelType == "HMM": seqLayer = HMMLayer(5, 15) # (10,15) is better than (5,11) elif seqModelType == "LSTM": seqLayer = layers.LSTM(RNNunits) elif seqModelType == "GRU": seqLayer = layers.GRU(RNNunits) elif seqModelType == "SimpleRNN": seqLayer = layers.SimpleRNN(RNNunits) else: sys.exit("unknown sequence model type " + seqModelType) if bidirectional: seqLayer = layers.Bidirectional(seqLayer) model.add(seqLayer) model.add(layers.Dense(1, activation='sigmoid')) lr = 1e-3 #if seqModelType == "HMM": # lr = 1e-2 print (f"lr={lr}") model.compile(optimizer = tf.keras.optimizers.Adam(learning_rate = lr), loss = tf.keras.losses.BinaryCrossentropy(), metrics = ["accuracy"]) return model
def print_model_architecture(): input_layer = layers.InputLayer(input_shape=[FEATURES_COUNT, 32, 1], batch_size=BATCH_SIZE) model = create_model(input_layer) print(model.summary())
def rnn(n_outputs, window_size): # 1-layer, basic model, doesn't work very well... m = Sequential() m.add(layers.InputLayer(input_shape=(window_size, 1))) m.add( layers.SimpleRNN(units=64, activation='tanh', use_bias=True, kernel_initializer='glorot_uniform', recurrent_initializer='orthogonal', bias_initializer='zeros', kernel_regularizer=None, recurrent_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, recurrent_constraint=None, bias_constraint=None, dropout=0.5, recurrent_dropout=0.2, return_sequences=False, return_state=False, go_backwards=False, stateful=False, unroll=False)) m.add(layers.BatchNormalization(name='batch_norm_1')) # last layer m.add(layers.Dense(n_outputs, activation='sigmoid', name='output')) return m
def __init__(self, input_shape, nclass): super(AlexNet, self).__init__() self.inputlayer = k_layers.InputLayer(input_shape=input_shape, name='inputlayer') self.conv1 = k_layers.Conv2D(8, (3, 3), strides=(1, 1), name='conv1', padding='same', activation='relu') self.conv2 = k_layers.Conv2D(16, (3, 3), strides=(1, 1), name='conv2', padding='same', activation='relu') self.conv3 = k_layers.Conv2D(32, (3, 3), strides=(1, 1), name='conv3', padding='same', activation='relu') self.conv4 = k_layers.Conv2D(64, (3, 3), strides=(1, 1), name='conv4', padding='same', activation='relu') self.conv5 = k_layers.Conv2D(64, (3, 3), strides=(1, 1), name='conv5', padding='same', activation='relu') self.maxpool1 = k_layers.MaxPool2D(name='maxpool1', strides=(2, 2)) self.maxpool2 = k_layers.MaxPool2D(name='maxpool2', strides=(2, 2)) self.maxpool3 = k_layers.MaxPool2D(name='maxpool3', strides=(2, 2)) self.maxpool4 = k_layers.MaxPool2D(name='maxpool4', strides=(2, 2)) self.maxpool5 = k_layers.MaxPool2D(name='maxpool5', strides=(2, 2)) self.bnlze1 = k_layers.BatchNormalization(name='bn1') self.bnlze2 = k_layers.BatchNormalization(name='bn2') self.bnlze3 = k_layers.BatchNormalization(name='bn3') self.bnlze4 = k_layers.BatchNormalization(name='bn4') self.bnlze5 = k_layers.BatchNormalization(name='bn5') self.flt = k_layers.Flatten() self.fc1 = k_layers.Dense(64, name='fc1', activation='relu') self.fc2 = k_layers.Dense(128, name='fc2', activation='relu') self.fc3 = k_layers.Dense(nclass, name='outlayer', activation='softmax')
def __init__(self, input_shape): self.model = models.Sequential([ layers.InputLayer(input_shape=input_shape), layers.experimental.preprocessing.Rescaling(1. / 255), # layers.experimental.preprocessing.RandomFlip("horizontal_and_vertical"), # layers.experimental.preprocessing.RandomRotation(0.5), # layers.experimental.preprocessing.RandomContrast(0.5), # layers.experimental.preprocessing.RandomTranslation(height_factor=0.3, width_factor=0.3), # layers.experimental.preprocessing.RandomZoom(height_factor=0.3), # layers.experimental.preprocessing.RandomCrop(128,128), ]) #use preprocessing to make dataset larger #128x128x3 self.model.add(layers.Conv2D(8, 13, activation='relu')) self.model.add(layers.BatchNormalization()) self.model.add(layers.Dropout(0.2)) #116x116x8 self.model.add(layers.AveragePooling2D(pool_size=2)) #58x58x8 self.model.add(layers.Conv2D(16, 11, activation='relu')) #48x48x16 self.model.add(layers.AveragePooling2D(pool_size=2)) #24x24x16 self.model.add(layers.Flatten()) self.model.add(layers.Dense(128, activation='relu')) self.model.add(layers.Dense(2, activation='softmax')) self.optimizer = optimizers.Adam(lr=0.001) self.loss = losses.CategoricalCrossentropy() self.model.compile(loss=self.loss, optimizer=self.optimizer, metrics=['accuracy'])
def decoder_x(self): layers = [ tfkl.InputLayer(input_shape=(self.latent_dim, )), # Expand the dimensions using Dense layer and prepare for de-convolution tfkl.Dense(7 * 7 * 32, activation='relu'), # Reshape the flattened representation into a 3D, so that de-convolution # can be successfully applied tfkl.Reshape(target_shape=(7, 7, 32)), tfkl.Conv2DTranspose(filters=64, kernel_size=3, strides=2, padding='same', activation='relu'), tfkl.Conv2DTranspose(filters=32, kernel_size=3, strides=2, padding='same', activation='relu'), # note that no activation is required in the final layer as we will # take care of that in the loss function. tfkl.Conv2DTranspose(filters=1, kernel_size=3, strides=1, padding='same') ] return tfk.Sequential(layers)
def CNN(shape, num_classes: int): """Returns a CNN model used in cot """ model = models.Sequential() model.add(layers.InputLayer(input_shape=shape)) model.add(layers.Conv2D(128, (3, 3), activation=lrelu, padding="valid")) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(128, (3, 3), activation=lrelu, padding="valid")) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(128, (3, 3), activation=lrelu, padding="valid")) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D((2, 2), strides=2)) model.add(layers.Dropout(rate=0.25)) model.add(layers.Conv2D(256, (3, 3), activation=lrelu, padding="valid")) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(256, (3, 3), activation=lrelu, padding="valid")) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(256, (3, 3), activation=lrelu, padding="valid")) model.add(layers.BatchNormalization()) model.add(layers.MaxPooling2D((2, 2), strides=2)) model.add(layers.Dropout(rate=0.25)) model.add(layers.Conv2D(512, (3, 3), activation=lrelu, padding="valid")) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(256, (3, 3), activation=lrelu, padding="same")) model.add(layers.BatchNormalization()) model.add(layers.Conv2D(128, (3, 3), activation=lrelu, padding="same")) model.add(layers.BatchNormalization()) model.add(layers.AveragePooling2D(pool_size=1, padding="valid")) model.add(layers.Flatten()) model.add(layers.Dense(128, activation=tf.nn.relu)) model.add(layers.Dense(num_classes, activation=tf.nn.softmax)) return model
def __init__(self): (self.train_X, self.train_y), (self.test_X, self.test_y) = mnist.load_data() self.image_input_layer = layers.InputLayer(input_shape=(28, 28, 1)) self.convolution2d_layer = layers.Conv2D( 20, use_bias=True, strides=(1, 1), activation='relu', padding='same', kernel_size=(5, 5), kernel_initializer=initializers.random_normal(mean=0, stddev=0.01, seed=None)) self.max_pooling2d_layer = layers.MaxPooling2D(strides=(2, 2), pool_size=(2, 2), padding='valid') self.fully_connected_layer1 = layers.Dense( 100, use_bias=True, activation='relu', kernel_initializer=initializers.random_normal(mean=0, stddev=0.01, seed=None)) self.fully_connected_layer2 = layers.Dense(10, use_bias=True, activation='softmax') self.optimizer = SGD(momentum=0.9, lr=0.001) self.history_list = list() self.score_list = list()
def get_decoder(): config = { "kernel_size": 3, "strides": 1, "padding": "same", "activation": "relu" } decoder = keras.Sequential([ layers.InputLayer((None, None, 512)), layers.Conv2D(filters=512, **config), layers.UpSampling2D(), layers.Conv2D(filters=256, **config), layers.Conv2D(filters=256, **config), layers.Conv2D(filters=256, **config), layers.Conv2D(filters=256, **config), layers.UpSampling2D(), layers.Conv2D(filters=128, **config), layers.Conv2D(filters=128, **config), layers.UpSampling2D(), layers.Conv2D(filters=64, **config), layers.Conv2D( filters=3, kernel_size=3, strides=1, padding="same", activation="sigmoid", ), ]) return decoder
def build_model(train_ds): """ Build the ML model. Sets up the desired layers and compiles the tf.keres model :param train_ds: The training dataset used for nomalisation and determining the input_shape """ # Get the input shape for the model for spectrogram, _ in train_ds.take(1): input_shape = spectrogram.shape[1:] print(f'Input shape: {input_shape}') # Normalisation Layer norm_layer = preprocessing.Normalization() norm_layer.adapt(train_ds.take(30).map(lambda x, _: x)) #Model layout model = models.Sequential([ layers.InputLayer(input_shape=input_shape), preprocessing.Resizing(32, 32), norm_layer, layers.Conv2D(60, 3, activation='relu'), #layers.Conv2D(30, 3, activation='relu'), #layers.Conv2D(30, 3, activation='relu'), #layers.Conv2D(30, 3, activation='relu'), layers.Flatten(), layers.Dense(30, activation='relu'), #layers.Dropout(0.1), layers.Dense(2), ]) return model
def target_model_fn(): """The architecture of the target (victim) model. The attack is white-box, hence the attacker is assumed to know this architecture too.""" model = tf.keras.models.Sequential() model.add(layers.InputLayer(input_shape=(WIDTH, HEIGHT, CHANNELS))) model.add(layers.Conv2D(32, (3, 3), activation="relu", padding="same")) model.add(layers.Conv2D(32, (3, 3), activation="relu")) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Dropout(0.25)) model.add(layers.Conv2D(64, (3, 3), activation="relu", padding="same")) model.add(layers.Conv2D(64, (3, 3), activation="relu")) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Dropout(0.25)) model.add(layers.Flatten()) model.add(layers.Dense(512, activation="relu")) model.add(layers.Dropout(0.5)) model.add(layers.Dense(NUM_CLASSES, activation="softmax")) model.compile("adam", loss="categorical_crossentropy", metrics=["accuracy"]) return model
def __init__(self): super().__init__() # stores the current probability of an image being augmented self.probability = tf.Variable(0.0) # the corresponding augmentation names from the paper are shown above each layer # the authors show (see figure 4), that the blitting and geometric augmentations # are the most helpful in the low-data regime self.augmenter = keras.Sequential( [ layers.InputLayer(input_shape=(image_size, image_size, 3)), # blitting/x-flip: layers.RandomFlip("horizontal"), # blitting/integer translation: layers.RandomTranslation( height_factor=max_translation, width_factor=max_translation, interpolation="nearest", ), # geometric/rotation: layers.RandomRotation(factor=max_rotation), # geometric/isotropic and anisotropic scaling: layers.RandomZoom(height_factor=(-max_zoom, 0.0), width_factor=(-max_zoom, 0.0)), ], name="adaptive_augmenter", )
def __init__(self, n_stages=4, filters=256, kernel_size=3): super().__init__() self.filters = filters self.kernel_size = kernel_size bn_axis = 3 # build model network self.layer_input = layers.InputLayer(input_shape=(15, 15, 3), name='input', dtype='float16') self.layer_conv0 = layers.Conv2D(self.filters, self.kernel_size, padding='same') self.layer_batch0 = layers.BatchNormalization(axis=bn_axis) self.layer_activ0 = layers.Activation('relu') # a list of resnet blocks self.layer_resBlocks = [ ResNetBlock(filters=self.filters, kernel_size=self.kernel_size) for _ in range(n_stages) ] # final evaluation head self.layer_final_conv = layers.Conv2D(1, (1, 1)) self.layer_final_batch = layers.BatchNormalization(axis=bn_axis) self.layer_final_activ = layers.Activation('relu') self.layer_flatten = layers.Flatten() self.layer_dense = layers.Dense(256, activation='relu') self.layer_res = layers.Dense(1, activation='tanh', name='result')
def build_network(self): c = self.config.cnn model = keras.Sequential() model.add( layers.InputLayer(input_shape=self.env.observation_space.shape)) # Scale the input values to be between 0 and 1 max_input = np.max(self.env.observation_space.high) model.add( layers.Lambda(lambda obs: tf.cast(obs, np.float32) / max_input)) # Create the conv layers for filters, kernel_size, strides in zip(c.filters, c.kernel_size, c.strides): layer = layers.Conv2D(filters, kernel_size, strides, activation='relu') model.add(layer) model.add(layers.Flatten()) model.add(layers.Dense(c.fc_size, activation='relu')) model.add(layers.Dense(self.n_actions)) return model
def __init__(self, config): super(Decoder, self).__init__() self.config = config self.dec = Sequential([ layers.InputLayer(input_shape=(self.config.latent_dim, )), layers.Dense(1024), layers.ReLU(), layers.Dense(4 * 4 * 64), layers.ReLU(), layers.Reshape((4, 4, 64)), layers.Conv2DTranspose(filters=64, kernel_size=4, strides=2, padding='same'), layers.ReLU(), layers.Conv2DTranspose(filters=32, kernel_size=4, strides=2, padding='same'), layers.ReLU(), layers.Conv2DTranspose(filters=1, kernel_size=4, strides=2, padding='same'), ])
def __init__(self, name="kid", **kwargs): super().__init__(name=name, **kwargs) # KID is estimated per batch and is averaged across batches self.kid_tracker = keras.metrics.Mean() # a pretrained InceptionV3 is used without its classification layer # transform the pixel values to the 0-255 range, then use the same # preprocessing as during pretraining self.encoder = keras.Sequential( [ layers.InputLayer(input_shape=(image_size, image_size, 3)), layers.Rescaling(255.0), layers.Resizing(height=kid_image_size, width=kid_image_size), layers.Lambda( keras.applications.inception_v3.preprocess_input), keras.applications.InceptionV3( include_top=False, input_shape=(kid_image_size, kid_image_size, 3), weights="imagenet", ), layers.GlobalAveragePooling2D(), ], name="inception_encoder", )
def getGenerator(self, CODE_SIZE): generator = Sequential() generator.add(L.InputLayer([CODE_SIZE],name='gen_input_layer')) generator.add(L.Dense(10*16*16, activation='elu', name = 'gen_Dense1')) generator.add(L.Reshape((16,16,10), name = 'gen_reshape')) generator.add(L.Conv2DTranspose(16,kernel_size=(9,9),activation='elu', name = 'gen_Conv9_1')) generator.add(L.Conv2DTranspose(16,kernel_size=(9,9),activation='elu', name = 'gen_Conv9_2')) generator.add(L.Conv2DTranspose(16,kernel_size=(9,9),activation='elu', name = 'gen_Conv9_3')) generator.add(L.Conv2DTranspose(16,kernel_size=(9,9),activation='elu', name = 'gen_Conv9_4')) generator.add(L.UpSampling2D(size=(2,2), name = 'gen_upsample1')) generator.add(L.Conv2DTranspose(16,kernel_size=(7,7),activation='elu', name = 'gen_Conv7_1')) generator.add(L.Conv2DTranspose(16,kernel_size=(7,7),activation='elu', name = 'gen_Conv7_2')) generator.add(L.UpSampling2D(size=(2,2), name = 'gen_upsample2')) generator.add(L.Conv2DTranspose(8,kernel_size=(5,5),activation='elu', name = 'gen_Conv5_1')) generator.add(L.Conv2DTranspose(8,kernel_size=(5,5),activation='elu', name = 'gen_Conv5_2')) generator.add(L.UpSampling2D(size=(2,2), name = 'gen_upsample3')) generator.add(L.Conv2DTranspose(8,kernel_size=(3,3),activation='elu', name = 'gen_Conv3_1')) generator.add(L.Conv2DTranspose(8,kernel_size=(3,3),activation='elu', name = 'gen_Conv3_2')) generator.add(L.Conv2D(8,kernel_size=3,activation='relu', name = 'gen_Conv3_3')) generator.add(L.Conv2D(3,kernel_size=3,activation='tanh', name = 'gen_Conv3_4')) return generator
def define_the_model(self): # defineste autoencoderul self.model = tf.keras.models.Sequential([ layers.InputLayer(input_shape=(self.data_set.network_input_size[0], self.data_set.network_input_size[1], 1)), ... ]) # afiseaza arhitectura modelului self.model.summary()
def build_model(self): model = tf.keras.Sequential() model.add(layers.InputLayer(input_shape = self.env.observation_space.shape)) model.add(layers.Dense(24, activation = "relu")) model.add(layers.Dense(24, activation = "relu")) model.add(layers.Dense(self.env.action_space.n, activation = "linear")) model.compile(optimizer = keras.optimizers.SGD(learning_rate = self.step_size, momentum = 0.5), loss = "mse") return model
def classify_model(x): model = Sequential() model.add(layers.InputLayer(input_shape=x.shape[1:])) model.add(layers.Dense(128, activation="relu")) model.add(layers.Dense(128, activation="relu")) model.add(layers.Dense(5, activation="softmax")) return model
def _build_layers_v2(self, input_dict, num_outputs, options): self.model = Sequential() self.model.add(layers.InputLayer(input_tensor=input_dict["obs"], input_shape=(4,))) self.model.add(layers.Dense(4, name='l1', activation='relu')) self.model.add(layers.Dense(10, name='l2', activation='relu')) self.model.add(layers.Dense(10, name='l3', activation='relu')) self.model.add(layers.Dense(10, name='l4', activation='relu')) self.model.add(layers.Dense(2, name='l5', activation='relu')) return self.model.get_layer("l5").output, self.model.get_layer("l4").output