def create_model(): model = WideResNet(image_size, depth=depth, k=k)() # Load weights weight_file = os.path.join("pretrained_models", "weights.18-4.06.hdf5") model.load_weights(weight_file, by_name=True) # # set the first 50 layers # # to non-trainable (weights will not be updated) # print(len(model.layers)) # if freeze_layers > 0 : # for layer in model.layers[:freeze_layers]: # layer.trainable = False # Compile model sgd = SGD(lr=0.1, momentum=0.9, nesterov=True) model.compile(optimizer=sgd, loss=["binary_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() return model
def main(): args = get_args() batch_size = args.batch_size nb_epochs = args.nb_epochs lr = args.lr opt_name = args.opt output_path = Path(__file__).resolve().parent.joinpath(args.output_path) output_path.mkdir(parents=True, exist_ok=True) logging.debug("Loading data...") train_gen = ImageGenerator( "/home/dodat/Documents/python-projects/age-gender-estimation/data/imdb_crop", "imdb", image_size=64, batch_size=batch_size) val_gen = ImageGenerator( "/home/dodat/Documents/python-projects/age-gender-estimation/data/wiki_crop", "wiki", image_size=64, batch_size=batch_size) print(train_gen.len()) print(val_gen.len()) print(train_gen.img_path()) model = WideResNet(64, depth=16, k=8)() opt = get_optimizer(opt_name, lr) model.compile( optimizer=opt, loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs, lr)), ModelCheckpoint(str(output_path) + "/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto") ] logging.debug("Running training...") hist = model.fit_generator(generator=train_gen, epochs=nb_epochs, validation_data=val_gen, verbose=1, callbacks=callbacks) logging.debug("Saving history...") pd.DataFrame(hist.history).to_hdf( output_path.joinpath("history_{}_{}.h5".format(16, 8)), "history")
def main(): args = get_args() input_path = args.input batch_size = args.batch_size nb_epochs = args.nb_epochs depth = args.depth k = args.width validation_split = args.validation_split logging.debug("Loading data...") image, gender, age, _, image_size, _ = load_data(input_path) X_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, 101) model = WideResNet(image_size, depth=depth, k=k)() sgd = SGD(lr=0.1, momentum=0.9, nesterov=True) model.compile( optimizer=sgd, loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() logging.debug("Saving model...") mk_dir("models") with open(os.path.join("models", "WRN_{}_{}.json".format(depth, k)), "w") as f: f.write(model.to_json()) mk_dir("checkpoints") callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs)), ModelCheckpoint("checkpoints/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto") ] logging.debug("Running training...") hist = model.fit(X_data, [y_data_g, y_data_a], batch_size=batch_size, epochs=nb_epochs, callbacks=callbacks, validation_split=validation_split) logging.debug("Saving weights...") model.save_weights(os.path.join("models", "WRN_{}_{}.h5".format(depth, k)), overwrite=True) pd.DataFrame(hist.history).to_hdf( os.path.join("models", "history_{}_{}.h5".format(depth, k)), "history")
def main(): args = get_args() input_path = args.input batch_size = args.batch_size nb_epochs = args.nb_epochs depth = args.depth k = args.width validation_split = args.validation_split use_augmentation = args.aug output_path = Path(__file__).resolve().parent.joinpath(args.output_path) output_path.mkdir(parents=True, exist_ok=True) logging.debug("Loading data...") image, gender, age, _, image_size, _ = load_data(input_path) X_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, 101) model = WideResNet(image_size, depth=depth, k=k)() sgd = SGD(lr=0.1, momentum=0.9, nesterov=True) model.compile( optimizer=sgd, loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs)), ModelCheckpoint(str(output_path) + "/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto") ] logging.debug("Running training...") data_num = len(X_data) indexes = np.arange(data_num) np.random.shuffle(indexes) X_data = X_data[indexes] y_data_g = y_data_g[indexes] y_data_a = y_data_a[indexes] train_num = int(data_num * (1 - validation_split)) X_train = X_data[:train_num] X_test = X_data[train_num:] y_train_g = y_data_g[:train_num] y_test_g = y_data_g[train_num:] y_train_a = y_data_a[:train_num] y_test_a = y_data_a[train_num:] if use_augmentation: datagen = ImageDataGenerator(width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, preprocessing_function=get_random_eraser( v_l=0, v_h=255)) training_generator = MixupGenerator(X_train, [y_train_g, y_train_a], batch_size=batch_size, alpha=0.2, datagen=datagen)() hist = model.fit_generator(generator=training_generator, steps_per_epoch=train_num // batch_size, validation_data=(X_test, [y_test_g, y_test_a]), epochs=nb_epochs, verbose=1, callbacks=callbacks) else: hist = model.fit(X_train, [y_train_g, y_train_a], batch_size=batch_size, epochs=nb_epochs, callbacks=callbacks, validation_data=(X_test, [y_test_g, y_test_a])) logging.debug("Saving history...") pd.DataFrame(hist.history).to_hdf( output_path.joinpath("history_{}_{}.h5".format(depth, k)), "history")
def main(): args = get_args() input_agender_path = args.input_agender input_emotion_path = args.input_emotion batch_size = args.batch_size nb_epochs = args.nb_epochs lr = args.lr staircase_decay_at_epochs = args.staircase_decay_at_epochs opt_name = args.opt depth = args.depth k = args.width validation_split = args.validation_split use_augmentation = args.aug output_path = Path(__file__).resolve().parent.joinpath(args.output_path) output_path.mkdir(parents=True, exist_ok=True) logging.debug("Loading data...") # load imdb: 171852 images # loadk wiki: 38138 images imdb_imgs, imdb_genders, imdb_ages, _, _, _ = load_imdb_or_wiki( input_agender_path) # gender_class_weight = class_weight.compute_class_weight('balanced', np.unique(imdb_genders), imdb_genders) # age_class_weight = class_weight.compute_class_weight('balanced', np.unique(imdb_ages), imdb_ages) if small_volume != 0: imdb_imgs = imdb_imgs[0:small_volume] imdb_genders = imdb_genders[0:small_volume] imdb_ages = imdb_ages[0:small_volume] imdb_genders = np_utils.to_categorical(imdb_genders, 2) imdb_ages = np_utils.to_categorical(imdb_ages, 101) imdb_emotions = np.full((len(imdb_imgs), emotion_class_num), 0) # imdb_emotions = np.full((len(imdb_imgs), emotion_class_num), -1, dtype=np.int8) print( 'imdb_imgs.shape: {}, imdb_genders.shape: {}, imdb_ages.shape: {}, imdb_emotions.shape: {}' .format(imdb_imgs.shape, imdb_genders.shape, imdb_ages.shape, imdb_emotions.shape)) # load fer2013: 35887 images fer_imgs, fer_emotions = load_fer2013(input_emotion_path, resize=(image_size, image_size)) # emotion_class_weight = class_weight.compute_class_weight('balanced', np.unique(fer_emotions), fer_emotions) if small_volume != 0: fer_imgs = fer_imgs[0:small_volume] fer_emotions = fer_emotions[0:small_volume] fer_imgs = np.squeeze(np.stack((fer_imgs, ) * 3, -1)) # convert gray into color fer_emotions = pd.get_dummies(fer_emotions).as_matrix() fer_genders = np.full((len(fer_imgs), 2), 0) fer_ages = np.full((len(fer_imgs), 101), 0) # fer_genders = np.full((len(fer_imgs), 2), -1, dtype=np.int8) # fer_ages = np.full((len(fer_imgs), 101), -1, dtype=np.int8) print( 'fer_imgs.shape: {}, fer_genders.shape: {}, fer_ages.shape: {}, fer_emotions.shape: {}' .format(fer_imgs.shape, fer_genders.shape, fer_ages.shape, fer_emotions.shape)) logging.debug("Splitting data...") # split imdb into train and validate set imdb_imgs_train, imdb_imgs_val, imdb_genders_train, imdb_genders_val, imdb_ages_train, imdb_ages_val, imdb_emotions_train, imdb_emotions_val \ = train_test_split( imdb_imgs, imdb_genders, imdb_ages, imdb_emotions, test_size=validation_split, shuffle=False) print( 'imdb_imgs_train.shape: {}, imdb_imgs_val.shape: {}, imdb_genders_train.shape: {}, imdb_genders_val.shape: {}, imdb_ages_train.shape: {} \ , imdb_ages_val.shape: {}, imdb_emotions_train.shape: {}, imdb_emotions_val.shape: {}' .format(imdb_imgs_train.shape, imdb_imgs_val.shape, imdb_genders_train.shape, imdb_genders_val.shape, imdb_ages_train.shape, imdb_ages_val.shape, imdb_emotions_train.shape, imdb_emotions_val.shape)) # split fer2013 into train and validate set fer_imgs_train, fer_imgs_val, fer_genders_train, fer_genders_val, fer_ages_train, fer_ages_val, fer_emotions_train, fer_emotions_val \ = train_test_split( fer_imgs, fer_genders, fer_ages, fer_emotions, test_size=validation_split, shuffle=False) print( 'fer_imgs_train.shape: {}, fer_imgs_val.shape: {}, fer_genders_train.shape: {}, fer_genders_val.shape: {}, fer_ages_train.shape: {} \ , fer_ages_val.shape: {}, fer_emotions_train.shape: {}, fer_emotions_val.shape: {}' .format(fer_imgs_train.shape, fer_imgs_val.shape, fer_genders_train.shape, fer_genders_val.shape, fer_ages_train.shape, fer_ages_val.shape, fer_emotions_train.shape, fer_emotions_val.shape)) # merge imdb and fer2013 validate set logging.debug("Merge validation set...") X_val = np.vstack((imdb_imgs_val, fer_imgs_val)) y_genders_val = np.vstack((imdb_genders_val, fer_genders_val)) y_ages_val = np.vstack((imdb_ages_val, fer_ages_val)) y_emotions_val = np.vstack((imdb_emotions_val, fer_emotions_val)) model = WideResNet(image_size, depth=depth, k=k)() opt = get_optimizer(opt_name, lr) # model.compile(optimizer=opt, # loss=[myloss, myloss, myloss], # metrics=['accuracy']) model.compile(optimizer=opt, loss={ 'output_gender': 'categorical_crossentropy', 'output_age': 'categorical_crossentropy', 'output_emotion': 'categorical_crossentropy' }, metrics={ 'output_gender': 'accuracy', 'output_age': myMAE, 'output_emotion': 'accuracy' }) logging.debug("Model summary...") # model.count_params() model.summary() # Total params: 25,381,360 # Trainable params: 25,374,160 # Non-trainable params: 7,200 # print(model.get_layer(name='conv2d_1').kernel_regularizer) lr_schedule = LearningRateScheduler( schedule=StaircaseSchedule(staircase_decay_at_epochs, lr)) # lr_schedule = LearningRateScheduler(schedule=Schedule(nb_epochs, lr)) callbacks = [ lr_schedule, ModelCheckpoint(str(output_path) + "/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto"), TensorBoard(log_dir='./logs', write_graph=True, write_images=True), CSVLogger('logs/train_log.csv', append=False) ] logging.debug("Running training...") # if use_augmentation: # datagen_agender = ImageDataGenerator( # width_shift_range=0.1, # height_shift_range=0.1, # horizontal_flip=True, # preprocessing_function=get_random_eraser(v_l=0, v_h=255)) # datagen_emotion = ImageDataGenerator( # featurewise_center=False, # featurewise_std_normalization=False, # rotation_range=10, # width_shift_range=0.1, # height_shift_range=0.1, # zoom_range=.1, # horizontal_flip=True) # datagen_agender = ImageDataGenerator( # featurewise_center=False, # featurewise_std_normalization=False, # rotation_range=10, # width_shift_range=0.1, # height_shift_range=0.1, # zoom_range=.1, # horizontal_flip=True, # preprocessing_function=get_random_eraser(v_l=0, v_h=255)) # training_generator = MixupGenerator(X_train, [y_genders_train, y_ages_train, y_emotions_train], # batch_size=batch_size, # alpha=0.2, # datagen=datagen_agender)() # else: # hist = model.fit(X_train, [y_genders_train, y_ages_train, y_emotions_train], batch_size=batch_size, # epochs=nb_epochs, # callbacks=callbacks, # validation_data=(X_val, [y_genders_val, y_ages_val, y_emotions_val])) # fit_class_weight = {'output_gender': dict(enumerate(gender_class_weight)), # 'output_age': dict(enumerate(age_class_weight)), # 'output_emotion': dict(enumerate(emotion_class_weight))} hist = model.fit_generator( generator=sample_generator((imdb_imgs_train, imdb_genders_train, imdb_ages_train, imdb_emotions_train), (fer_imgs_train, fer_genders_train, fer_ages_train, fer_emotions_train), batch_size=32), steps_per_epoch=(len(imdb_imgs_train) + len(fer_imgs_train)) // batch_size, validation_data=(X_val, [y_genders_val, y_ages_val, y_emotions_val]), epochs=nb_epochs, verbose=1, callbacks=callbacks) logging.debug("Saving history...") pd.DataFrame(hist.history).to_hdf( output_path.joinpath("history_{}_{}.h5".format(depth, k)), "history")
image, gender, age = ft.load_data("serializer/MATimdb64.mat") x_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, 101) # Fatores importantes: # optimizers, largura da rede, profundidade da rede, losses, val_split, # model WidesResNet (WRN) dupla saida(age,gender) model = WideResNet(64, depth=16, k=8)() #model.summary() #optimizers model.compile(SGD(lr=0.1, momentum=0.9, nesterov=True), loss=['categorical_crossentropy', 'categorical_crossentropy'], metrics=['accuracy']) #Pre-process Base validation_split = 0.1 data_num = len(x_data) #Randomizar base indexes = np.arange(data_num) np.random.shuffle(indexes) x_data = x_data[indexes] y_data_g = y_data_g[indexes] #Gender y_data_a = y_data_a[indexes] #Age train_num = int(data_num * (1 - validation_split))
def train_from_db(): ''' train the solution gadget: CNN "WideResNet" WideResNet is designed to predict both age and gender; I am omitting gender prediction for my project ''' data = scipy.io.loadmat('utk.mat') # initialize model for training model = WideResNet(data['img_size'][0, 0])() model.compile( optimizer=SGD(lr=0.1, momentum=0.9, nesterov=True), loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy'], ) model.summary() nb_epochs = 32 lr = 0.1 callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs, lr)), ModelCheckpoint( "weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto", ) ] X_data = data['image'] y_data_a = np_utils.to_categorical(data['age'][0], 101) y_data_g = np_utils.to_categorical( [0] * len(data['age'][0]), 2) # place holder for unused gender output indexes = np.arange(len(X_data)) np.random.shuffle(indexes) # shuffle the dataset X_data = X_data[indexes] y_data_a = y_data_a[indexes] # train on 90%; validate on 10% train_num = int(len(X_data) * (1 - 0.1)) X_train = X_data[:train_num] X_test = X_data[train_num:] y_train_g = y_data_g[:train_num] y_test_g = y_data_g[train_num:] y_train_a = y_data_a[:train_num] y_test_a = y_data_a[train_num:] # training hist = model.fit( X_train, [y_train_g, y_train_a], batch_size=32, epochs=nb_epochs, callbacks=callbacks, validation_data=(X_test, [y_test_g, y_test_a]), )
def main(): args = get_args() input_path = args.input batch_size = args.batch_size nb_epochs = args.nb_epochs freeze_layers = args.freeze_layers depth = args.depth k = args.width validation_split = args.validation_split logging.debug("Loading data...") image, gender, age, _, image_size, _ = load_data(input_path) X_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, 101) #Load weights weight_file = os.path.join("pretrained_models", "weights.18-4.06.hdf5") model = WideResNet(image_size, depth=depth, k=k)() model.load_weights(weight_file) # set the first 50 layers # to non-trainable (weights will not be updated) print(len(model.layers)) if freeze_layers > 0: for layer in model.layers[:freeze_layers]: layer.trainable = False sgd = SGD(lr=0.1, momentum=0.9, nesterov=True) model.compile( optimizer=sgd, loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() logging.debug("Saving model...") mk_dir("models") with open(os.path.join("models", "WRN_{}_{}.json".format(depth, k)), "w") as f: f.write(model.to_json()) mk_dir("checkpoints") callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs)), ModelCheckpoint("checkpoints/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto") ] logging.debug("Running training...") # print('length of X', len(X_data)) # print('length of y_data_g', y_data_g) # print('length of y_data_a', len(y_data_a)) hist = model.fit(X_data, [y_data_g, y_data_a], batch_size=batch_size, epochs=nb_epochs, callbacks=callbacks, validation_split=validation_split) logging.debug("Saving weights...") model.save_weights(os.path.join("models", "WRN_{}_{}.h5".format(depth, k)), overwrite=True) pd.DataFrame(hist.history).to_hdf( os.path.join("models", "history_{}_{}.h5".format(depth, k)), "history")
def main(): args = get_args() input_path = args.input batch_size = args.batch_size*args.gpus nb_epochs = args.nb_epochs depth = args.depth k = args.width validation_split = args.validation_split img_size = args.img_size val_path = args.val_path pretrained_fil = args.pretrained_fil input_shape = [img_size, img_size, 3] patience = 30 gpu_num = args.gpus train_db = args.db logging.debug("Loading data...") ''' image, gender, age, _, image_size, _ = load_data(input_path) X_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, 101) ''' batchdataload = BatchLoader(input_path,batch_size,img_size,train_db) valdataload = BatchLoader(val_path,batch_size,img_size) model = WideResNet(img_size, depth=depth, k=k)() #model = mini_XCEPTION(input_shape,101) with open(os.path.join("ag_models", "WRN_{}_{}.json".format(depth, k)), "w") as f: f.write(model.to_json()) if pretrained_fil : model.load_weights(pretrained_fil) #sgd = SGD(lr=0.001, momentum=0.7, nesterov=True) adam = Adam(lr=0.0001,beta_1=0.9,beta_2=0.999,epsilon=1e-5) #model.compile(optimizer=sgd, loss=["categorical_crossentropy", "categorical_crossentropy"], # metrics=['accuracy']) #if gpu_num >1: #model = multi_gpu_model(model,gpu_num) model.compile(optimizer=adam, loss=["categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") #model.count_params() model.summary() logging.debug("Saving model...") if not os.path.exists("./ag_models"): mk_dir("ag_models") reduce_lr = ReduceLROnPlateau(monitor="val_loss",factor=0.1,patience=patience*2,verbose=1,min_lr=0.0000001) early_stop = EarlyStopping('val_loss', patience=patience) modelcheckpoint = ModelCheckpoint("ag_models/weights.{epoch:02d}-{val_loss:.2f}.hdf5",\ monitor="val_loss",verbose=1,save_best_only=True,mode="auto",period=1000) #mk_dir("checkpoints") #reduce_lr = LearningRateScheduler(schedule=reduce_lr) #callbacks = [modelcheckpoint,early_stop,reduce_lr] callbacks = [modelcheckpoint,reduce_lr] logging.debug("Running training...") #whole training error_min = 0 if whole_data : hist = model.fit_generator(data_geneter(batchdataload), steps_per_epoch=batchdataload.batch_num, epochs=nb_epochs, verbose=1, callbacks=callbacks, validation_data=data_geneter(valdataload), nb_val_samples=valdataload.batch_num, nb_worker=1) logging.debug("Saving weights...") model.save_weights(os.path.join("ag_models", "WRN_{}_{}.h5".format(depth, k)),overwrite=True) #pd.DataFrame(hist.history).to_hdf(os.path.join("ag_models", "history_{}_{}.h5".format(depth, k)), "history") else: epoch_step = 0 while epoch_step < nb_epochs: step = 0 while step < batchdataload.batch_num: #X_data, y_data_g, y_data_a = batch_geneter(batchdataload) X_data, y_data_g = batch_geneter(batchdataload) #hist = model.fit(X_data, [y_data_g, y_data_a], batch_size=batch_size, epochs=1, verbose=2) hist = model.fit(X_data, y_data_g, batch_size=batch_size, epochs=1, verbose=2) step+=1 if step % 100 ==0: #val_data,val_g,val_a = batch_geneter(valdataload) val_data,val_g = batch_geneter(valdataload) #error_t = model.evaluate(val_data,[val_g,val_a],batch_size=batch_size,verbose=1) error_t = model.evaluate(val_data,val_g,batch_size=batch_size,verbose=1) print ("****** Epoch {} Step {}: ***********".format(str(epoch_step),str(step)) ) print (" loss: {}".format(error_t)) if epoch_step % 5 ==0: #logging.debug("Saving weights...") #val_data,val_g,val_a = batch_geneter(valdataload) #error_t = model.evaluate(val_data,[val_g,val_a],batch_size=batch_size,verbose=1) if error_t[4] >error_min: logging.debug("Saving weights...") model.save_weights(os.path.join("ag_models", "WRN_{}_{}_epoch{}_step{}.h5".format(depth, k,epoch_step,step))) error_min = error_t[4] epoch_step+=1 if epoch_step % 5 ==0: logging.debug("Saving weights...") #val_data,val_g,val_a = batch_geneter(valdataload) val_data,val_g = batch_geneter(valdataload) #error_t = model.evaluate(val_data,[val_g,val_a],batch_size=batch_size,verbose=1) error_t = model.evaluate(val_data,val_g,batch_size=batch_size,verbose=1) if error_t[1] >error_min: model.save_weights(os.path.join("ag_models", "WRN_{}_{}_epoch{}.h5".format(depth, k,epoch_step))) error_min = error_t[4] error_min =0
def main(): logging.debug("Reading Configuration...") args = get_args() Config = configparser.ConfigParser() Config.read(args.config_path) def ConfigSectionMap(section): dict1 = {} options = Config.options(section) for option in options: try: dict1[option] = Config.get(section, option) if dict1[option] == -1: DebugPrint("skip: %s" % option) except: print("exception on %s!" % option) dict1[option] = None return dict1 #Loading Fixed parameters input_path = ConfigSectionMap("Fixed")['input_path'] batch_size = int(ConfigSectionMap("Fixed")['batch_size']) nb_epochs = int(ConfigSectionMap("Fixed")['nb_epochs']) validation_split = float(ConfigSectionMap("Fixed")['validation_split']) dim = int(ConfigSectionMap("Fixed")['dimension']) use_augmentation = bool(ConfigSectionMap("Fixed")['use_augmentation']) metrics_type = ConfigSectionMap("Fixed")['metrics'] history = ConfigSectionMap("Fixed")['history_save_path'] checkpoints = ConfigSectionMap("Fixed")['checkpoint_save_path'] logs_dir = ConfigSectionMap("Fixed")['log_save_path'] #Loading parameters that vary over different configurations config_number = args.config_number distribution = ConfigSectionMap(config_number)['distribution'] feature_extractor = ConfigSectionMap(config_number)['feature_extractor'] sigma = float(ConfigSectionMap(config_number)['sigma']) optimizer_type = ConfigSectionMap(config_number)['optimizer'] loss_type = ConfigSectionMap(config_number)['loss'] logging.debug("Loading data...") image, _, age, _, image_size, _ = load_data(input_path) X_data = image #Alter age according to distribution type if distribution == "GaussBins": age = age[:,np.newaxis] lin_y = np.linspace(0,100,dim)[:,np.newaxis] y_data_a = (1/(sigma*np.sqrt(2*np.pi)))*np.exp(-np.square((age-lin_y.T)/(np.sqrt(2)*sigma))) elif distribution == "Cls": y_data_a = np_utils.to_categorical(age, dim) print(y_data_a.shape) data_num = len(X_data) #Randomly shuffle data indexes = np.arange(data_num) np.random.shuffle(indexes) X_data = X_data[indexes] y_data_a = y_data_a[indexes] #Split in test train set train_num = int(data_num * (1 - validation_split)) X_train = X_data[:train_num] X_test = X_data[train_num:] y_train_a = y_data_a[:train_num] y_test_a = y_data_a[train_num:] #Choose network if feature_extractor == "WideResNet": model = WideResNet(image_size, depth=16, k=8)() #Choose optimizer if optimizer_type == "sgd": optimizer = SGD(lr=0.1, momentum=0.9, nesterov=True) #Choose loss if loss_type == "kullback_leibler_divergence": loss = "kullback_leibler_divergence" elif loss_type == "Wasserstein": loss = Wasserstein elif loss_type == "wass1": loss = Wass1 elif loss_type == "loss1": loss = custom_loss1 elif loss_type == "loss2": loss = custom_loss2 elif loss_type == "loss3": loss = "mean_squared_error" elif loss_type == "loss4": loss = "mean_absolute_error" elif loss_type == "categorical_crossentropy": loss = "categorical_crossentropy" #Choose metric if metrics_type == "mean_absolute_error": metric = mean_absolute_error #Final compilation model.compile(optimizer=optimizer, loss=[loss], metrics=[metric]) logging.debug("Model summary...") model.count_params() # model.summary() #Callbacks json_log = open(os.path.join(logs_dir,"{}_{}_{:.5}_{}_{}.log".format(distribution,feature_extractor,loss_type,optimizer_type,sigma)), mode='wt', buffering=1) logging_callback = LambdaCallback( on_train_begin=lambda logs: json_log.write( json.dumps({'distribution': distribution, 'feature_extractor': feature_extractor, 'loss_type': loss_type, 'optimizer_type': optimizer_type, 'sigma': sigma}) + '\n'), on_epoch_end=lambda epoch, logs: json_log.write( json.dumps({'epoch': epoch, 'val_mean_absolute_error': logs['val_mean_absolute_error'], 'val_loss': logs['val_loss'], 'mean_absolute_error': logs['mean_absolute_error'], 'loss': logs['loss']}) + '\n'), on_train_end=lambda logs: json_log.close() ) callbacks = [LearningRateScheduler(schedule=Schedule(nb_epochs)), ModelCheckpoint(os.path.join(checkpoints,"weights.{}_{}_{:.5}_{}_{}.hdf5".format(distribution,feature_extractor,loss_type,optimizer_type,sigma)), monitor="val_mean_absolute_error", verbose=1, save_best_only=True, mode="auto"), logging_callback, TensorBoard(log_dir=os.path.join(logs_dir,"{}_{}_{:.5}_{}_{}/".format(distribution,feature_extractor,loss_type,optimizer_type,sigma)), histogram_freq=0, batch_size=batch_size, write_graph=False, write_grads=False, write_images=False) ] logging.debug("Running training...") if use_augmentation: datagen = ImageDataGenerator( width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, preprocessing_function=get_random_eraser(v_l=0, v_h=255)) training_generator = MixupGenerator(X_train, y_train_a, batch_size=batch_size, alpha=0.2, datagen=datagen)() hist = model.fit_generator(generator=training_generator, steps_per_epoch=train_num // batch_size, validation_data=(X_test, y_test_a), epochs=nb_epochs, verbose=1, callbacks=callbacks) else: hist = model.fit(X_train, y_train_a, batch_size=batch_size, epochs=nb_epochs, verbose=1, callbacks=callbacks, validation_data=(X_test, y_test_a)) logging.debug("Saving history and graphs...") pd.DataFrame(hist.history).to_hdf(os.path.join(history, "history.{}_{}_{:.5}_{}_{}.hdf5".format(distribution,feature_extractor,loss_type,optimizer_type,sigma)), "history")
model_path = 'model' if not os.path.exists(model_path): os.mkdir(model_path) image_size = 128 batch_size = 64 nb_epochs = 30 # depth of network (should be 10, 16, 22, 28, ...) # width of network (should be 2, 4, 6, 8, 10, ...) model = WideResNet(image_size, depth=16, k=4)() model.load_weights('model/weights.24-5.84.hdf5', by_name=True) sgd = SGD(lr=0.002, momentum=0.9, nesterov=True) model.compile( optimizer=sgd, loss=["categorical_crossentropy", "categorical_crossentropy"]) gen = Generator(train_full_path="images/imdb_detect/imdb.csv", \ valid_full_path="images/wiki_detect/wiki.csv", \ image_size=image_size, \ batch_size=batch_size) callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs)), ModelCheckpoint("model/weights.{epoch:02d}-{val_loss:.2f}.hdf5", verbose=1, save_weights_only=True) ] history = model.fit_generator(
def main(): args = get_args() input_path = args.input batch_size = args.batch_size nb_epochs = args.nb_epochs depth = args.depth k = args.width validation_split = args.validation_split use_augmentation = args.aug logging.debug("Loading data...") image, gender, age, _, image_size, _ = load_data(input_path) X_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, 101) model = WideResNet(image_size, depth=depth, k=k)() sgd = SGD(lr=0.1, momentum=0.9, nesterov=True) model.compile(optimizer=sgd, loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() logging.debug("Saving model...") mk_dir("models") with open(os.path.join("models", "WRN_{}_{}.json".format(depth, k)), "w") as f: f.write(model.to_json()) mk_dir("checkpoints") callbacks = [LearningRateScheduler(schedule=Schedule(nb_epochs)), ModelCheckpoint("checkpoints/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto") ] logging.debug("Running training...") data_num = len(X_data) indexes = np.arange(data_num) np.random.shuffle(indexes) X_data = X_data[indexes] y_data_g = y_data_g[indexes] y_data_a = y_data_a[indexes] train_num = int(data_num * (1 - validation_split)) X_train = X_data[:train_num] X_test = X_data[train_num:] y_train_g = y_data_g[:train_num] y_test_g = y_data_g[train_num:] y_train_a = y_data_a[:train_num] y_test_a = y_data_a[train_num:] if use_augmentation: datagen = ImageDataGenerator( width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, preprocessing_function=get_random_eraser(v_l=0, v_h=255)) training_generator = MixupGenerator(X_train, [y_train_g, y_train_a], batch_size=batch_size, alpha=0.2, datagen=datagen)() hist = model.fit_generator(generator=training_generator, steps_per_epoch=train_num // batch_size, validation_data=(X_test, [y_test_g, y_test_a]), epochs=nb_epochs, verbose=1, callbacks=callbacks) else: hist = model.fit(X_train, [y_train_g, y_train_a], batch_size=batch_size, epochs=nb_epochs, callbacks=callbacks, validation_data=(X_test, [y_test_g, y_test_a])) logging.debug("Saving weights...") model.save_weights(os.path.join("models", "WRN_{}_{}.h5".format(depth, k)), overwrite=True) pd.DataFrame(hist.history).to_hdf(os.path.join("models", "history_{}_{}.h5".format(depth, k)), "history")
def main(): args = get_args() input_path = args.input batch_size = args.batch_size nb_epochs = args.nb_epochs max_age = args.max_age + 1 depth = args.depth k = args.width transfer_learning = args.transfer_learning validation_split = args.validation_split use_augmentation = args.aug initial_weights = '/home/paula/THINKSMARTER_/Model/demographics-model-prediction/pretrained_models/weights.18-4.06.hdf5' # weight_file = '/home/paula/THINKSMARTER_/Model/age-gender-estimation-adapted/checkpoints/weights.09-4.32.hdf5' _weight_decay = 0.0005 _use_bias = False _weight_init = "he_normal" logging.debug("Loading data...") image, gender, age, _, image_size, _ = load_data(input_path) X_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, max_age) if transfer_learning: model = WideResNet(image_size, depth=depth, k=k, units_age=101)() model.load_weights(initial_weights) inputs = model.input flatten = model.layers[-3].output # capa flatten dense1 = Dense(units=2, kernel_initializer=_weight_init, use_bias=_use_bias, kernel_regularizer=l2(_weight_decay), activation="softmax")(flatten) dense2 = Dense(units=117, kernel_initializer=_weight_init, use_bias=_use_bias, kernel_regularizer=l2(_weight_decay), activation="softmax")(flatten) model = Model(inputs=inputs, outputs=[dense1, dense2]) # --------------------------------- # IDEA: fine tuning (nomes entreno les dos ultimes capes) # for layer in model.layers[:-2]: # layer.trainable = False else: model = WideResNet(image_size, depth=depth, k=k, units_age=max_age)() sgd = SGD(lr=0.1, momentum=0.9, nesterov=True) model.compile( optimizer=sgd, loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() if args.plot_model: plot_model(model, to_file='experiments_pictures/model_plot.png', show_shapes=True, show_layer_names=True) logging.debug("Saving model...") mk_dir("models") with open(os.path.join("models", "WRN_{}_{}.json".format(depth, k)), "w") as f: f.write(model.to_json()) mk_dir("checkpoints") # tensorBoard = TensorBoard(log_dir='events', histogram_freq=0, batch_size=32, write_graph=True, write_grads=False, write_images=True, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None, embeddings_data=None) callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs)), ModelCheckpoint("checkpoints/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=True, mode="auto") ] logging.debug("Running training...") data_num = len(X_data) indexes = np.arange(data_num) np.random.shuffle(indexes) X_data = X_data[indexes] y_data_g = y_data_g[indexes] y_data_a = y_data_a[indexes] train_num = int(data_num * (1 - validation_split)) X_train = X_data[:train_num] X_test = X_data[train_num:] y_train_g = y_data_g[:train_num] y_test_g = y_data_g[train_num:] y_train_a = y_data_a[:train_num] y_test_a = y_data_a[train_num:] if use_augmentation: datagen = ImageDataGenerator(width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, preprocessing_function=get_random_eraser( v_l=0, v_h=255)) training_generator = MixupGenerator(X_train, [y_train_g, y_train_a], batch_size=batch_size, alpha=0.2, datagen=datagen)() hist = model.fit_generator(generator=training_generator, steps_per_epoch=train_num // batch_size, validation_data=(X_test, [y_test_g, y_test_a]), epochs=nb_epochs, verbose=1, callbacks=callbacks) else: hist = model.fit(X_train, [y_train_g, y_train_a], batch_size=batch_size, epochs=nb_epochs, callbacks=callbacks, validation_data=(X_test, [y_test_g, y_test_a])) logging.debug("Saving weights...") model.save_weights(os.path.join("models", "WRN_{}_{}.h5".format(depth, k)), overwrite=True) pd.DataFrame(hist.history).to_hdf( os.path.join("models", "history_{}_{}.h5".format(depth, k)), "history") with open('history_tmp.txt', 'w') as f: for key in hist.history: print(key, file=f) f.write('\n') json.dump(hist.history, f)
def main(): nb_class = 2 args = get_args() input_path = args.input batch_size = args.batch_size nb_epochs = args.nb_epochs lr = args.lr opt_name = args.opt depth = args.depth k = args.width validation_split = args.validation_split output_path = Path(__file__).resolve().parent.joinpath(args.output_path) output_path.mkdir(parents=True, exist_ok=True) logging.debug("Loading data...") image, gender, age, _, image_size, _ = load_data(input_path) X_data = image y_data_g = np_utils.to_categorical(gender, 2) y_data_a = np_utils.to_categorical(age, 101) #vggface = VGGFace(model='resnet50') # vgg_model = VGGFace(model='resnet50', include_top=False, input_shape=(224, 224, 3)) last_layer = vgg_model.get_layer('avg_pool').output x = Flatten(name='flatten')(last_layer) out = Dense(nb_class, activation='softmax', name='classifier')(x) custom_vgg_model = Model(vgg_model.input, out) # model = WideResNet(image_size, depth=depth, k=k)() opt = get_optimizer(opt_name, lr) model.compile( optimizer=opt, loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy']) logging.debug("Model summary...") model.count_params() model.summary() callbacks = [ LearningRateScheduler(schedule=Schedule(nb_epochs, lr)), ModelCheckpoint(str(output_path) + "/weights.{epoch:02d}-{val_loss:.2f}.hdf5", monitor="val_loss", verbose=1, save_best_only=False, mode="auto") ] logging.debug("Running training...") data_num = len(X_data) indexes = np.arange(data_num) np.random.shuffle(indexes) X_data = X_data[indexes] y_data_g = y_data_g[indexes] y_data_a = y_data_a[indexes] train_num = int(data_num * (1 - validation_split)) X_train = X_data[:train_num] X_test = X_data[train_num:] y_train_g = y_data_g[:train_num] y_test_g = y_data_g[train_num:] y_train_a = y_data_a[:train_num] y_test_a = y_data_a[train_num:] hist = model.fit(X_train, [y_train_g, y_train_a], batch_size=batch_size, epochs=nb_epochs, callbacks=callbacks, validation_data=(X_test, [y_test_g, y_test_a])) logging.debug("Saving history...") pd.DataFrame(hist.history).to_hdf( output_path.joinpath("history_{}_{}.h5".format(depth, k)), "history")