def _build_model(self): model = Sequential() model.add(InputLayer(self.input_shape)) model.add( Conv2D(filters=64, kernel_size=1, data_format='channels_first')) model.add(self.activation()) model.add( Conv2D(filters=64, kernel_size=1, data_format='channels_first')) model.add(self.activation()) model.add( Conv2D(filters=16, kernel_size=1, data_format='channels_first')) model.add(self.activation()) model.add(Flatten()) model.add(Dense(units=256)) model.add(self.activation()) if self.dropout_rate > 0: model.add(Dropout(self.dropout_rate)) model.add(Dense(units=256)) model.add(self.activation()) if self.dropout_rate > 0: model.add(Dropout(self.dropout_rate)) model.add(Dense(units=128)) model.add(self.activation()) model.add(Dense(units=3)) return model
def create_layer(self, layer): layer_type = layer.type if layer_type == Layers.CONV: return Conv2D(filters=layer.filters, kernel_size=layer.kernel_size, strides=layer.strides, padding='same') elif layer_type == Layers.ACTIVATION: return Activation(layer.func) elif layer_type == Layers.INPUT: return InputLayer(input_shape=layer.shape) elif layer_type == Layers.DENSE: return Dense(units=layer.nodes) elif layer_type == Layers.FLATTEN: return Flatten() elif layer_type == Layers.DROPOUT: return Dropout(rate=layer.rate) elif layer_type == Layers.POOLING: if layer.operation == 'max': return MaxPooling2D(pool_size=layer.pool_size, strides=layer.strides, padding='same') elif layer.operation == 'average': return AveragePooling2D(pool_size=layer.pool_size, strides=layer.strides, padding='same') elif layer_type == Layers.BATCH_NORM: return BatchNormalization(momentum=layer.momentum)
def lstm(x_dim) -> Model: model = Sequential() model.add(InputLayer(input_shape=(x_dim, 1))) model.add(LSTM(256, return_sequences=True)) model.add(SeqWeightedAttention()) return model
def handle(self, *args, **kwargs): os.makedirs("tmp", exist_ok=True) version = kwargs['mlversion'] path = ccp.weights_for("density", version) output = kwargs['output'] print("Converting {0} to {1}".format(path, output)) model = load_model(path) # Create a new input layer to replace the (None,None,3) input layer input_layer = InputLayer(input_shape=(675, 900, 3), name="input_1") # Save intermediary_path = "tmp/reshaped_model.h5" model.layers[0] = input_layer model.save(intermediary_path) # Convert coreml_model = coremltools.converters.keras.convert( intermediary_path, input_names=['input_1'], image_input_names=['input_1'], output_names=['density_map']) # Set model metadata coreml_model.author = 'Dimitri Roche' coreml_model.short_description = 'Generates a density map with the crowd estimate as the sum of pixels' coreml_model.input_description[ 'input_1'] = 'Image to calculate density map' coreml_model.output_description[ 'density_map'] = 'Density map where the sum of pixels is crowd count' coreml_model.save(output)
def __init__(self, props) -> None: print(props.dense) self.props = props self.model = Sequential() self.model.add(InputLayer(input_shape=props.input_shape)) self.model.add(BatchNormalization()) self.model.add( Conv2D(props.output_classes, padding="same", strides=(props.stride_x, props.stride_y), kernel_size=(props.kernel_x, props.kernel_y))) self.model.add(MaxPool2D(padding="same")) self.model.add(Flatten()) self.model.add(Dense(props.dense)) self.model.add(Dense(props.output_classes)) self.tf_cb = callbacks.TensorBoard( log_dir='./logs/{}'.format(props.id()), batch_size=props.batch_size, write_graph=False, ) self.model.compile( loss=categorical_crossentropy, optimizer=props.optimizer, metrics=props.metrics, )
def trainV2(X, Y, imageShape): model = Sequential() model.add(InputLayer(input_shape=(3, ))) model.add(Dense(4, activation='relu')) model.add(Dense(5, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) tensor_board = TensorBoard( 'model/fullyConnectedLayers/tensorboardFullyConnectedModel') model.fit(X, Y, batch_size=8, epochs=10000, verbose=1, validation_split=0.2, shuffle=True, callbacks=[tensor_board]) model.save('model/fullyConnectedLayers/fullyConnectedSavedModel/annV2.h5', include_optimizer='true')
def create_empty_model(): """ Creation of empty model """ model = Sequential() model.add(InputLayer(input_shape=(106,))) model.add(Dense(53)) model.add(Dense(2)) model.compile(loss='mse', optimizer='adam', metrics=['accuracy']) return model
def create_model(self): model = Sequential() model.add( InputLayer(batch_input_shape=(1, self.maze.size[0] * self.maze.size[1]))) model.add(Dense(4, activation='sigmoid')) model.add(Dense(len(self.map2str), activation='linear')) model.compile(loss='mse', optimizer='adam', metrics=['mae']) model.summary() return model
def _build_encoder(): model = Sequential(name="encoder") model.add(InputLayer(input_shape=(None, None, 1))) model.add(Conv2D(64, (3, 3), activation="relu", padding="same", strides=2)) model.add(Conv2D(128, (3, 3), activation="relu", padding="same")) model.add(Conv2D(128, (3, 3), activation="relu", padding="same", strides=2)) model.add(Conv2D(256, (3, 3), activation="relu", padding="same")) model.add(Conv2D(256, (3, 3), activation="relu", padding="same", strides=2)) model.add(Conv2D(512, (3, 3), activation="relu", padding="same")) model.add(Conv2D(512, (3, 3), activation="relu", padding="same")) model.add(Conv2D(256, (3, 3), activation="relu", padding="same")) return model
def _build_encoder(): model = Sequential(name='encoder') model.add(InputLayer(input_shape=(None, None, 1))) model.add(Conv2D(64, (3, 3), activation='relu', padding='same', strides=2)) model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(Conv2D(128, (3, 3), activation='relu', padding='same', strides=2)) model.add(Conv2D(256, (3, 3), activation='relu', padding='same')) model.add(Conv2D(256, (3, 3), activation='relu', padding='same', strides=2)) model.add(Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(Conv2D(512, (3, 3), activation='relu', padding='same')) model.add(Conv2D(256, (3, 3), activation='relu', padding='same')) return model
def _build_decoder(encoding_depth): model = Sequential(name='decoder') model.add(InputLayer(input_shape=(None, None, encoding_depth))) model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(UpSampling2D((2, 2))) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(Conv2D(2, (3, 3), activation='tanh', padding='same')) model.add(UpSampling2D((2, 2))) return model
def _build_decoder(encoding_depth): model = Sequential(name="decoder") model.add(InputLayer(input_shape=(None, None, encoding_depth))) model.add(Conv2D(128, (3, 3), activation="relu", padding="same")) model.add(UpSampling2D((2, 2))) model.add(Conv2D(64, (3, 3), activation="relu", padding="same")) model.add(Conv2D(64, (3, 3), activation="relu", padding="same")) model.add(UpSampling2D((2, 2))) model.add(Conv2D(32, (3, 3), activation="relu", padding="same")) model.add(Conv2D(2, (3, 3), activation="tanh", padding="same")) model.add(UpSampling2D((2, 2))) return model
def main(batch_size=8, epochs=300, images_per_epoch=8192, validation_images=1024, image_size=224, color_space='yuv', train_data_dir='/mnt/bolbol/raw-data/train', valid_data_dir='/mnt/bolbol/raw-data/validation', model_save_dir='finetune_models'): """ FineTune VGG16 to work on black and white images that are passed as inputs to colorizer """ data_mapper = get_mapper(color_space=color_space, classifier=False) ''' Modify VGG16 to work with greyscale images ''' vgg = VGG16() for layer in vgg.layers: layer.trainable = False vgg.get_layer(name='block1_conv1').trainable = True vgg.get_layer(name='block1_conv2').trainable = True vgg.get_layer(name='block2_conv1').trainable = True vgg.get_layer(name='block2_conv2').trainable = True needed_layers = vgg.layers[2:] model = Sequential() model.add(InputLayer(input_shape=(image_size, image_size, 1), name='gray')) model.add(Conv2D(filters=64, kernel_size=3, padding='same')) for layer in needed_layers: model.add(layer) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.summary() train_generator = ImageDataGenerator().flow_from_directory(directory=train_data_dir, interpolation='bilinear', target_size=(image_size, image_size), batch_size=batch_size, color_mode='rgb', class_mode='sparse') valid_generator = ImageDataGenerator().flow_from_directory(directory=valid_data_dir, interpolation='bilinear', target_size=(image_size, image_size), batch_size=batch_size, color_mode='rgb', class_mode='sparse') train_generator = ImageGenerator(rgb_generator=train_generator, workers=4, input_processing_function=data_mapper.rgb_to_colorizer_input) valid_generator = ImageGenerator(rgb_generator=valid_generator, workers=4, input_processing_function=data_mapper.rgb_to_colorizer_input) # Configure model checkpoints model_save_path = os.path.join(model_save_dir, 'vgg-{epoch:02d}-{val_acc:.2f}-{val_loss:.2f}.hdf5') if not os.path.exists(model_save_dir): os.mkdir(model_save_dir) ''' FineTune VGG ''' model.fit_generator(generator=train_generator, steps_per_epoch=images_per_epoch // batch_size, epochs=epochs, validation_data=valid_generator, validation_steps=validation_images // batch_size, callbacks=[EarlyStopping(patience=5), ModelCheckpoint(filepath=model_save_path, monitor='val_acc', save_best_only=True)])
def trainV1(X, Y, imageShape, model_name): if model_name is None or model_name is "": model = Sequential() model.add( InputLayer(input_shape=(imageShape['rows'], imageShape['columns'], imageShape['channels']))) model.add(Flatten()) model.add(Dense( 4096, activation='relu', )) model.add(Dropout(0.5)) model.add(Dense(4096, activation='relu')) model.add(Dense( 4096, activation='relu', )) model.add(Dropout(0.5)) model.add(Dense(4096, activation='relu')) model.add(Dense(16, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) else: print("loading the saved model") model = keras.models.load_model( 'model/fullyConnectedLayers/fullyConnectedSavedModel/' + model_name) model.summary() tensor_board = TensorBoard( 'model/fullyConnectedLayers/tensorboardFullyConnectedModel') model.fit(X, Y, batch_size=32, epochs=1, verbose=1, validation_split=0.1, shuffle=True, callbacks=[tensor_board]) model.save('model/fullyConnectedLayers/fullyConnectedSavedModel/' + "annV1.h5", include_optimizer='true') print("model saved")
def to_fully_conv(model): """ This methods converts a sequential model to a fully convolutional model.""" new_model = Sequential() input_layer = InputLayer(input_shape=(None, None, 3), name="input_new") new_model.add(input_layer) for layer in model.layers: if "Flatten" in str(layer): flattened_ipt = True f_dim = layer.input_shape elif "Dense" in str(layer): input_shape = layer.input_shape output_dim = layer.get_weights()[1].shape[0] W, b = layer.get_weights() if flattened_ipt: shape = (f_dim[1], f_dim[2], f_dim[3], output_dim) new_W = W.reshape(shape) new_layer = Convolution2D(output_dim, (f_dim[1], f_dim[2]), strides=(1, 1), activation=layer.activation, padding='valid', weights=[new_W, b]) flattened_ipt = False else: shape = (1, 1, input_shape[1], output_dim) new_W = W.reshape(shape) new_layer = Convolution2D(output_dim, (1, 1), strides=(1, 1), activation=layer.activation, padding='valid', weights=[new_W, b]) else: new_layer = layer new_model.add(new_layer) return new_model
def build(input_shape, classes): model = Sequential() model.add(InputLayer(input_shape=input_shape)) model.add(Conv2D(16, (8, 20), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Conv2D(32, (4, 10), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) # models.add(Conv2D(64, (4, 10), activation='relu')) # models.add(MaxPooling2D(pool_size=(2, 2))) # models.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(classes, activation='softmax')) return model
def __call__(self, *args, **kwargs): # Share weights of character-level embedding embedding_layer = TimeDistributed(Sequential([ InputLayer(input_shape=(self.chars_per_word, )), Embedding(input_dim=self.input_dim, output_dim=self.embedding_size, input_length=self.chars_per_word, mask_zero=True), Bidirectional(GRU(units=24)) ]), name='CharEmbedding') inputs = [ Input(shape=(shape, self.chars_per_word)) for shape in self.shapes ] embeddings = [embedding_layer(char_input) for char_input in inputs] return inputs, embeddings
def nn(shape, no_classes): """neural network model""" model = Sequential() model.add(InputLayer(input_shape=shape)) model.add(Dense(100)) model.add(Activation('relu')) model.add(Dense(20)) model.add(Activation('relu')) model.add(Dense(no_classes)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer=sgd(lr=0.01), metrics=['categorical_accuracy']) return model
def create_model(): model = Sequential() model.add( InputLayer(batch_input_shape=(1, NUMBER_OF_ROWS * NUMBER_OF_COLUMNS), name='input')) model.add( Dense(NUMBER_OF_COLUMNS * NUMBER_OF_ROWS * 2, input_shape=(NUMBER_OF_ROWS * NUMBER_OF_COLUMNS, ), activation=sigmoid, name='hidden1')) model.add( Dense(NUMBER_OF_COLUMNS * 2, input_shape=(NUMBER_OF_COLUMNS * NUMBER_OF_ROWS * 2, ), activation=sigmoid, name='hidden2')) model.add( Dense(NUMBER_OF_COLUMNS, input_shape=(NUMBER_OF_COLUMNS * 2, ), activation=linear, name='output')) model.compile(loss=mean_squared_error, optimizer=adam(), metrics=[mean_absolute_error]) return model
def transform_layer(layer, next_layer, queue_ctr, flattened): print("transform {} (next = {})".format(layer, next_layer)) new_layers = [] skip_next = False if isinstance(layer, InputLayer): new_layers.append(InputLayer.from_config(layer.get_config())) elif isinstance(layer, Conv2D) and not isinstance(layer, DepthwiseConv2D): conf = layer.get_config() act = conf['activation'] # if the next layer is a pooling layer, create a fused activation maxpool_params = None if slalom and isinstance(next_layer, MaxPooling2D): mp = next_layer assert (layer.activation == relu) maxpool_params = mp.get_config() skip_next = True act_layer = None if act != "linear": conf['activation'] = "linear" if slalom and isinstance(next_layer, GlobalAveragePooling2D): assert layer.activation in [relu, relu6] act = "avgpool" + act skip_next = True act_layer = ActivationQ(act, bits_w, bits_x, maxpool_params=maxpool_params, log=log, quantize=quantize, slalom=slalom, slalom_integrity=slalom_integrity, slalom_privacy=slalom_privacy, sgxutils=sgxutils, queue=None if queues is None else queues[queue_ctr]) queue_ctr += 1 conf['bits_w'] = bits_w conf['bits_x'] = bits_x conf['log'] = log conf['quantize'] = quantize conf['slalom'] = slalom conf['slalom_integrity'] = slalom_integrity conf['slalom_privacy'] = slalom_privacy conf['sgxutils'] = sgxutils new_layer = Conv2DQ.from_config(conf) new_layers.append(new_layer) layer_map[new_layer] = layer if act_layer is not None: new_layers.append(act_layer) elif isinstance(layer, DepthwiseConv2D): conf = layer.get_config() assert conf['activation'] == "linear" conf['bits_w'] = bits_w conf['bits_x'] = bits_x conf['log'] = log conf['quantize'] = quantize conf['slalom'] = slalom conf['slalom_integrity'] = slalom_integrity conf['slalom_privacy'] = slalom_privacy conf['sgxutils'] = sgxutils new_layer = DepthwiseConv2DQ.from_config(conf) new_layers.append(new_layer) layer_map[new_layer] = layer elif isinstance(layer, Dense): conf = layer.get_config() act = conf['activation'] act_layer = None if act != "linear": conf['activation'] = "linear" act_layer = ActivationQ(act, bits_w, bits_x, log=log, quantize=quantize, slalom=slalom, slalom_integrity=slalom_integrity, slalom_privacy=slalom_privacy, sgxutils=sgxutils, queue=None if queues is None else queues[queue_ctr]) queue_ctr += 1 conf['bits_w'] = bits_w conf['bits_x'] = bits_x conf['log'] = log conf['quantize'] = quantize conf['slalom'] = slalom conf['slalom_integrity'] = slalom_integrity conf['slalom_privacy'] = slalom_privacy conf['sgxutils'] = sgxutils # replace the dense layer by a pointwise convolution if verif_preproc: del conf['units'] conf['filters'] = layer.units conf['kernel_size'] = 1 if not flattened: h_in = int(layer.input_spec.axes[-1]) new_layers.append(Reshape((1, 1, h_in))) flattened = True new_layer = Conv2DQ.from_config(conf) new_layers.append(new_layer) layer_map[new_layer] = layer else: new_layer = DenseQ.from_config(conf) new_layers.append(new_layer) layer_map[new_layer] = layer if act_layer is not None: new_layers.append(act_layer) elif isinstance(layer, BatchNormalization): pass elif isinstance(layer, MaxPooling2D): assert (not slalom or not slalom_privacy) new_layers.append(MaxPooling2D.from_config(layer.get_config())) elif isinstance(layer, AveragePooling2D): assert (not slalom or not slalom_privacy) new_layers.append(AveragePooling2D.from_config(layer.get_config())) new_layers.append(Lambda(lambda x: K.round(x))) elif isinstance(layer, Activation): assert layer.activation in [relu6, relu, softmax] queue = None if queues is None else queues[queue_ctr] queue_ctr += 1 act_func = "relu6" if layer.activation == relu6 else "relu" if layer.activation == relu else "softmax" if slalom and isinstance(next_layer, GlobalAveragePooling2D): #assert layer.activation == relu6 act_func = "avgpoolrelu6" skip_next = True maxpool_params = None if slalom and (isinstance(next_layer, MaxPooling2D) or isinstance(next_layer, AveragePooling2D)): mp = next_layer assert (layer.activation == relu) maxpool_params = mp.get_config() skip_next = True new_layers.append(ActivationQ(act_func, bits_w, bits_x, log=log, maxpool_params=maxpool_params, quantize=quantize, slalom=slalom, slalom_integrity=slalom_integrity, slalom_privacy=slalom_privacy, sgxutils=sgxutils, queue=queue)) elif isinstance(layer, ZeroPadding2D): if quantize: # merge with next layer conv = next_layer assert isinstance(conv, Conv2D) or isinstance(conv, DepthwiseConv2D) assert conv.padding == 'valid' conv.padding = 'same' else: new_layers.append(ZeroPadding2D.from_config(layer.get_config())) elif isinstance(layer, Flatten): if not verif_preproc: new_layers.append(Flatten.from_config(layer.get_config())) elif isinstance(layer, GlobalAveragePooling2D): assert not slalom conf = layer.get_config() conf['bits_w'] = bits_w conf['bits_x'] = bits_x conf['log'] = log conf['quantize'] = quantize new_layers.append(GlobalAveragePooling2DQ.from_config(conf)) elif isinstance(layer, Reshape): new_layers.append(Reshape.from_config(layer.get_config())) elif isinstance(layer, Dropout): pass elif isinstance(layer, ResNetBlock): #assert not slalom path1 = [] path2 = [] for l in layer.path1: lq, queue_ctr, _, _ = transform_layer(l, None, queue_ctr, flattened) path1.extend(lq) for l in layer.path2: lq, queue_ctr, _, _ = transform_layer(l, None, queue_ctr, flattened) path2.extend(lq) [actq], queue_ctr, flattened, skip_next = transform_layer(layer.merge_act, next_layer, queue_ctr, flattened) new_layer = ResNetBlock(layer.kernel_size, layer.filters, layer.stage, layer.block, layer.identity, layer.strides, path1=path1, path2=path2, merge_act=actq, quantize=quantize, bits_w=bits_w, bits_x=bits_x, slalom=slalom, slalom_integrity=slalom_integrity, slalom_privacy=slalom_privacy) new_layers.append(new_layer) else: raise AttributeError("Don't know how to handle layer {}".format(layer)) return new_layers, queue_ctr, flattened, skip_next
def autoencode(pipe: Pipe, layer_config: List[Dict], from_file: str, store_model: str, loss: str, optimiser: str, epochs: int, batch_size: int, shuffle: bool, validation_split: float, adjust_weights: float, mode: str): """Build and train an autoencoder.""" import keras from keras import regularizers, Sequential, Input, Model from keras.callbacks import EarlyStopping, TensorBoard from keras.engine import InputLayer from keras.engine.saving import model_from_yaml, model_from_json from keras.layers import Dense from numpy.random.mtrand import seed from tensorflow import set_random_seed from lyner.keras_extras import SignalHandler seed(1) set_random_seed(2) matrix = pipe.matrix.copy() if matrix.isnull().values.any(): LOGGER.warning("Dropping rows containing nan values") matrix.dropna(how='any', inplace=True) def parse_layout(layer_conf): get_layer_type = lambda t: getattr(keras.layers, t, None) regdict = {'l1_l2': regularizers.l1_l2, 'l1': regularizers.l1, 'l2': regularizers.l2} lc = layer_conf.copy() layer_type = lc.get('type', None) if layer_type: lc['type'] = get_layer_type(layer_type) # TODO parse regularizers kernel_reg_type = lc.get('kernel_regularizer', None) if kernel_reg_type: if '(' in kernel_reg_type and ')' in kernel_reg_type: params = kernel_reg_type[kernel_reg_type.index('(') + 1:kernel_reg_type.index(')')] if '+' in params: params = params.split('+') else: params = [params] params = [float(p) for p in params] kernel_reg_type = kernel_reg_type[:kernel_reg_type.index('(')] lc['kernel_regularizer'] = regdict[kernel_reg_type](*params) return lc.pop('type'), int(lc.pop('n')), lc layout = [parse_layout(layer_conf) for layer_conf in layer_config] labels = matrix.columns.values.tolist() data = matrix.values shape = (data.shape[0],) data = data.transpose() if layout: encoding_dim = layout[-1][1] encoder = Sequential(name="encoder") encoder.add(InputLayer(shape, name="encoder_input")) for layer_num, (Layer, n_nodes, extra_args) in enumerate(layout): encoder.add(Layer(n_nodes, name=f"encoder_{layer_num}_{n_nodes}", **extra_args)) # kernel_regularizer=regularizers.l1_l2(0.001, 0.001), # kernel_regularizer=regularizers.l1(0.0001), decoder = Sequential(name="decoder") decoder.add(InputLayer((encoding_dim,), name="decoder_input")) for layer_num, (Layer, n_nodes, _) in enumerate(layout[::-1][1:]): decoder.add(Layer(n_nodes, name=f"decoder_{layer_num}_{n_nodes}")) decoder.add(Dense(shape[0], activation='linear', name="decoder_output")) input_layer = Input(shape=shape, name="autoencoder_input") encode_layer = encoder(input_layer) decode_layer = decoder(encode_layer) autoencoder = Model(input_layer, decode_layer) if store_model: if store_model.endswith('.yaml'): model_string = autoencoder.to_yaml() elif store_model.endswith('.json'): model_string = autoencoder.to_json() else: model_string = autoencoder.to_yaml() with open(store_model, 'wt') as writer: writer.write(model_string) elif from_file: with open(from_file, 'rt') as reader: model_string = '\n'.join(reader.readlines()) if from_file.endswith('.yaml'): autoencoder = model_from_yaml(model_string) elif from_file.endswith('.json'): autoencoder = model_from_json(model_string) # TODO set encoder and decoder correctly else: raise ValueError("No model specified. Use either of --layer-config or --from-file.") # from pprint import pprint # pprint(autoencoder.get_config()) autoencoder.compile(optimizer=optimiser, loss=loss, metrics=['mse'], ) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0.0000001, patience=50) sh = SignalHandler() autoencoder.fit(np.vsplit(data, 1), np.vsplit(data, 1), callbacks=[TensorBoard(log_dir='/tmp/autoencoder'), sh, early_stopping], epochs=epochs, batch_size=batch_size, validation_split=validation_split, shuffle=shuffle ) sh.uninit() class Autoencoder: def __init__(self, encoder=None, decoder=None): self._encoder = encoder self._decoder = decoder def inverse_transform(self, data): return self._decoder.predict(data).transpose() def transform(self, data): return self._encoder.predict(data).transpose() pipe.decomposition = Autoencoder(encoder, decoder) encoded_data = pipe.decomposition.transform(data) decoded_data = pipe.decomposition.inverse_transform(encoded_data.T) pre_error = ((data.T - decoded_data) ** 2).mean(axis=None) print(f"MSE: {pre_error}") pipe._index = pipe.matrix.index pipe._columns = pipe.matrix.columns if adjust_weights: quant = float(adjust_weights) for i, layer in enumerate(encoder.layers): W, b = layer.get_weights() low, median, high = np.quantile(W.flatten(), [quant, 0.5, 1 - quant]) W_low = W * (W < low) W_high = W * (W > high) selected_weights = W_low + W_high # oplot([Histogram(x=W.flatten()), Histogram(x=W[W < low].flatten()), Histogram(x=W[W > high].flatten())]) layer.set_weights([selected_weights, b]) break encoded_data = pipe.decomposition.transform(data) decoded_data = pipe.decomposition.inverse_transform(encoded_data.T) post_error = ((data.T - decoded_data) ** 2).mean(axis=None) print(f"MSE: {post_error}") if 'weights' == mode: layer = 0 layer_weights = encoder.layers[layer].get_weights() layer = encoder.layers[layer] if len(layer_weights) == 0: layer_weights = encoder.layers[0].get_weights() if len(layer_weights) >= 2: layer_weights = layer_weights[:-1] # last one is bias new_data = layer_weights[0] index = [f'Weight_{i}' for i in range(new_data.shape[0])] num_nodes = new_data.shape[1] columns = [f"{layer.name}_{i}" for i in range(num_nodes)] elif 'nodes' == mode: new_data = encoder.predict(np.vsplit(data, 1)).transpose() columns = labels index = [f"{mode}_{i}" for i in range(encoding_dim)] elif 'discard' == mode: W, b = encoder.layers[0].get_weights() W = np.sum(np.abs(W), axis=1) W[W != 0] = 1 print(f"Kept {np.sum(W)} weights") v: np.array = pipe.matrix.values new_data = (v.T * W).T columns = pipe.matrix.columns index = pipe.matrix.index else: raise ValueError(f"Unknown mode {mode}") pipe.matrix = pd.DataFrame(data=new_data, columns=columns, index=index, ) return
from keras.layers import Conv2D, MaxPooling2D, Activation, Flatten, Dense from keras.optimizers import SGD from examples.custom_optimiser import LRMultiplierSGD from examples.custom_weight_decay import add_weight_decay from examples.utils import getImageData num_classes = 10 x_train, y_train, x_test, y_test = getImageData('cifar10', num_classes) shape = x_train.shape[1:] kernel_init = keras.initializers.RandomNormal(stddev=0.05) model = Sequential() model.add(InputLayer(input_shape=(32, 32, 3))) # Unit 1 model.add( Conv2D(filters=32, kernel_size=(5, 5), kernel_initializer=kernel_init)) model.add(MaxPooling2D(padding='same')) model.add(Activation('relu')) # Unit 2 model.add( Conv2D(filters=32, kernel_size=(5, 5), kernel_initializer=kernel_init)) model.add(MaxPooling2D(padding='same')) model.add(Activation('relu')) # Unit 3 model.add( Conv2D(filters=32, kernel_size=(5, 5), kernel_initializer=kernel_init)) model.add(MaxPooling2D(padding='same')) model.add(Activation('relu'))
from pathlib import Path import numpy as np from PIL import Image from keras import Sequential, Input, Model from keras.engine import InputLayer from keras.layers import Flatten, Dense, Activation, Conv2D, MaxPooling2D, concatenate, Reshape from keras.optimizers import Adam import phpcode_data model = Sequential() model.add( InputLayer(input_shape=(phpcode_data.IMAGE_HEIGHT, phpcode_data.IMAGE_WIDTH))) model.add(Reshape((phpcode_data.IMAGE_HEIGHT, phpcode_data.IMAGE_WIDTH, 1))) # 三组卷积逻辑,每组包括两个卷积层及一个池化层 model.add( Conv2D(filters=32, kernel_size=5, strides=(1, 1), padding='same', use_bias=True, input_shape=(phpcode_data.IMAGE_HEIGHT, phpcode_data.IMAGE_WIDTH, 1))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=2, strides=2, padding='same')) model.add(
preprocessor = prep.StandardScaler().fit( dataset) # 0을 기준으로 정규분포를 만드는 것 같다. dataset = preprocessor.transform(dataset) # 어쨌든 데이터 전처리 과정임 dataset = dataset.reshape((dataset_samples, dataset_nx, dataset_ny)) # 다시 Feature x 시퀀수 수 모양으로 나눔 tmp = tmp.reshape((dataset_samples * dataset_nx * dataset_ny, 1)) send = prep.StandardScaler().fit(tmp) return dataset, send # 전처리된 데이터를 반환함 real_data, send = preprocess_data(loaded_dataset, window) input_layer = InputLayer(input_shape=(None, None), name="input_1") model = load_model('my_model(binary).h5') model.layers[0] = input_layer model.summary() Predicted_visitors = [] for pred in range(predict_period): # 나중에 이 숫자 7은 입력으로 받는걸로 ㄱㄱ Predicted_visitors.append( model.predict(real_data[[pred]], batch_size=2, verbose=1)) # 예측된 값을 새로운 리스트에 저장 tmp = Predicted_visitors[pred] # 예측된 값을 추출 if pred < predict_period - 1: # 파일의 끝에 도달할때까지 반복 real_data[pred + 1, -1, -1] = tmp[0][ 0] # 예측된 Y를 사용하기 위해 다음날짜의 page_impressions 에 채워넣음
def main(): training_images = load_data(train_data) tr_img_data = np.array([i[0] for i in training_images]).reshape(-1, 64, 64, 1) tr_lbl_data = np.array([i[1] for i in training_images]) model = Sequential() model.add(InputLayer(input_shape=[64, 64, 1])) model.add( Conv2D(filters=4, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add( Conv2D(filters=8, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add( Conv2D(filters=10, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add( Conv2D(filters=20, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add(Dropout(rate=0.25)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dropout(rate=0.5)) model.add(Dense(2, activation='softmax')) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) datagen = preprocessing.image.ImageDataGenerator(rotation_range=10, width_shift_range=0.2, height_shift_range=0.2, zoom_range=0.2, shear_range=0.2) model.fit_generator(datagen.flow(tr_img_data, tr_lbl_data, batch_size=256), epochs=500) model.summary() # Save the weights model.save_weights('trained_model/model_weights.h5') # Save the model architecture with open('trained_model/model_architecture.json', 'w') as f: f.write(model.to_json()) test()
for i in range(kernels.shape[0]): for j in range(kernels.shape[1]): new_kernels[i][j] = np.append(kernels[i][j], 0) return utils.get_weights(new_kernels) if __name__ == '__main__': model = utils.load_model('Models/Model_12KHz_98%_meanPooling.yaml', 'Models/Model_12KHz_98%_meanPooling.h5') new_model = Sequential() input_layer = InputLayer(input_shape=(None, 1), name="input_new") new_model.add(input_layer) for layer in model.layers: if "Flatten" in str(layer): flattened_ipt = True f_dim = layer.input_shape elif "Dense" in str(layer): input_shape = layer.input_shape output_dim = layer.get_weights()[1].shape[0] W, b = layer.get_weights() Wshape = W.shape
# freeze(mfcc_dnn.model) # # mbh_dnn=Dnn(dataset.sources['mbh'][1], 239, name='DNN_mbh') # mbh_dnn.load_weights(path="weights/") # freeze(mbh_dnn.model) # # hog_dnn=Dnn(dataset.sources['hog'][1], 239, name='DNN_hog') # hog_dnn.load_weights(path="weights/") # freeze(hog_dnn.model) # # traj_dnn=Dnn(dataset.sources['traj'][1], 239, name='DNN_traj') # traj_dnn.load_weights(path="weights/") # freeze(traj_dnn.model) cnn_dnn = Sequential() cnn_dnn.add(InputLayer(input_shape=(239, ))) cnn_scalar = VectorLayer() cnn_dnn.add(cnn_scalar) # cnn_dnn.add(Activation('sigmoid')) mfcc_dnn = Sequential() mfcc_dnn.add(InputLayer(input_shape=(239, ))) mfcc_scalar = VectorLayer() mfcc_dnn.add(mfcc_scalar) # mfcc_dnn.add(Activation('sigmoid')) mbh_dnn = Sequential() mbh_dnn.add(InputLayer(input_shape=(239, ))) mbh_scalar = VectorLayer() mbh_dnn.add(mbh_scalar) # mbh_dnn.add(Activation('sigmoid'))
def run_lstm(Xtr, Xte, ytr, yte, max_features, max_features2, out_size, embedding_size, hidden_size, batch_size, epochs=50, verbose=0, maxsent=0): print('Training and testing tensor shapes:', Xtr.shape, Xte.shape, ytr.shape, yte.shape) mf = max(max_features, max_features2) model1 = Sequential() model1.add( Embedding(input_dim=mf, output_dim=embedding_size, input_length=maxsent, mask_zero=True)) model2 = Sequential() model2.add(InputLayer(input_shape=(maxsent, Xtr.shape[2] - 1))) model = Sequential() model.add(Merge([model1, model2], mode='concat')) model.add(Dense(1)) model.add( LSTM(hidden_size, return_sequences=True, input_shape=(maxsent, Xtr.shape[2] - 1))) model.add(TimeDistributed(Dense(out_size))) model.add(Activation('softmax')) print 'compile...' model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #print(model.summary()) print('train...') model.fit([Xtr[:, :, 0], Xtr[:, :, 1:Xtr.shape[2]]], ytr, epochs=epochs, verbose=verbose, batch_size=batch_size, validation_data=([Xte[:, :, 0], Xte[:, :, 1:Xtr.shape[2]]], yte)) score = model.evaluate([Xte[:, :, 0], Xte[:, :, 1:Xtr.shape[2]]], yte, batch_size=batch_size, verbose=verbose) print('Raw test score:', score) pr = model.predict_classes([Xtr[:, :, 0], Xtr[:, :, 1:Xtr.shape[2]]], verbose=verbose) yh = ytr.argmax(2) # no encoding fyh, fpr = score2(yh, pr) print('Training...') print(' - accuracy:', accuracy_score(fyh, fpr)) print(' - confusion matrix:') print(confusion_matrix(fyh, fpr)) print(' - precision, recall, f1, support:') print precision_recall_fscore_support(fyh, fpr) pr = model.predict_classes([Xte[:, :, 0], Xte[:, :, 1:Xte.shape[2]]], verbose=verbose) yh = yte.argmax(2) fyh, fpr = score2(yh, pr) print('Testing...') print(' - accuracy:', accuracy_score(fyh, fpr)) print(' - confusion matrix:') print(confusion_matrix(fyh, fpr)) print(' - precision, recall, f1, support:') print precision_recall_fscore_support(fyh, fpr) print( '----------------------------------------------------------------------------------' )
from keras.models import load_model from keras.layers import Input, Dense from tensorflow import Tensor from keras import backend as K from keras.engine import InputLayer model = load_model('model_checkpoint.hdf5') for layer in model.layers: print(layer) input_layer1 = InputLayer(input_shape=(51, 68, 3), name="input_1") input_layer2 = InputLayer(input_shape=(51, 68, 3), name="input_2") print("input shape:", input_layer1.input_shape) print("input tensor:", input_layer1.input) print("name:", input_layer1.name) print("sparse:", input_layer1.sparse) print("dtype:", input_layer1.dtype) model.layers[0] = input_layer1 model.layers[1] = input_layer2 model.save("reshaped-model.h5") import coremltools coreml_model = coremltools.converters.keras.convert( 'reshaped-model.h5', is_bgr=True, input_names=['image1', 'image2'], image_input_names=['image1', 'image2'], output_names=['output'], blue_bias=-103.939,
def _build_encoder(): model = Sequential(name='encoder') model.add(InputLayer(input_shape=(None, None, 1)))