def train(): X = np.load('./data/train_X.npy') y = np.load('./data/train_y.npy') train_datagen = ImageDataGenerator(rescale=1.0 / 255.) validation_datagen = ImageDataGenerator(rescale=1.0 / 255.) train_generator = train_datagen.flow(X, y, batch_size=300) validation_generator = validation_datagen.flow(X, y) nb_epoch = 2000 nb_train_samples = N nb_validation_samples = 600 old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) model = Sequential() with tf.name_scope("inference") as scope: model = set_model(model) model.summary() fpath = './model/weights.hdf5' tb_cb = TensorBoard(log_dir="./tensorlog", histogram_freq=1) cp_cb = ModelCheckpoint(filepath=fpath, monitor='val_loss', verbose=1, save_best_only=False, mode='auto', save_weights_only=True) history = model.fit_generator(train_generator,samples_per_epoch=nb_train_samples, \ nb_epoch=nb_epoch, validation_data=validation_generator, \ nb_val_samples=nb_validation_samples,\ callbacks=[cp_cb, tb_cb])
def _wrap_savedmodel_around_keras(self, preprocess_function, postprocess_function, model_name, model_version, h5_filepath, serve_dir, channels, optional_preprocess_args, optional_postprocess_args): """ Injects input and output layers with Keras Lambdas, then exports to SavedModel. Args: preprocess_function: A function from the LayerInjector class which preprocesses input. postprocess_function: A function from the LayerInjector class which postprocesses output. model_name: The name of the model. model_version: The version number of the model. h5_filepath: The filepath to a .h5 file containing an exported Keras model. serve_dir: The path to the model's serve directory. channels: The number of channels of the input image. optional_preprocess_args: Optional dict of arguments for use with custom preprocess functions. optional_postprocess_args: Optional dict of arguments for use with custom postprocess functions. """ # Parses paths # Note that the serve directory MUST have a model version subdirectory model_version = str(model_version) save_path = serve_dir + "/" + model_name + "/" + model_version # Instantiates a Keras model K.set_learning_phase(0) keras_model = load_model(h5_filepath) # Instantiates placeholder for image bitstring input_bytes = Input(shape=[], dtype=tf.string) # Preprocesses image bitstring pre_map = {"channels": channels, **optional_preprocess_args} input_tensor = Lambda(preprocess_function, arguments=pre_map)(input_bytes) # Gets output tensor(s) output_tensor = keras_model(input_tensor) # Postprocesses output tensor(s) post_map = optional_postprocess_args output_bytes = Lambda(postprocess_function, arguments=post_map)(output_tensor) # Builds new Model model = Model(input_bytes, output_bytes) # Builds input/output tensor protos input_tensor_info = {"input_bytes": build_tensor_info(model.input)} output_tensor_info = {"output_bytes": build_tensor_info(model.output)} # Creates and saves SavedModel self._create_savedmodel(save_path, input_tensor_info, output_tensor_info)
def encode_and_decode(mode_auto, exp_condition): config = tf.compat.v1.ConfigProto() config.gpu_options.allow_growth = True sess = tf.compat.v1.Session(config=config) keras.backend.set_session(sess) old_session = KTF.get_session() session = tf.compat.v1.Session('') KTF.set_session(session) KTF.set_learning_phase(1) loader_ins = Loader(exp_condition["load_dir"]) loader_ins.load(gray=True, size=(196, 136)) # 横×縦 data = loader_ins.get_data(norm=True) # (None, Height, Width) if mode_auto == "CAE": input_shape = (data.shape[1], data.shape[2], 1) data = np.reshape(data, (data.shape[0], data.shape[1], data.shape[2], 1)) # (None, Height, Width, 1) elif mode_auto == "AE": input_shape = (data.shape[1]*data.shape[2],) data = np.reshape(data, (data.shape[0], data.shape[1]*data.shape[2],)) # (None, Height*Width, 1) else: raise Exception x_train = data[:int(len(data) * exp_condition["train_rate"])] x_val = data[int(len(data) * exp_condition["train_rate"]):] train_auto(mode_auto=mode_auto, x_train=x_train, x_val=x_val, input_shape=input_shape, weights_dir=exp_condition["weights_dir"], batch_size=exp_condition["batch_size"], verbose=1, epochs=exp_condition["epochs"], num_compare=2 ) data = loader_ins.get_data(norm=True) model_name = get_latest_modified_file_path(exp_condition["weights_dir"]) print(model_name, "をモデルとして分散表現化します.") img2vec(data, model_name, mode_auto=mode_auto, mode_out="hwf") KTF.set_session(old_session)
def main(_): (x_train, y_train), (x_test, y_test) = load_data() print(x_train.shape) print(x_test.shape) x_train = x_train.astype('float32').reshape(-1, 784) / 255. x_test = x_test.astype('float32').reshape(-1, 784) / 255. y_train = to_categorical(y_train) y_test = to_categorical(y_test) print(x_train.shape) print(x_test.shape) with tf.Graph().as_default() as graph: with tf.Session() as sess: K.set_session(sess) K.set_learning_phase(1) model = Mnist() pprint(get_train_ops(graph=model.graph))
def model_fn(input_dim, labels_dim, hidden_units, learning_rate=0.1): """Create a Keras Sequential model with layers. Args: input_dim: (int) Input dimensions for input layer. labels_dim: (int) Label dimensions for input layer. hidden_units: [int] the layer sizes of the DNN (input layer first) learning_rate: (float) the learning rate for the optimizer. Returns: A Keras model. """ # "set_learning_phase" to False to avoid: # AbortionError(code=StatusCode.INVALID_ARGUMENT during online prediction. K.set_learning_phase(False) model = models.Sequential() hidden_units = [int(units) for units in hidden_units.split(',')] for units in hidden_units: model.add( layers.Dense( units, activation=relu, input_shape=[input_dim], kernel_initializer='glorot_uniform', )) model.add(layers.Dropout(0.5)) model.add( layers.BatchNormalization(epsilon=1e-03, momentum=0.9, weights=None)) input_dim = units # activity_regularizer=tf.keras.regularizers.l1(0.01) # Add a dense final layer with sigmoid function. model.add(layers.Dense(labels_dim, activation='softmax')) compile_model(model, learning_rate) return model
def save_model(model): # load tensorflow and keras backend import tensorflow as tf from tensorflow.python.framework import graph_util from tensorflow.python.framework import graph_io import keras.backend.tensorflow_backend as K ksess = K.get_session() print(ksess) # transform keras model to tensorflow graph # the output will be json-like format K.set_learning_phase(0) graph = ksess.graph kgraph = graph.as_graph_def() print(kgraph) # define output node num_output = 1 prefix = "output" pred = [None]*num_output outputName = [None]*num_output for i in range(num_output): outputName[i] = prefix + str(i) pred[i] = tf.identity(model.get_output_at(i), name=outputName[i]) print('output name: ', outputName) # convert variables in the model graph to constants constant_graph = graph_util.convert_variables_to_constants(ksess, ksess.graph.as_graph_def(), outputName) # save the model in .pb and .txt output_dir = "/home/" output_graph_name = "keras2tf.pb" output_text_name = "keras2tf.txt" graph_io.write_graph(constant_graph, output_dir, output_graph_name, as_text=False) graph_io.write_graph(constant_graph, output_dir, output_text_name, as_text=True) print('saved graph .pb at: {0}\nsaved graph .txt at: {1}'.format( os.path.join(output_dir, output_graph_name), os.path.join(output_dir, output_text_name)))
def model_fn(input_dim, labels_dim, hidden_units, learning_rate=0.1): K.set_learning_phase(False) model = models.Sequential() hidden_units = [int(units) for units in hidden_units.split(',')] for units in hidden_units: model.add(layers.Dense(units, activation=relu, input_shape=[input_dim], kernel_initializer='glorot_uniform', )) # model.add(layers.Dropout(0.5)) # model.add(layers.BatchNormalization(epsilon=1e-03, momentum=0.9, weights=None)) input_dim = units # activity_regularizer=tf.keras.regularizers.l1(0.01) # Add a dense final layer with sigmoid function. model.add(layers.Dense(labels_dim, activation='softmax')) # compile_model(model, learning_rate) return model
def main(args): # set the necessary list train_list = pd.read_csv(args.train_list, header=None) val_list = pd.read_csv(args.val_list, header=None) # set the necessary directories trainimg_dir = args.trainimg_dir trainmsk_dir = args.trainmsk_dir valimg_dir = args.valimg_dir valmsk_dir = args.valmsk_dir # get old session old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) # set callbacks fpath = './pretrained_mask/LIP_PSPNet50_mask{epoch:02d}.hdf5' cp_cb = ModelCheckpoint(filepath=fpath, monitor='val_loss', verbose=1, save_best_only=True, mode='auto', period=5) es_cb = EarlyStopping(monitor='val_loss', patience=2, verbose=1, mode='auto') tb_cb = TensorBoard(log_dir="./pretrained_mask", write_images=True) # set generater train_gen = data_gen_small(trainimg_dir, trainmsk_dir, train_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) val_gen = data_gen_small(valimg_dir, valmsk_dir, val_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) # set model pspnet = PSPNet50(input_shape=args.input_shape, n_labels=args.n_labels, output_mode=args.output_mode, upsample_type=args.upsample_type) print(pspnet.summary()) # compile model pspnet.compile(loss=args.loss, optimizer=args.optimizer, metrics=["accuracy"]) # fit with genarater pspnet.fit_generator(generator=train_gen, steps_per_epoch=args.epoch_steps, epochs=args.n_epochs, validation_data=val_gen, validation_steps=args.val_steps, callbacks=[cp_cb, es_cb, tb_cb]) # save model with open("./pretrained_mask/LIP_SegUNet_mask.json", "w") as json_file: json_file.write(json.dumps(json.loads(segunet.to_json()), indent=2)) print("save json model done...")
def Network_config(class_num=4, epoch=200, initial_epoch=0, batch_size=32, train_data=None, train_label=None, test_data=None, test_label=None, fold=0): adam = Adam(lr=0.005, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.000) sgd = SGD(lr=0.001, momentum=0.9, decay=0.0, nesterov=False) K.set_learning_phase(1) base_model = VGG16(input_tensor=Input(shape=(224, 224, 3)), weights='imagenet', include_top=False) x = base_model.output x = Flatten()(x) x = Dense(512, activation='relu')(x) x = BatchNormalization()(x) x = Dense(512, activation='relu')(x) x = BatchNormalization()(x) predictions = Dense(class_num, activation='softmax')(x) # this is the model we will train model = Model(inputs=base_model.input, outputs=predictions) for layer in (base_model.layers): layer.trainable = False if layer.name.startswith('bn'): layer.call(layer.input, training=False) model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=[keras.metrics.categorical_accuracy]) tools.create_directory('./tmpvgg/') weights_file = './tmpvgg/' + str( fold ) + '-weights.{epoch:02d}-{categorical_accuracy:.4f}-{val_loss:.4f}-{val_categorical_accuracy:.4f}.h5' csv_file = './tmpvgg/record.csv' lr_reducer = ReduceLROnPlateau(monitor='categorical_accuracy', factor=0.5, cooldown=0, patience=5, min_lr=0.5e-6) early_stopper = EarlyStopping(monitor='val_categorical_accuracy', min_delta=1e-4, patience=50) model_checkpoint = ModelCheckpoint(weights_file, monitor='val_categorical_accuracy', save_best_only=True, verbose=2, save_weights_only=True, mode='max') tensorboard = TensorBoard(log_dir='./logs/', histogram_freq=0, batch_size=8, write_graph=True, write_grads=True, write_images=True, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None) CSV_record = CSVLogger(csv_file, separator=',', append=True) callbacks = [ lr_reducer, early_stopper, model_checkpoint, tensorboard, CSV_record ] gc.disable() model.fit_generator( generator=tools.batch_generator(np.array(train_data), np.array(train_label), batch_size, True, class_num), steps_per_epoch=int(len(train_label) / batch_size) - 1, max_q_size=50, initial_epoch=initial_epoch, epochs=epoch, verbose=1, callbacks=callbacks, validation_data=tools.batch_generator(np.array(test_data), np.array(test_label), batch_size, True, class_num), validation_steps=int(len(test_label) / batch_size) - 1, class_weight='auto') all_y_pred = [] all_y_true = [] for test_data_batch, test_label_batch in tools.batch_generator_confusion_matrix( np.array(test_data), np.array(test_label), batch_size, True, class_num): y_pred = model.predict(test_data_batch, batch_size) y_true = test_label_batch for y_p in y_pred: all_y_pred.append(np.where(y_p == max(y_p))[0][0]) for y_t in y_true: all_y_true.append(np.where(y_t == max(y_t))[0][0]) confusion = confusion_matrix(y_true=all_y_true, y_pred=all_y_pred) print(confusion) f = open('confusion_matrix.txt', 'a+') f.write(str(all_y_true) + "\n") f.write(str(all_y_pred) + "\n") f.write(str(confusion) + '\n') f.close() gc.enable()
def learning_star(data, label): X_train, X_test, y_train, y_test = train_test_split(data, label, test_size=0.2, random_state=29) """ Add TensorBoard """ old_session = tf.Session('') session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) """ Define the model """ model = Sequential() model.add(Conv2D(30, 3, input_shape=(data.shape[1], data.shape[2], data.shape[3]))) model.add(Activation('relu')) model.add(Conv2D(30, 3)) model.add(Activation('relu')) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Conv2D(30, 3)) model.add(Activation('relu')) model.add(MaxPool2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(1024)) model.add(Activation('relu')) model.add(Dropout(1.0)) model.add(Dense(nb_classes, activation='softmax')) adam = Adam(lr=1e-4) model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=["accuracy"]) """ Add callbacks (TensorBoard, EarlyStopping) """ tb_cb = keras.callbacks.TensorBoard('./logs/', histogram_freq=1) early_stopping = EarlyStopping(monitor='val_loss', mode='min', patience=20) cbks = [tb_cb, early_stopping] """ Display Model Summary """ plot_model(model, to_file='./model.png') """ Learning Flow """ history = model.fit(X_train, y_train, batch_size=batch_size, epochs=nb_epoch, verbose=1, validation_split=0.1, callbacks=cbks) score = model.evaluate(X_test, y_test, verbose=0) print('Test Score:', score[0]) print('Test accuracy:', score[1]) """ Save Model """ print('save the architechture of the model') json_string = model.to_json() open(os.path.join('./', 'cnn_model.json'), 'w').write(json_string) yaml_string = model.to_yaml() open(os.path.join('./', 'cnn_model.yaml'), 'w').write(yaml_string) print('save the weights') model.save_weights(os.path.join('./', 'cnn_model_weight.hdf5')) """
def main(): parser = train_parser() args = parser.parse_args() if args.use_cpu: # disable gpu completely os.environ["CUDA_VISIBLE_DEVICES"] = "-1" else: # set device number os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu if args.seed != -1: # set random seed np.random.seed(args.seed) random.seed(args.seed) tf.set_random_seed(args.seed) # get old session old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) # determine some variables from args dims, input_shape, n_labels, model_dir, checkpoint_path = find_input( args) os.makedirs(model_dir, exist_ok=True) # set callbacks # for multiple checkpoints set filepath to "...point{epoch:d}.hdf5" cp_cb = MyCheckpoint(filepath=model_dir + "/checkpoint.hdf5", monitor='val_loss', verbose=1, save_best_only=False, mode='auto', period=1) tb_cb = TensorBoard(log_dir=model_dir, write_images=True) log = CSVLogger(model_dir + "/training.log", append=True) # set generator if args.use_random: # create random data train_gen = data_gen_random(dims, n_labels, args.batch_size, args.use_flow) val_gen = data_gen_random(dims, n_labels, args.batch_size, args.use_flow) elif args.use_numpy: # load small numpy dataset n_labels = args.n_classes datagen = DataStorageNpy(args.train_imgs_npy, args.train_mask_npy, args.train_flow_npy, args.val_percent, dims, n_labels, args.use_flow, args.batch_size) train_gen = datagen.generate(training=True) val_gen = datagen.generate(training=False) else: # load dataset from folders datagen = DataStorage(args.data_dir, args.dataset, dims, n_labels) train_gen = datagen.generate( args.batch_size, args.use_flow, args.use_mb, args.use_occ, args.train_categories, split="train", shuffle=True, normalize_images=not args.no_norm_images) val_gen = datagen.generate( args.batch_size, args.use_flow, args.use_mb, args.use_occ, args.train_categories, split="val", shuffle=False, random_crop=False, normalize_images=not args.no_norm_images) if args.test_generator: imgs, labels = next(train_gen) print("datagen yielded", imgs.shape, labels.shape) return # # test has flow and images, but masks are zero # # so it cannot be used to compute accuracy # test_gen = datagen.generate(args.batch_size, args.use_flow, # args.use_mb, args.use_occ, # split="test") # ----- determine class weights weight_mask, weight_mask_iou = find_masks(args, n_labels) print("using weight mask:", weight_mask) print("using weight mask for iou:", weight_mask_iou) # ----- define loss old_loss = args.loss print("old loss", old_loss) loss = weighted_categorical_crossentropy(weight_mask, args.weight_mult) # ----- define iou metric def mean_iou(y_true, y_pred): return mean_iou_func(y_true, y_pred, args.batch_size, dims, n_labels, weight_mask_iou, iou_test=False) # ----- restart or load model restart = args.restart if not args.restart: # check if model is available if not os.path.exists(checkpoint_path): print("no previous model available, restarting from epoch 0") restart = True print("model input shape", input_shape) if restart: # set model pspnet = PSPNet50(input_shape=input_shape, n_labels=n_labels, output_mode=args.output_mode, upsample_type=args.upsample_type) # compile model pspnet.compile(loss=loss, optimizer=args.optimizer, metrics=["accuracy", mean_iou]) # metrics=["acc_iou", mean_iou]) starting_epoch = 0 else: # load model from dir try: pspnet = load_model(checkpoint_path, custom_objects={ 'mean_iou': mean_iou, 'loss': loss }) except OSError: raise OSError("failed loading checkpoint", checkpoint_path) except ValueError: raise ValueError( "possible the checkpoint file is corrupt because the " "script died while saving. use the backup old_checkpoint") try: with open(model_dir + "/epochs.txt", "r") as fh: starting_epoch = int(fh.read()) except OSError: raise FileNotFoundError("could not find epochs.txt") print("reloading model epoch", starting_epoch) # print model summary (weights, layers etc) if args.summary: print(pspnet.summary()) # ----- fit with genarater pspnet.fit_generator(generator=train_gen, steps_per_epoch=args.epoch_steps, epochs=args.n_epochs, validation_data=val_gen, validation_steps=args.val_steps, callbacks=[cp_cb, tb_cb, log], initial_epoch=starting_epoch)
output = clip_ops.clip_by_value(output, epsilon_, 1 - epsilon_) # print("target shape=", target.shape) wei = target[:, :, :, :, -1:] target = target[:, :, :, :, :-1] # print("target shape=", target.shape, ", wei shape=", wei.shape, "output shape ", output.shape) output = output[:, :, :, :, :-1] output = math_ops.log(output / (1 - output)) retval = nn.weighted_cross_entropy_with_logits( targets=target, logits=output, pos_weight=10) #900=works #2900=200x200, 125=30x30 retval = retval * (wei + 0.01) # print("output xentr ", retval) return tf.reduce_sum(retval, axis=None) / (tf.reduce_sum(wei, axis=None)) K.set_learning_phase(0) if args.theano_backend: K.set_image_data_format('channels_first') else: K.set_image_data_format('channels_last') try: net_model = load_model(weight_file_path, custom_objects={ 'loss_mse_select_clipped': loss_mse_select_clipped, 'loss_ROIsoft_crossentropy': loss_ROI_crossentropy, '_to_tensor': _to_tensor }) except ValueError as err:
def run(): env = RoboEnv(client) nb_actions = env.action_space.n for i in range(50): print('simulation start: %d' % i) old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) if not os.path.isfile(model_save_path): model = Sequential() model.add( Flatten(input_shape=(1, ) + env.observation_space.shape)) model.add(Dense(16)) model.add(Activation('relu')) model.add(Dense(16)) model.add(Activation('relu')) model.add(Dense(16)) model.add(Activation('relu')) model.add(Dense(nb_actions)) model.add(Activation('linear')) else: with open(model_save_path, 'r') as f: model = model_from_json(f.read()) if os.path.isfile(weight_save_path): model.load_weights(weight_save_path) print(model.summary()) # experience replay用のmemory memory = SequentialMemory(limit=50000, window_length=1) # 行動方策はオーソドックスなepsilon-greedy。ほかに、各行動のQ値によって確率を決定するBoltzmannQPolicyが利用可能 policy = EpsGreedyQPolicy(eps=0.1) dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=100, target_model_update=1e-2, policy=policy) dqn.compile(Adam(lr=1e-3), metrics=['mae']) tb = TensorBoard(log_dir='data/tensorboard', histogram_freq=0, write_graph=True) history = dqn.fit(env, nb_steps=50000, visualize=False, callbacks=[tb], verbose=2, nb_max_episode_steps=5000) json_string = model.to_json() with open(model_save_path, 'w') as f: f.write(json_string) model.save_weights(weight_save_path) with open( 'data/history/history%s.pickle' % time.strftime('%Y%m%d-%H%M%S'), 'wb') as f: pickle.dump(history.history, f) KTF.set_session(old_session)
from keras.utils import np_utils from keras.models import model_from_json M = 10 # data (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('f') / 255.0 # (60000, 28, 28) x_test = x_test.astype('f') / 255.0 y_train = np_utils.to_categorical(y_train, M) # int -> one-of-vector y_test = np_utils.to_categorical(y_test, M) with tf.Graph().as_default(): session = tf.Session('') K.set_session(session) K.set_learning_phase(1) try: json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) loaded_model.load_weights("model.h5") print("Loaded model from disk") except: # model construction model = Sequential() model.add(Reshape((28, 28, 1), input_shape=(28, 28))) # tensorflow-order!! model.add(Conv2D(8, (5, 5), strides=(2, 2), activation='relu')) model.add(Conv2D(16, (5, 5), strides=(2, 2), activation='relu'))
def main(args): # set the necessary list train_list = pd.read_csv(args.train_list, header=None) val_list = pd.read_csv(args.val_list, header=None) # set the necessary directories trainimg_dir = args.trainimg_dir trainmsk_dir = args.trainmsk_dir valimg_dir = args.valimg_dir valmsk_dir = args.valmsk_dir # get old session old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) # class weights classes = ['background', 'hat', 'hair', 'glove', 'sunglasses', 'upperclothes', 'dress', 'coat', 'socks', 'pants', 'jumpsuits', 'scarf', 'skirt', 'face', 'leftArm', 'rightArm', 'leftLeg', 'rightLeg', 'leftShoe','rightShoe'] if args.class_weights: """ class_weights = {0:1, 1:40, 2:1, 3:114, 4:151, 5:3, 6:53, 7:7, 8:165, 9:7, 10:106, 11:249, 12:150, 13:1, 14:1, 15:1, 16:1, 17:1, 18:114, 19:118} """ class_weights = [1, 40, 1, 114, 151, 3, 53, 7, 165, 7, 106, 249, 150, 1, 1, 1, 1, 1, 114, 118] # set callbacks fpath = "./pretrained_class_weights/LIP_PSPNet50_class_weights{epoch:02d}.hdf5" cp_cb = ModelCheckpoint(filepath = fpath, monitor='val_loss', verbose=1, save_best_only=True, mode='auto', period=2) es_cb = EarlyStopping(monitor='val_loss', patience=2, verbose=1, mode='auto') tb_cb = TensorBoard(log_dir="./pretrained_class_weights", write_images=True) # set generater train_gen = data_gen_small( trainimg_dir, trainmsk_dir, train_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) val_gen = data_gen_small( valimg_dir, valmsk_dir, val_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) # set model pspnet = PSPNet50( input_shape=args.input_shape, n_labels=args.n_labels, output_mode=args.output_mode, upsample_type=args.upsample_type) print(pspnet.summary()) # compile model pspnet.compile( loss=args.loss, optimizer=args.optimizer, metrics=["accuracy"]) # fit with genarater pspnet.fit_generator( generator=train_gen, steps_per_epoch=args.epoch_steps, epochs=args.n_epochs, validation_data=val_gen, validation_steps=args.val_steps, class_weight=class_weights, callbacks=[cp_cb, es_cb, tb_cb]) # save model with open("./pretrained_class_weights/LIP_PSPNet50.json", "w") as json_file: json_file.write(json.dumps(json.loads(pspnet.to_json()), indent=2)) print("save json model done...")
def main(fname_lift_train, fname_shape_train, fname_lift_test, fname_shape_test, case_number, case_type=3, env="Lab"): r_rate = [1, 2, 4, 8] for rr in r_rate: if rr == 1: s_odd = 0 # 全部読みだす elif fname_shape_train.find("fourier") != -1: s_odd = 3 # 前方から読み出す(fourier用) else: s_odd = 4 # 全体にわたって等間隔に読み出す(equidistant, dense用) old_session = KTF.get_session() with tf.Graph().as_default(): source = "Incompressible_Invicid\\training_data\\" if env == "Lab": source = "D:\\Toyota\\Data\\" + source case_num = get_case_number(source, env, case_number) log_name = "learned\\" + case_num + "_tb_log.hdf5" json_name = "learned\\" + case_num + "_mlp_model_.json" weight_name = "learned\\" + case_num + "_mlp_weight.h5" elif env == "Colab": source = "/content/drive/Colab Notebooks/" + source.replace( "\\", "/") case_num = get_case_number(source, env, case_number) log_name = "learned/" + case_num + "_log.hdf5" json_name = "learned/" + case_num + "_mlp_model_.json" weight_name = "learned/" + case_num + "_mlp_weight.h5" session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) model = Sequential() if case_type == 3: X_train, y_train = read_csv_type3(source, fname_lift_train, fname_shape_train, shape_odd=s_odd, read_rate=rr) x_test, y_test = read_csv_type3(source, fname_lift_test, fname_shape_test, shape_odd=s_odd, read_rate=rr) input_vector_dim = X_train.shape[1] with tf.name_scope("inference") as scope: model.add(Dense(units=2, input_dim=input_vector_dim)) model.add(LeakyReLU()) model.add(Dense(units=16)) model.add(LeakyReLU()) """ model.add(Dense(units=128)) model.add(LeakyReLU()) model.add(Dense(units=192)) model.add(LeakyReLU()) model.add(Dense(units=2048)) model.add(LeakyReLU()) model.add(Dense(units=2048)) model.add(LeakyReLU()) """ """ model.add(Dense(units=512)) model.add(LeakyReLU()) for i in range(5): model.add(Dense(units = 512)) model.add(LeakyReLU()) # model.add(Dropout(0.5)) # model.add(Dense(units=half, activation='relu')) # model.add(Dropout(0.5)) """ model.add(Dense(units=1)) model.summary() save_my_log(source, case_number, fname_lift_train, fname_shape_train, model.summary()) # es_cb = EarlyStopping(monitor='val_loss', patience=0, verbose=0, mode='auto') tb_cb = TensorBoard(log_dir=source + log_name, histogram_freq=0, write_grads=True) model.compile(loss="mean_squared_error", optimizer='Adam') batch_size = 500 train_steps, train_batches = batch_iter(X_train, y_train, batch_size) valid_steps, valid_batches = batch_iter(x_test, y_test, batch_size) """ model.fit(x=X_train, y=y_train, batch_size=600, nb_epoch=1000, validation_split=0.05, callbacks=[tb_cb]) """ model.fit_generator(train_batches, train_steps, epochs=1000, validation_data=valid_batches, validation_steps=valid_steps, callbacks=[tb_cb]) # X_train: [number, angle, shape001, shape002, ..., shapeMAX] # y_train: [number, lift] # 適当に中央付近の翼を抜き出しての-40-38degreeをプロットさせてみる tekito = 1306 * 40 # NACA2613 or NACA2615 plt.figure() plt.plot(X_train[tekito:tekito + 40, 0], y_train[tekito:tekito + 40]) plt.plot(X_train[tekito:tekito + 40, 0], model.predict(X_train)[tekito:tekito + 40]) plt.savefig(source + case_num + "_train.png") y_predict = model.predict(x_test) tekito = (99 + 13) * 40 # 22012 plt.figure() plt.plot(x_test[tekito:tekito + 40, 0], y_test[tekito:tekito + 40]) plt.plot(x_test[tekito:tekito + 40, 0], y_predict[tekito:tekito + 40]) plt.savefig(source + case_num + "_test.png") json_string = model.to_json() open(source + json_name, 'w').write(json_string) model.save_weights(source + weight_name) KTF.set_session(old_session)
def cnn_train(self, X_train, Y_train, X_test, Y_test): conv1 = self.conv1 conv2 = self.conv2 conv3 = self.conv3 dense1 = self.dense1 dense2 = self.dense2 # ニュートラルネットワークで使用するモデル作成 old_session = KTF.get_session() # old_session = tf.compat.v1.keras.backend.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) model = Sequential() model.add( Conv2D(conv1, kernel_size=(3, 3), activation='relu', input_shape=(X_train.shape[1:]))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(conv2, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(conv3, (3, 3), activation='relu')) # model.add(Dropout(0.25)) # model.add(Conv2D(128, (3, 3), padding='same',activation='relu')) # model.add(MaxPooling2D(pool_size=(2, 2))) # model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(dense1, activation='relu')) # model.add(Dropout(0.5)) model.add(Dense(self.classnum, activation='softmax')) model.summary() # optimizer には adam を指定 adam = keras.optimizers.Adam(lr=self.learning_rate) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['accuracy']) es_cb = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=100, verbose=0, mode='auto') tb_cb = keras.callbacks.TensorBoard(log_dir=self.f_log, histogram_freq=1) # cp_cb = keras.callbacks.ModelCheckpoint(filepath = os.path.join(f_model,'cnn_model{epoch:02d}-loss{loss:.2f}-acc{acc:.2f}-vloss{val_loss:.2f}-vacc{val_acc:.2f}.hdf5'), monitor='val_loss', verbose=1, save_best_only=True, mode='auto') # cbks = [es_cb, tb_cb, cp_cb] cbks = [es_cb, tb_cb] # cbks = [tb_cb] history = model.fit(X_train, Y_train, batch_size=self.nb_batch, epochs=self.nb_epoch, validation_data=(X_test, Y_test), callbacks=cbks, verbose=1) score = model.evaluate(X_test, Y_test, verbose=0) print('Test score:', score[0]) print('Test accuracy:', score[1]) print('save the architecture of a model') json_string = model.to_json() open(os.path.join(self.f_model, 'cnn_model.json'), 'w').write(json_string) yaml_string = model.to_yaml() open(os.path.join(self.f_model, 'cnn_model.yaml'), 'w').write(yaml_string) print('save weights') model.save_weights(os.path.join(self.f_model, 'cnn_weights.hdf5')) KTF.set_session(old_session) return
# https://keras.io/getting-started/faq/#how-can-i-obtain-the-output-of-an-intermediate-layer if SAVE_HIDDEN: layers_of_interest = [ 'conv1d_1', 'conv1d_2', 'reshape_2', 'lstm_1', 'dense_1', 'dense_2' ] np.random.seed(0) rand_indices = np.random.randint(0, x_test.shape[0], 250) print('Saving hidden layers: ', layers_of_interest) tfs.get_keras_layers( model, layers_of_interest, x_test[rand_indices], y_test[rand_indices], output_dir=tfs.prep_dir( 'I:/_ecg_data_backup/classification/hidden_layers'), fname='rat_hidden_all_' + file_name + '.mat') print('Elapsed Time (ms): ', tfs.current_time_ms() - start_time_ms) print('Elapsed Time (min): ', (tfs.current_time_ms() - start_time_ms) / 60000) data_dict = {'x_val': x_test, 'y_val': y_test, 'y_prob': yy_probabilities} savemat(tfs.prep_dir(output_folder) + file_name + '.mat', mdict=data_dict) tf_backend.set_learning_phase(0) tfs.export_model_keras(keras_model_name, tfs.prep_dir("graph_rat"), model_name=description) # Results:
def __enter__(self): self.learning_phase_placeholder = K.learning_phase() K.set_learning_phase(self.value)
def main(args): aggregator = Aggregator(_base_dir = args.base_dir, _img_dir = args.img_dir, _label_dir = args.label_dir, _inf_dir = args.inf_dir, _dag_dir = args.dag_dir, _poses_dir = args.poses_dir) print('Num of ground truth labeled images %d\n\n' % len(aggregator.agg_list)) for i in range(0, 100): print('\nDAgger Iteration: %d\n' % aggregator.dag_it_num) # creates new directories each iteration aggregator.on_new_iter() # returns the training, validation lists and knowledge of index at which index evaluation in agg_list starts train, val, idx_eval = aggregator.get_training_data() # set directory to save predictions of inference inf_dir = aggregator.dag_dir + '%02d/inf/' % aggregator.dag_it_num # initiates the evaluator evaluator = Evaluator(aggregator.base_dir, inf_dir, aggregator.label_dir, _agg_list = aggregator.agg_list) # estimating a batch each process should evaluate later to don't exceed a given process number evaluator.estimate_batch_size(len(aggregator.agg_list[idx_eval:])) print('Evaluating %d images in %d threads' % (evaluator.batch_size, evaluator.num_max_threads)) if aggregator.dag_done or evaluator.stop_dagger: aggregator.save_list() print('DAgger stopped!') break aggregator.save_list(train, 'train') aggregator.save_list(val, 'val') # Training and Prediction os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = '0' with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) # initializes a trainer with already separated training and validation list # an inference is done for all images in the agg_list after the idx_eval trainer = Trainer(_train_list = train, _val_list = val, _inf_list = aggregator.agg_list[idx_eval:], _base_dir = aggregator.base_dir, _img_dir = aggregator.img_dir, _label_dir = aggregator.label_dir, _inf_dir = aggregator.inf_dir, _dag_dir = aggregator.dag_dir, _log_dir = 'log/') # setting of some hyper parameters trainer.batch_size = 8 # increasing epoch steps so the net has the chance to see all images of the training set in an epoch # else it is observable that the validation loss doesn't decrease and the training is stopped trainer.epoch_steps = len(train) // trainer.batch_size trainer.val_steps = len(val) // trainer.batch_size trainer.n_epochs = 25 trainer.dag_it = aggregator.dag_it_num trainer.update_callback() # trains model for defined number of epochs with the actual dataset trainer.train() print('\nTraining done!\nStarting Prediction\n') # safes inferences of images that are unseen by the net trainer.predict() session.close() print('\nInference done!\n') print('Evaluating %d images' % len(aggregator.agg_list[idx_eval:])) # Training and prediction done # Evaluation aggregator.agg_list = evaluator.process_prediction(agg_chunk = aggregator.agg_list, idx_eval = idx_eval) print('Evaluation done. Saving evaluated data.') aggregator.save_list(aggregator.agg_list[idx_eval:], 'eval') # Evaluation done and saved for next iteration # save full aggregation list with all information of all iterations until this in iteration's folder aggregator.save_list() # delete all images of inference step to save space on the drive aggregator.delete_inf() aggregator.prepare_next_it()
def cnn_train_noneval(self, X_train, Y_train): conv1 = self.conv1 conv2 = self.conv2 conv3 = self.conv3 dense1 = self.dense1 dense2 = self.dense2 # ニュートラルネットワークで使用するモデル作成 old_session = KTF.get_session() #old_session = tf.compat.v1.keras.backend.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) model = Sequential() model.add( Conv2D(conv1, kernel_size=(3, 3), activation='relu', input_shape=(X_train.shape[1:]))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(conv2, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(conv3, (3, 3), activation='relu')) # model.add(Dropout(0.25)) # model.add(Conv2D(128, (3, 3), padding='same',activation='relu')) # model.add(MaxPooling2D(pool_size=(2, 2))) # model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(dense1, activation='relu')) # model.add(Dropout(0.5)) model.add(Dense(self.classnum, activation='softmax')) model.summary() # optimizer には adam を指定 adam = keras.optimizers.Adam(lr=self.learning_rate) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['accuracy']) history = model.fit(X_train, Y_train, batch_size=self.nb_batch, epochs=self.nb_epoch, validation_data=None, callbacks=None, verbose=1) print('save the architecture of a model') json_string = model.to_json() open(os.path.join(self.f_model, 'cnn_model.json'), 'w').write(json_string) yaml_string = model.to_yaml() open(os.path.join(self.f_model, 'cnn_model.yaml'), 'w').write(yaml_string) print('save weights') model.save_weights(os.path.join(self.f_model, 'cnn_weights.hdf5')) KTF.set_session(old_session) return
def main(args): # device number if args.gpu_num: os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_num print(os.environ["CUDA_VISIBLE_DEVICES"]) # set the necessary directories train_dir = 'resources/train' test_dir = 'resources/test' train_list = [] train_list_file = "resources/train_list.txt" val_list_file = "resources/val_list.txt" with open(train_list_file, "r") as f: for l in f: train_list.append(l.replace("\n", "")) val_list = [] with open(val_list_file, "r") as f: for l in f: val_list.append(l.replace("\n", "")) with tf.Graph().as_default(): config = tf.ConfigProto() config.gpu_options.allow_growth = True config.gpu_options.per_process_gpu_memory_fraction = 1.0 session = tf.Session(config=config) KTF.set_session(session) KTF.set_learning_phase(1) # set callbacks cp_cb = ModelCheckpoint(filepath='resources/checkpoints/checkpoint', monitor='val_loss', verbose=1, save_best_only=True, mode='auto', period=2) es_cb = EarlyStopping(monitor='val_loss', patience=2, verbose=1, mode='auto') tb_cb = TensorBoard(log_dir='resources/logs/', write_images=True) csv_logger = CSVLogger('resources/logs/training.log') # set generater train_gen = data_gen_small('resources/train/', 'resources/train/', train_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) val_gen = data_gen_small('resources/val/', 'resources/val/', val_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) # set model model = segunet(args.input_shape, args.n_labels, args.kernel, args.pool_size, args.output_mode) print(model.summary()) # compile model model.compile(loss=args.loss, optimizer=args.optimizer, metrics=["accuracy"]) # fit with genarater model.fit_generator(generator=train_gen, steps_per_epoch=args.epoch_steps, epochs=args.n_epochs, validation_data=val_gen, validation_steps=args.val_steps, callbacks=[cp_cb, es_cb, tb_cb, csv_logger]) model.save_weights("resources/weights/weights_01.hdf5")
def dnn_classification(train_x, train_y, test_x, test_y, class_number, base_dir, from_frequency, to_frequency, frequency_list): # conv1 = 30 nb_epoch = 10000 nb_batch = 32 learning_rate = 1e-2 try: ##convolutionを使う場合 conv1 train_x.resize(train_x.shape[0], train_x.shape[1], 1) test_x.resize(test_x.shape[0], test_x.shape[1], 1) except: pass dense1 = 60 dense2 = 30 dense3 = 14 dense4 = class_number regularizers_l2_1 = 0 regularizers_l2_2 = 0 regularizers_l2_3 = 0 try: model_structure = 'conv{0}relu_{1}relul2{2}_{3}relul2{4}_{5}relul2{6}_{7}softmax'.format(conv1, dense1, regularizers_l2_1, dense2, regularizers_l2_2, dense3, regularizers_l2_3, dense4) except: model_structure = '{0}relul2{1}_{2}relul2{3}_{4}relul2{5}_{6}softmax'.format(dense1, regularizers_l2_1, dense2, regularizers_l2_2, dense3, regularizers_l2_3, dense4) f_log = base_dir + '/logs/fit' + 'freq' + str( from_frequency) + 'to' + str(to_frequency) + 'num' + str( len(frequency_list)) + '/' + model_structure + '_lr' + str(learning_rate) + '/Adam_epoch' + str( nb_epoch) + '_batch' + str(nb_batch) # print(f_log) f_model = base_dir + '/model' + 'freq' + str( from_frequency) + 'to' + str(to_frequency) + 'num' + str( len(frequency_list)) + '/' + model_structure + '_lr' + str(learning_rate) + '/Adam_epoch' + str( nb_epoch) + '_batch' + str(nb_batch) os.makedirs(f_model, exist_ok=True) # ニュートラルネットワークで使用するモデル作成 old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) model = keras.models.Sequential() try: model.add(Conv1D(conv1, 4, padding='same', input_shape=(train_x.shape[1:]), activation='relu')) model.add(Flatten()) model.add(Dense(dense1, activation='relu', kernel_regularizer=regularizers.l2(regularizers_l2_1))) except: model.add(Dense(dense1, activation='relu', kernel_regularizer=regularizers.l2(regularizers_l2_1), input_shape=(train_x.shape[1:]))) # model.add(Dropout(0.25)) model.add(Dense(dense2, activation='relu', kernel_regularizer=regularizers.l2(regularizers_l2_2))) # model.add(Dropout(0.25)) model.add(Dense(dense3, activation='relu', kernel_regularizer=regularizers.l2(regularizers_l2_3))) model.add(Dense(dense4, activation='softmax')) model.summary() # optimizer には adam を指定 adam = keras.optimizers.Adam(lr=learning_rate) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # model.compile(loss='sparse_categorical_crossentropy',optimizer='adam',metrics=['accuracy']) train_y = np.array(train_y) test_y = np.array(test_y) # print(test_y) # print(test_y.shape) # print(type(test_y)) es_cb = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=1000, verbose=0, mode='auto') tb_cb = keras.callbacks.TensorBoard(log_dir=f_log, histogram_freq=1) # cp_cb = keras.callbacks.ModelCheckpoint(filepath = os.path.join(f_model,'tag_model{epoch:02d}-loss{loss:.2f}-acc{acc:.2f}-vloss{val_loss:.2f}-vacc{val_acc:.2f}.hdf5'), monitor='val_loss', verbose=1, save_best_only=True, mode='auto') # cbks = [es_cb, tb_cb, cp_cb] cbks = [es_cb, tb_cb] history = model.fit(train_x, train_y, batch_size=nb_batch, epochs=nb_epoch, validation_data=(test_x, test_y), callbacks=cbks, verbose=1) score = model.evaluate(test_x, test_y, verbose=0) print('Test score:', score[0]) print('Test accuracy:', score[1]) predict = model.predict(test_x) # print('predict:{}'.format(predict)) print('save the architecture of a model') json_string = model.to_json() open(os.path.join(f_model, 'tag_model.json'), 'w').write(json_string) yaml_string = model.to_yaml() open(os.path.join(f_model, 'tag_model.yaml'), 'w').write(yaml_string) print('save weights') model.save_weights(os.path.join(f_model, 'tag_weights.hdf5')) KTF.set_session(old_session) best_pred = [] probability = [] category = np.arange(1, class_number+1) for (i, pre) in enumerate(predict): y = pre.argmax() # preがそれぞれの予測確率で一番高いものを取ってきている。Y_testはone-hotベクトル best_pred.append(category[y]) probability.append(pre[y]) return best_pred, probability
MultiprocessIterator( valid, batch_size=8, #repeat=False, shuffle=False, n_processes=12, n_prefetch=120, shared_mem=1000 * 1000 * 5)) # type: Iterator[Tuple[np.ndarray, np.ndarray]] old_session = tensorflow_backend.get_session() with K.tf.Graph().as_default(): session = K.tf.Session("") tensorflow_backend.set_session(session) tensorflow_backend.set_learning_phase(1) loss = "" # type: Union[Callable, str] metrics = [] # type: List[Union[Callable, str]] input_shape = (resize_shape[0], resize_shape[1], 3) if args.dice_coef: output_ch = 1 loss = dice_coef_loss metrics = [dice_coef] filename = "_weights.epoch{epoch:04d}-val_loss{val_loss:.2f}-val_dice_coef{val_dice_coef:.2f}.hdf5" else: output_ch = 2 loss = "categorical_crossentropy" metrics = ['accuracy'] filename = "_weights.epoch{epoch:04d}-val_loss{val_loss:.2f}-val_acc{val_acc:.2f}.hdf5"
def main(args): # device number if args.gpu_num: os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu # set the necessary list train_list = pd.read_csv(args.train_list, header=None) val_list = pd.read_csv(args.val_list, header=None) # set the necessary directories trainimg_dir = args.trainimg_dir trainmsk_dir = args.trainmsk_dir valimg_dir = args.valimg_dir valmsk_dir = args.valmsk_dir # get old session old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) # set callbacks cp_cb = ModelCheckpoint(filepath=args.log_dir, monitor='val_loss', verbose=1, save_best_only=True, mode='auto', period=2) es_cb = EarlyStopping(monitor='val_loss', patience=2, verbose=1, mode='auto') tb_cb = TensorBoard(log_dir=args.log_dir, write_images=True) # set generater train_gen = data_gen_small(trainimg_dir, trainmsk_dir, train_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) val_gen = data_gen_small(valimg_dir, valmsk_dir, val_list, args.batch_size, [args.input_shape[0], args.input_shape[1]], args.n_labels) # set model pspnet = PSPNet50(input_shape=args.input_shape, n_labels=args.n_labels, output_mode=args.output_mode, upsample_type=args.upsample_type) print(pspnet.summary()) # compile model pspnet.compile(loss=args.loss, optimizer=args.optimizer, metrics=["accuracy"]) # fit with genarater pspnet.fit_generator(generator=train_gen, steps_per_epoch=args.epoch_steps, epochs=args.n_epochs, validation_data=val_gen, validation_steps=args.val_steps, callbacks=[cp_cb, es_cb, tb_cb])
def main(args): # set the necessary list # train_list = pd.read_csv(args.train_list,header=None) # val_list = pd.read_csv(args.val_list,header=None) # set the necessary directories trainimg_dir = args.trainimg_dir trainmsk_dir = args.trainmsk_dir valimg_dir = args.valimg_dir valmsk_dir = args.valmsk_dir # get old session # old_session = KTF.get_session() with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) # set callbacks fpath = './pretrained_mask/' + args.name + '{epoch:02d}.hdf5' cp_cb = ModelCheckpoint(filepath=fpath, monitor='val_loss', verbose=1, mode='auto', period=1) tb_cb = TensorBoard(log_dir="./pretrained_mask", write_graph=True, write_images=True) seq = iaa.Sequential( [ iaa.Crop( px=(0, 16) ), # crop images from each side by 0 to 16px (randomly chosen) iaa.Fliplr(0.5), # horizontally flip 50% of the images sometimes( iaa.Affine( scale={ "x": (0.8, 1.2), "y": (0.8, 1.2) }, # scale images to 80-120% of their size, individually per axis translate_percent={ "x": (-0.2, 0.2), "y": (-0.2, 0.2) }, # translate by -20 to +20 percent (per axis) rotate=(-10, 10), # rotate by -45 to +45 degrees )), ], random_order=True) if args.dataset == 'coco': train_gen = Datahandler_COCO(trainimg_dir, trainmsk_dir).make_batches( batchsize=args.batch_size, inputshape=args.input_shape, augmentation=seq) val_gen = Datahandler_COCO(valimg_dir, valmsk_dir).make_batches( batchsize=args.batch_size, inputshape=args.input_shape, augmentation=None) elif args.dataset == 'pascal_khamba': train_gen = Pascal_Generator(trainimg_dir, trainmsk_dir).make_batches( batchsize=args.batch_size, inputshape=args.input_shape, augmentation=seq) val_gen = Pascal_Generator(valimg_dir, valmsk_dir).make_batches( batchsize=args.batch_size, inputshape=args.input_shape, augmentation=None) else: train_gen = Default_Generator(trainimg_dir, trainmsk_dir).make_batches( batchsize=args.batch_size, inputshape=args.input_shape, augmentation=seq) val_gen = Default_Generator(valimg_dir, valmsk_dir).make_batches( batchsize=args.batch_size, inputshape=args.input_shape, augmentation=None) # set model pspnet = PSPNet50(input_shape=args.input_shape, n_labels=args.n_labels, output_mode=args.output_mode, upsample_type=args.upsample_type) print(pspnet.summary()) if args.load is not None: print("loadinf weights") pspnet.load_weights(args.load) # compile model pspnet.compile(loss=args.loss, optimizer=args.optimizer, metrics=["accuracy"]) # fit with genarater pspnet.fit_generator(generator=train_gen, steps_per_epoch=args.steps, epochs=args.epochs, validation_data=val_gen, validation_steps=args.val_steps, callbacks=[cp_cb, tb_cb], verbose=True) # save model with open("./pretrained_mask/" + args.name + ".json", "w") as json_file: json_file.write(json.dumps(json.loads(pspnet.to_json()), indent=2)) print("save json model done...")
def run_cnn(X_train, X_val, X_test, network_func, n_classes=30, img_shape=(128, 128, 3), optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'], callbacks=None, batch_size=32, steps_per_epoch=64, num_epochs=300, validation_steps=50, path_save_weights=None, path_plot_model=None, dropout=False): train_iter = batch_generator.Batch_generator(X_train, image_shape=img_shape, num_classes=n_classes, batch_size=batch_size, segment=False) val_iter = batch_generator.Batch_generator(X_val, image_shape=img_shape, num_classes=n_classes, batch_size=batch_size, segment=False) old_session = KTF.get_session() # with tf.Graph().as_default(): session = tf.Session() KTF.set_session(session) # if using dropout (a situation when networks would be different between training and testing phase) if dropout: KTF.set_learning_phase(1) inputs = layers.Input(img_shape) output_layer = network_func(inputs, n_classes) model = models.Model(inputs, output_layer) model.summary() model.compile(optimizer=optimizer, loss=loss, metrics=metrics) history = model.fit_generator(train_iter, steps_per_epoch=steps_per_epoch, epochs=num_epochs, verbose=1, validation_data=val_iter, validation_steps=validation_steps, callbacks=callbacks, workers=2) # save model # model.save('./test_log/models/fcn_model.hdf5') if path_save_weights != None: try: model.save_weights(path_save_weights) except: print("Could not save weigths data.") if path_plot_model != None: try: plot_model(model, to_file=path_plot_model) except: print("Could not plot model properly.") # test the prediction print("\n") print("Testing model...") score = model_helper.predict_from_path(model, X_test, img_shape, n_classes) print("\n") print("=====" * 13) print("\n") print("Test score : {:.6f}".format(score[0])) print("Test accuracy : {:.6f}\n".format(score[1])) KTF.set_session(old_session)
def main(): base_dir = '/media/localadmin/Test/11Nils/kitti/dataset/sequences/Data/' label_dir = 'labels/' train_img_dir = 'images/' eval_base_dir = '/media/localadmin/Test/11Nils/kitti/dataset/sequences/08/' eval_lbl_dir = 'labels/' eval_img_dir = 'image_2/' inf_dir = 'pooling_test/' test_no_indices = True if test_no_indices: inf_dir_tested = 'MaxPooling2D/' log = 'log/' gpu_num = '0, 1, 2, 3' else: inf_dir_tested = 'MaxPooling2DWithIndices/' log = 'log_indices/' gpu_num = '2, 3' segnet = True if segnet: inf_dir_tested = 'SegNet/' log = 'log_seg/' gpu_num = '2, 3' label_list = sorted(os.listdir(base_dir + label_dir)) shuffle(label_list) train = label_list[:int(len(label_list) * 0.8)] val = label_list[int(len(label_list) * 0.8):] eval = os.listdir(eval_base_dir + eval_lbl_dir) print(len(train), len(val), len(eval)) with tf.Graph().as_default(): os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = gpu_num session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) trainer = Trainer(_train_list=train, _val_list=val, _inf_list=eval, _gpu_num=gpu_num, _no_inidices=test_no_indices, _segnet=segnet) trainer.base_dir = base_dir trainer.label_dir = label_dir trainer.img_dir = train_img_dir trainer.log_dir = eval_base_dir + inf_dir + log trainer.inf_dir = inf_dir + inf_dir_tested trainer.batch_size = 16 trainer.epoch_steps = 750 trainer.val_steps = 200 trainer.n_epochs = 30 trainer.dag_it = 0 trainer.update_callback() # trains model for defined number of epochs with the actual dataset print('Loading labels from %s' % (trainer.base_dir + trainer.label_dir)) print('Loading imgs from %s' % (trainer.base_dir + trainer.img_dir)) trainer.train() print('\nTraining done!\nStarting Prediction\n') # safes inferences of images that are unseen by the net trainer.base_dir = eval_base_dir trainer.img_dir = eval_img_dir print('Loading labels from %s' % (trainer.base_dir + trainer.label_dir)) print('Loading imgs from %s' % (trainer.base_dir + trainer.img_dir)) trainer.predict() session.close()
ax.text(x - 1, y - 1, part_place_name, color='black', fontsize=15) place_name_list.append(part_place_name) return ax, place_name_list #実際に確認したいターゲットの画像を設定する。 img = cv2.imread("hrei-sign105.png") input_shape = (50, 100, 1) with tf.Graph().as_default(): session = tf.Session('') KTF.set_session(session) KTF.set_learning_phase(1) def schedule(epoch, decay=0.9): return base_lr * decay**(epoch) base_lr = 3e-4 optim = Adam(lr=base_lr) model = spp_model(input_shape, NUM_CLASSES, optim) model.load_weights('./param/learning_place_name.hdf5', by_name=True) result_label_list = predict_img(img, model, place_list, input_shape) print(len(result_label_list))
def run_segmentation(X_train, y_train, X_val, y_val, X_test, y_test, network_func, n_classes=30, img_shape=(128, 128, 3), optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'], callbacks=None, batch_size=32, steps_per_epoch=500, num_epochs=30, validation_steps=65, path_save_weights=None, path_save_pred_images=None, num_save_pred_image=None, dropout=False): # import tensorflow as tf # from keras import backend as K config = tf.ConfigProto() config.gpu_options.per_process_gpu_memory_fraction = 0.90 train_iter = batch_generator.Batch_generator(X_train, target=y_train, image_shape=img_shape, num_classes=n_classes, batch_size=batch_size, segment=True) val_iter = batch_generator.Batch_generator(X_val, target=y_val, image_shape=img_shape, num_classes=n_classes, batch_size=batch_size, segment=True) old_session = KTF.get_session() # with tf.Graph().as_default(): session = tf.Session(config=config) KTF.set_session(session) # if using dropout (a situation when networks would be different between training and testing phase) if dropout: KTF.set_learning_phase(1) inputs = layers.Input(img_shape) output_layer = network_func(inputs, n_classes) model = models.Model(inputs, output_layer) model.summary() model.compile(optimizer=optimizer, loss=loss, metrics=metrics) model.fit_generator(train_iter, steps_per_epoch=steps_per_epoch, epochs=num_epochs, verbose=1, validation_data=val_iter, validation_steps=validation_steps, callbacks=callbacks, workers=2) # save model # model.save('./test_log/models/fcn_model.hdf5') if path_save_weights != None: try: model.save_weights(path_save_weights) except: print("Path to save weigths data is not valid.") # predicting and calculate IoU print("\n") print("=====" * 15) print("\n") print("Testing model...") start = time() # extract data test = np.vstack([ np.expand_dims(misc.imresize(misc.imread(t), img_shape), axis=0) for t in X_test ]) pred = model_helper.prediction(model, test) # predicted data target = pre.pixelwise_class_array(y_test) # ground truths iou = model_helper.ave_iou_score(pred, target) end = time() print("\n") print("IoU score : {:.6f}".format(iou)) print("Calcuration time : {:.6f} sec.".format(end - start)) # Save predicted image if path_save_pred_images != None: print("\n") print("=====" * 15) print("\n") print("Saving predict image...") path_save_pred_images = os.path.join(path_save_pred_images, 'predictions') # create directory pre.makedirs_if_none(path_save_pred_images) # reduce save data if need if num_save_pred_image != None: pred = pred[:num_save_pred_image] X_test = X_test[:num_save_pred_image] # convert from class array to image(rgb) array pred = pre.pixelwise_array_to_img(pred) # Save data for img, file_path in zip(pred, X_test): misc.imsave( os.path.join(path_save_pred_images, os.path.basename(file_path)), img) print("Done.") # close current session KTF.set_session(old_session)