def evaluate(get_labels=0, bb_only=False): # load top model architecture if bb_only: num_classes = 4 else: num_classes = 38 top_model = create_model(num_classes=num_classes, weights='best_weights/defrost_all_bb_8.hdf5', activation=None) top_model.compile(optimizer=optimizers.Adam(), loss='mean_absolute_error', metrics=['accuracy']) # load pickled parts info unpickled_test = pickle.load(open('cache/bb_validation.p', 'rb')) time_start = time.time() if get_labels: test_generator = utils.img_parts_generator(part_file_name, validation_data_dir, batch_size=get_labels, unpickled=unpickled_test, load_image=True, bb_only=bb_only) else: test_generator = utils.img_parts_generator(part_file_name, validation_data_dir, batch_size=4500, unpickled=unpickled_test, load_image=True, bb_only=bb_only) if get_labels: x = [] y = [] y_pred = [] j = 0 for inp, label in test_generator: preds = top_model.predict_on_batch(inp) if not x: x = inp y = label y_pred = preds else: x = np.concatenate((x, inp)) y = np.concatenate((y, label)) y_pred = np.concatenate((y_pred, preds)) j += 1 if j == 1: break return x, y, y_pred else: test_eval = [] j = 0 for inp, label in test_generator: res = top_model.evaluate(inp, label, verbose=0, batch_size=400) test_eval.append(res) test_eval = np.mean(test_eval, axis=0) print('Loss: {:.4f} Evaluate{:.4f}'.format(test_eval[0], test_eval[1])) time_taken = time.time() - time_start
def train_top_model(): # load top model architecture top_model, _, _ = create_top_model(num_classes=500) top_model.compile(optimizer=optimizers.Adam(), loss='categorical_crossentropy', metrics=['accuracy',metrics.top_k_categorical_accuracy]) best_val_loss = 100 f = open('console_dumps/{}.txt'.format(exp_name),'w') unpickled_train = pickle.load(open('cache/parts_train.p','rb')) unpickled_valid = pickle.load(open('cache/parts_validation.p','rb')) #unpickled_test = pickle.load(open('cache/parts_test.p','rb')) for i in range(epochs): time_start = time.time() train_generator = utils.img_parts_generator(part_file_name, train_data_dir, batch_size=5000, bottleneck_file='bottleneck/bottleneck_60_train.npy', unpickled=unpickled_train) val_generator = utils.img_parts_generator(part_file_name, validation_data_dir, batch_size=5000, bottleneck_file='bottleneck/bottleneck_60_validation.npy', unpickled=unpickled_valid) j = 0 train_eval = [] print('Training') for inp, label in train_generator: hist = top_model.fit(inp, label, verbose=0, batch_size=400) res = [hist.history['loss'][0], hist.history['acc'][0]] train_eval.append(res) #print("Epoch: {}/{} Batch (train): {}/{} train_l: {:.4f} train_acc: {:.4f}".format(i+1,epochs,j+1,42320/batch_size, res[0], res[1])) j += 1 # find mean of loss and acc train_eval = np.mean(train_eval, axis=0) val_eval = [] j = 0 print('Evaluating validation set') for inp, label in val_generator: res = top_model.evaluate(inp, label, verbose=0, batch_size=400) #print("Epoch: {}/{} Batch (valid): {}/{} val_l: {:.4f} val_acc: {:.4f}".format(i+1,epochs,j+1,3000/batch_size, res[0], res[1])) val_eval.append(res) j += 1 if j==5: break val_eval = np.mean(val_eval, axis=0) if val_eval[0] < best_val_loss: #print('Saving weights') best_val_loss = val_eval[0] top_model.save_weights('models/{}_{}_{:.4f}.hdf5'.format(exp_name,i+1,round(best_val_loss))) time_taken = time.time() - time_start log = 'Epoch: {}, train_l: {:.4f}, train_a: {:.4f}, val_l: {:.4f}, val_a: {:.4f}, time: {:.4f}\n'.format(i+1,train_eval[0], train_eval[1], val_eval[0],val_eval[1], time_taken) f.write(log) print(log) f.close()
def train_top_model(): # load top model architecture top_model, _, _ = create_top_model( num_classes=4, activation=None, weights='models/v2_top_bb_30_28.0000.hdf5') top_model.compile(optimizer=optimizers.Adam(), loss='mean_absolute_error', metrics=['accuracy']) print(top_model.summary()) bottlenecks_train = utils.load_bottlenecks(bottleneck_dir + 'bottleneck_60_train.npy') bottlenecks_valid = utils.load_bottlenecks(bottleneck_dir + 'bottleneck_60_validation.npy') best_val_loss = 100 f = open('console_dumps/{}.txt'.format(exp_name), 'w') unpickled_train = pickle.load(open('cache/bb_train.p', 'rb')) unpickled_valid = pickle.load(open('cache/bb_validation.p', 'rb')) for i in range(epochs): time_start = time.time() train_generator = utils.img_parts_generator( part_file_name, 'train/', batch_size=5000, bottlenecks=bottlenecks_train, unpickled=unpickled_train, bb_only=True) val_generator = utils.img_parts_generator( part_file_name, 'validation/', batch_size=5000, bottlenecks=bottlenecks_valid, unpickled=unpickled_valid, bb_only=True) train_eval = [] # stores metrics of training iterations # print('Training') for inp, label in train_generator: hist = top_model.fit(inp, label, verbose=0, batch_size=400) res = [hist.history['loss'][0], hist.history['acc'][0]] train_eval.append(res) # find mean of loss and acc train_eval = np.mean(train_eval, axis=0) val_eval = [] # stores metrics of validation iterations j = 0 # print('Evaluating validation set') for inp, label in val_generator: res = top_model.evaluate(inp, label, verbose=0, batch_size=400) #print("Epoch: {}/{} Batch (valid): {}/{} val_l: {:.4f} val_acc: {:.4f}".format(i+1,epochs,j+1,3000/batch_size, res[0], res[1])) val_eval.append(res) j += 1 #if j==5: # break val_eval = np.mean(val_eval, axis=0) # save weights if current loss beats best loss if val_eval[0] < best_val_loss: #print('Saving weights') best_val_loss = val_eval[0] top_model.save_weights('models/{}_{}_{:.4f}.hdf5'.format( exp_name, i + 1, round(best_val_loss))) time_taken = time.time() - time_start log = 'Epoch: {}, train_l: {:.4f}, train_a: {:.4f}, val_l: {:.4f}, val_a: {:.4f}, time: {:.4f}\n'.format( i + 1, train_eval[0], train_eval[1], val_eval[0], val_eval[1], time_taken) f.write(log) print(log) f.close()
def defrost_all_parts(): # load top model architecture base_weights = 'best_weights/defrost_everything_init_47_freeze_fixed_weights.03-0.60.hdf5' top_weights = 'best_weights/top_bb.hdf5' model = create_model(num_classes=4, activation=None, weights=base_weights, weights_output_dim=500, top_weights=top_weights) model.compile(optimizer=optimizers.Adam(lr=1e-5), loss='mean_absolute_error', metrics=['accuracy']) print(model.summary()) best_val_loss = 100 f = open('console_dumps/{}.txt'.format(exp_name), 'w') unpickled_train = pickle.load(open('cache/bb_train.p', 'rb')) unpickled_valid = pickle.load(open('cache/bb_validation.p', 'rb')) #unpickled_test = pickle.load(open('cache/parts_test.p','rb')) for i in range(epochs): # begin epoch time_start = time.time() # init the generators for train and valid train_generator = utils.img_parts_generator(part_file_name, train_data_dir, batch_size=5000, load_image=True, unpickled=unpickled_train, bb_only=True) val_generator = utils.img_parts_generator(part_file_name, validation_data_dir, batch_size=3000, load_image=True, unpickled=unpickled_valid, bb_only=True) # j tracks batch in epoch j = 0 train_eval = [] # stores results for each epoch for inp, label in train_generator: sub_epoch_start = time.time() hist = model.fit(inp, label, verbose=1, batch_size=batch_size) res = [hist.history['loss'][0], hist.history['acc'][0]] train_eval.append(res) sub_e_time = time.time() - sub_epoch_start print( "[train] Epoch: {}/{} Batch: {}/{} train_l: {:.4f} train_acc: {:.4f} time: {:.2f}" .format(i + 1, epochs, j + 1, 42320 / batch_size, res[0], res[1], sub_e_time)) j += 1 # find mean of loss and acc train_eval = np.mean(train_eval, axis=0) val_eval = [] j = 0 print('Evaluating validation set') for inp, label in val_generator: print(inp.shape, label.shape) res = model.evaluate(inp, label, verbose=1, batch_size=batch_size) print( "[valid] Epoch: {}/{} Batch: {}/{} val_l: {:.4f} val_acc: {:.4f}" .format(i + 1, epochs, j + 1, 3000 / batch_size, res[0], res[1])) val_eval.append(res) j += 1 if j == 5: break val_eval = np.mean(val_eval, axis=0) if val_eval[0] < best_val_loss: print('Saving weights') best_val_loss = val_eval[0] model.save_weights('models/{}_{}_{:.4f}.hdf5'.format( exp_name, i + 1, round(best_val_loss))) time_taken = time.time() - time_start train_eval = [0.0, 0.0] log = 'Epoch: {}, train_l: {:.4f}, train_a: {:.4f}, val_l: {:.4f}, val_a: {:.4f}, time: {:.4f}\n'.format( i + 1, train_eval[0], train_eval[1], val_eval[0], val_eval[1], time_taken) f.write(log) print(log) f.close()
print(model.summary()) # In[6]: print(model.layers[-1].name) # In[5]: from keras import backend as K from utils import img_parts_generator from KerasDeconv import DeconvNet # In[6]: generator = img_parts_generator('parts_info.txt', data_dir='../cropped/validation/', batch_size=10, load_parts=False, load_image=True) # In[7]: deconv_net = DeconvNet(model) for img in generator: deconv = deconv_get_deconv(img, 'conv2d_139', 0, 'all') # postprocess and save image break #img.save('results/{}_{}_{}.png'.format(layer_name, feature_to_visualize, visualize_mode))
part_file_name = 'parts_info.txt' data_dir = 'validation/' batch_size = 1 steps = 4 target_dim = None cache = False save_path = '../cropped_aligned' target_angle = 50 generator = img_parts_generator(part_file_name, data_dir, batch_size=20, load_image=True, target_dim=target_dim, cache=False, load_paths=True, load_parts=True, bb_only=False) body_index = set([2, 4, 5, 10, 11, 15, 16, 17]) head_index = set([3, 6, 7, 8, 9, 12, 13, 14, 18]) bar = Bar('Cropping aligned image', max=3000) with ThreadPoolExecutor(max_workers=100) as executor: for imgs, paths, parts in generator: executor.submit(align_crop, imgs, paths, parts) bar.finish()
def crop(): part_file_name = 'parts_info.txt' #validation_data_dir = 'validation/' batch_size = 100 target_dim = (299, 299) cache = False save_path = '../cropped_pred_scale1.1' model = create_model(num_classes=4, weights='best_weights/defrost_all_bb_8.hdf5', activation=None) print(model.summary()) model.compile(optimizer='adam', loss='mean_absolute_error', metrics=['accuracy']) direcs = ['test/', 'train/'] nums = [4500, 42320] #direcs = ['validation/'] #nums = [3000] for direc, num in zip(direcs, nums): gen = img_parts_generator(part_file_name, direc, batch_size=batch_size, load_image=True, target_dim=target_dim, cache=False, load_paths=True, load_orig_img=True, bb_only=True) bar = Bar('Cropping: ' + direc[:-1], max=num) for imgs, orig_imgs, paths, parts in gen: preds = model.predict(imgs, batch_size=100, verbose=1) for i in range(len(imgs)): img = imgs[i] orig_img = orig_imgs[i] path = paths[i] ## Rescaling predicted points to original dimensions t_l_point = (preds[i][0], preds[i][1]) b_r_point = (preds[i][2], preds[i][3]) #print("Orig: ", parts[i]) #print("Predicted:", t_l_point, b_r_point) b_r_point = scale(b_r_point, orig_img.shape) t_l_point = scale(t_l_point, orig_img.shape) t_l_point, b_r_point = scale_bounding_box(t_l_point, b_r_point, orig_img.shape, scale=1.1) # get bounding boxes t_l_x = int(t_l_point[0]) t_l_y = int(t_l_point[1]) b_r_x = int(b_r_point[0]) b_r_y = int(b_r_point[1]) if (b_r_y > t_l_y and b_r_x > t_l_x): img = crop(orig_img, t_l_x, t_l_y, b_r_x, b_r_y) else: img = orig_img try: img = resize(img, (299, 299)) except ValueError: print(img.shape) print(orig_img.shape) print(t_l_x, b_r_x, t_l_y, b_r_y) print(t_l_point, b_r_point) a = orig_img[t_l_y:b_r_y, :] print(a.shape) raise ValueError("Error") save_img_path = get_save_path(path, save_path) img = Image.fromarray(img) img.save(save_img_path) bar.next() #break bar.finish()