def main(args): config_path = 'config.json' config_path = args.conf num_anchors = 5 with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) train_imgs, train_labels = parse_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) grid_w = config['model']['input_size']/32 grid_h = config['model']['input_size']/32 # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width']/grid_w cell_h = image['height']/grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin']))/cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin']))/cell_h annotation_dims.append(map(float, (relative_w,relatice_h))) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file print '\naverage IOU for', num_anchors, 'anchors:', '%0.2f' % avg_IOU(annotation_dims, centroids) print_anchors(centroids)
def main(argv): config_path = args.conf num_anchors = args.anchors with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) train_imgs, train_labels = parse_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) grid_w = config['model']['input_size']/32 grid_h = config['model']['input_size']/32 # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width']/grid_w cell_h = image['height']/grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin']))/cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin']))/cell_h annotation_dims.append(tuple(map(float, (relative_w,relatice_h)))) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file print('\naverage IOU for', num_anchors, 'anchors:', '%0.2f' % avg_IOU(annotation_dims, centroids)) print_anchors(centroids)
def load_data_generators(generator_config, args): pickle_train = 'data/TrainAnn_hydr.pickle' pickle_val = 'data/ValAnn_hydr.pickle' train_image_folder = os.path.join(args.input, "image/") train_annot_folder = os.path.join(args.input, "labels/") valid_image_folder = train_image_folder valid_annot_folder = train_annot_folder if os.path.isfile(pickle_train): print("\n=== WARNING!!! Opening an old pickled file!!! ===") with open(pickle_train, 'rb') as fp: train_imgs = pickle.load(fp) else: train_imgs, seen_train_labels = parse_annotation( train_annot_folder, train_image_folder, labels=generator_config['LABELS']) with open(pickle_train, 'wb') as fp: pickle.dump(train_imgs, fp) if os.path.isfile(pickle_val): with open(pickle_val, 'rb') as fp: valid_imgs = pickle.load(fp) else: valid_imgs, seen_valid_labels = parse_annotation( valid_annot_folder, valid_image_folder, labels=generator_config['LABELS']) with open(pickle_val, 'wb') as fp: pickle.dump(valid_imgs, fp) train_batch = BatchSequenceGenerator(train_imgs, generator_config, norm=None, shuffle=True, augment=False) valid_batch = BatchSequenceGenerator(valid_imgs, generator_config, norm=None, augment=False) return train_batch, valid_batch
def main(argv): config_path = args.conf initial_num_anchors = args.anchors print("Generating %d anchors..." % initial_num_anchors) with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) print('labels:\n') print(config['model']['labels']) train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) grid_w = config['model']['input_size'] / 32 grid_h = config['model']['input_size'] / 32 #anchorsFinalAcceptableIou = 0.9 #anchorsAvgIou = 0 #num_anchors = initial_num_anchors #hsItCounter = 0 #while anchorsAvgIou < anchorsFinalAcceptableIou: # run k_mean to find the anchors annotation_dims = [] num_wrong = 0 for image in train_imgs: cell_w = image['width'] / grid_w cell_h = image['height'] / grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin'])) / cell_w relative_h = (float(obj["ymax"]) - float(obj['ymin'])) / cell_h if not (relative_w < 0 or relative_h < 0): annotation_dims.append( tuple(map(float, (relative_w, relative_h)))) else: num_wrong += 1 print("WRONG! ", num_wrong) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, initial_num_anchors) # write anchors to file anchorsAvgIou = avg_IOU(annotation_dims, centroids) print('\naverage IOU for', initial_num_anchors, 'anchors:', '%0.2f' % anchorsAvgIou) print_anchors(centroids)
def main(argv): config_path = args.conf num_anchors = args.anchors with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) if config['parser_annotation_type'] == 'xml': # parse annotations of the training set train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) elif config['parser_annotation_type'] == 'csv': # parse annotations of the training set train_imgs, train_labels = parse_annotation_csv( config['train']['train_csv_file'], config['model']['labels'], config['train']['train_csv_base_path']) input_size = (config['model']['input_size_h'], config['model']['input_size_w'], 1) feature_extractor = import_feature_extractor(config['model']['backend'], input_size) grid_w = config['model'][ 'input_size_w'] / feature_extractor.get_output_shape()[1] grid_h = config['model'][ 'input_size_h'] / feature_extractor.get_output_shape()[0] # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width'] / grid_w cell_h = image['height'] / grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin'])) / cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin'])) / cell_h annotation_dims.append(tuple(map(float, (relative_w, relatice_h)))) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file print('\naverage IOU for', num_anchors, 'anchors:', '%0.2f' % avg_IOU(annotation_dims, centroids)) print_anchors(centroids)
def _main_(args): config_path = args.conf weights_path = args.weights with open(config_path) as config_buffer: config = json.load(config_buffer) yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) yolo.load_weights(weights_path) valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) yolo.batch_size = config['train']['batch_size'] yolo.sequence_length = 1 generator_config = { 'IMAGE_H': yolo.input_size, 'IMAGE_W': yolo.input_size, 'GRID_H': yolo.grid_h, 'GRID_W': yolo.grid_w, 'BOX': yolo.nb_box, 'LABELS': yolo.labels, 'CLASS': len(yolo.labels), 'ANCHORS': yolo.anchors, 'BATCH_SIZE': yolo.batch_size, 'TRUE_BOX_BUFFER': yolo.max_box_per_image, 'SEQUENCE_LENGTH': yolo.sequence_length } valid_generator = BatchGenerator(valid_imgs, generator_config, norm=yolo.feature_extractor.normalize, jitter=False) ave_precisions = yolo.evaluate(valid_generator, iou_threshold=0.3, score_threshold=0.2) print("ave precisions: ", ave_precisions) print('mAP: {:.4f}'.format( sum(ave_precisions.values()) / len(ave_precisions)))
def main(args): config_path = args.conf num_anchors = args.anchors with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) if not train_imgs: print('ERROR: No images found for labels {}'.format( config['model']['labels'])) return grid_w = config['model']['input_size'] / 32 grid_h = config['model']['input_size'] / 32 # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width'] / grid_w cell_h = image['height'] / grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin'])) / cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin'])) / cell_h annotation_dims.append(tuple(map(float, (relative_w, relatice_h)))) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file print('\naverage IOU for', num_anchors, 'anchors:', '%0.2f' % avg_IOU(annotation_dims, centroids)) print_anchors(centroids) config['model']['anchors'] = np.array(sorted( centroids.tolist())).flatten().tolist() with open(config_path, 'w') as config_buffer: json.dump(config, config_buffer)
def get_anchors(config, num_anchors=5): train_imgs, train_labels = parse_annotation(config['train_annot_folder'], config['train_image_folder'], config['LABELS']) grid_w = config['GRID_W'] grid_h = config['GRID_H'] annotation_dims = [] for image in train_imgs: cell_w = image['width'] / grid_w cell_h = image['height'] / grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin'])) / cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin'])) / cell_h annotation_dims.append(tuple(map(float, (relative_w, relatice_h)))) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) return centroids
def write_all_missing_fields(self): self.config['wt_path'] = self.wt_path self.config['train_annot_folder'] = self.train_annot_folder self.config['train_image_folder'] = self.train_image_folder self.config['valid_annot_folder'] = self.valid_annot_folder self.config['valid_image_folder'] = self.valid_image_folder self.config['model_save_path'] = self.model_save_path _, seen_labels = parse_annotation( self.train_annot_folder, self.train_image_folder, labels=[], onlyInLabels=False ) LABELS = sorted(seen_labels.keys()) self.config['LABELS'] = LABELS self.config['CLASS'] = len(LABELS) self.config['CLASS_WEIGHTS'] = [1.0] * len(LABELS) random.seed(self.config['random_seed']) anchors = sorted_anchors(get_anchors(self.config)) self.config['ANCHORS'] = anchors
def main(argv): config_path = args.conf num_anchors = int(args.anchors) class_name = args.name with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) grid_w = config['model']['input_size'] / 32 grid_h = config['model']['input_size'] / 32 # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width'] / grid_w cell_h = image['height'] / grid_h for obj in image['object']: if obj['name'] == class_name or not class_name: relative_w = (float(obj['xmax']) - float(obj['xmin'])) / cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin'])) / cell_h annotation_dims.append(map(float, (relative_w, relatice_h))) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file print('\naverage IOU for', num_anchors, 'anchors:', '%0.2f' % avg_IOU(annotation_dims, centroids)) print_anchors(centroids) centroids_real_value = np.zeros(centroids.shape) centroids_real_value[:, 0] = centroids[:, 0] * cell_w centroids_real_value[:, 1] = centroids[:, 1] * cell_h print('Real value:') print_anchors(centroids_real_value)
def main(): #LABELS = ['traffic_sign'] LABELS = [ "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "pottedplant", "sheep", "sofa", "train", "tvmonitor", "person" ] #train_imgs_GTSDB,train_labels_GTSDB = parse_GTSDB_dataset() # train_imgs, train_labels = parse_annotation('/data4/sunsiyuan/data/LISA/Annotations/', # '/data4/sunsiyuan/data/LISA/JPEGImages/', # LABELS) train_imgs, train_labels = parse_annotation( '/data4/sunsiyuan/data/VOC/VOCdevkit/VOC2012/Annotations/', '/data4/sunsiyuan/data/VOC/VOCdevkit/VOC2012/JPEGImages/', LABELS) print len(train_imgs) print train_labels #train_imgs.extend(train_imgs_GTSDB) #train_labels['traffic_sign'] = train_labels['traffic_sign'] + train_labels_GTSDB['traffic_sign'] num_anchors = 5 grid_w = 13 grid_h = 13 # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width'] / grid_w cell_h = image['height'] / grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin'])) / cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin'])) / cell_h #print (relatice_h,relative_w) annotation_dims.append(map(float, (relative_w, relatice_h))) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file print '\naverage IOU for', num_anchors, 'anchors:', '%0.2f' % avg_IOU( annotation_dims, centroids) print_anchors(centroids)
def main(argv): config_path = args.conf num_anchors = args.anchors train_annot_folder = '/home/sathish/gitRepos/YOLO/darkflow/custom_dataset/BT/Train/Annotation/' train_image_folder = '/home/sathish/gitRepos/YOLO/darkflow/custom_dataset/BT/Train/Img/' labels = ['gooddayOrangeCashew', 'parleg'] #with open(config_path) as config_buffer: #config = json.loads(config_buffer.read()) train_imgs, train_labels = parse_annotation(train_annot_folder, train_image_folder, labels) grid_w = int(256/32) grid_h = int(256/32) # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width']/grid_w #if image['width'] == 0: #print(image) cell_h = image['height']/grid_h #print(cell_h) for obj in image['object']: print(obj) relative_w = (float(obj['xmax']) - float(obj['xmin']))/cell_w relatice_h = (float(obj["ymax"]) - float(obj['ymin']))/cell_h annotation_dims.append(tuple(map(float, (relative_w, relatice_h)))) print('shape of ann:--', annotation_dims[0]) annotation_dims = np.array(annotation_dims) print(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file print('\naverage IOU for', num_anchors, 'anchors:', '%0.2f' % avg_IOU(annotation_dims, centroids)) print_anchors(centroids)
def mymain(config_path, num_anchors): #config_path = args.conf #num_anchors = args.anchors with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) print("Anno processed") inp_size = config['model']['input_size'] grid_w = inp_size[0] / 32 grid_h = inp_size[1] / 32 # run k_mean to find the anchors annotation_dims = [] for image in train_imgs: cell_w = image['width'] / grid_w cell_h = image['height'] / grid_h for obj in image['object']: relative_w = (float(obj['xmax']) - float(obj['xmin'])) / cell_w relative_h = (float(obj["ymax"]) - float(obj['ymin'])) / cell_h annotation_dims.append([relative_w, relative_h]) annotation_dims = np.array(annotation_dims) centroids = run_kmeans(annotation_dims, num_anchors) # write anchors to file anchors = avg_IOU(annotation_dims, centroids) print('\naverage IOU for {} anchors: \n'.format(num_anchors)) print(anchors) print_anchors(centroids)
no_object_scale = 1.0 coord_scale = 1.0 class_scale = 1.0 train_times = 5 valid_times = 1 architecture = "Tiny Yolo" input_size = 416 max_box_per_img = 10 anchors = [ 0.57273, 0.677385, 1.87446, 2.06253, 3.33843, 5.47434, 7.88282, 3.52778, 9.77052, 9.16828 ] imgs, labels = parse_annotation(train_annot_folder, train_image_folder, labels) train_valid_split = int(0.8 * len(imgs)) np.random.shuffle(imgs) valid_imgs = imgs[train_valid_split:] train_imgs = imgs[:train_valid_split] overlap_labels = set(labels).intersection(set(labels.keys())) # print("Seen labels: "+str(labels)) # print("Given labels: "+str(labels) print("Overelap labels: " + str(overlap_labels)) if len(overlap_labels) < len(labels): print("Some labels have no image! Please check it.")
def main(): argparser = argparse.ArgumentParser(description=PARSER_HELP_STR) argparser.add_argument('-c', '--conf', default='config.json', help='path to configuration file') argparser.add_argument('-d', '--imgdir', default='.', help='path to image directory') argparser.add_argument('-s', '--suffix', default='', help='image file suffix') argparser.add_argument('-m', '--multi_image', action='store_true', help='show multi-band images in separate plots') args = argparser.parse_args() conf_type = os.path.splitext(args.conf)[1] if conf_type == '.json': from preprocessing import parse_annotation with open(args.conf) as cfb: config = json.loads(cfb.read()) train_imgs, _ = parse_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) elif conf_type == '.txt': filenames = [x for x in os.listdir(args.imgdir) if is_image(x)] if not filenames: print('No images found in {}'.format(args.imgdir)) return train_imgs = [] with open(args.conf) as txt: for line in txt.readlines(): item = {} data = line.strip().split(' ') poss_imgs = [f for f in filenames if data[0] in f] print(len(poss_imgs), 'found for', data[0]) if args.suffix: poss_imgs = [f for f in poss_imgs if args.suffix in f] if poss_imgs: item['filename'] = os.path.join( args.imgdir, poss_imgs[0]) else: print('No images found with suffix {}'.format( args.suffix)) else: item['filename'] = os.path.join(args.imgdir, poss_imgs[0]) item['object'] = [ zip(['xmin', 'ymax', 'xmax', 'ymin'], [float(x) for x in data[5:]]) ] train_imgs.append(item) print(train_imgs) else: print('Invalid config file {}'.format(args.conf)) return for imobj in train_imgs: plot_image(imobj['filename'], imobj['object'][0], separate=args.multi_image)
generator_config = { 'IMAGE_H': IMAGE_H, 'IMAGE_W': IMAGE_W, 'GRID_H': GRID_H, 'GRID_W': GRID_W, 'BOX': BOX, 'LABELS': LABELS, 'CLASS': len(LABELS), 'ANCHORS': ANCHORS, 'BATCH_SIZE': BATCH_SIZE, 'TRUE_BOX_BUFFER': 50, } image_path = './raccoon_dataset-master/images/' annot_path = './raccoon_dataset-master/annotations/' all_imgs, seen_labels = parse_annotation(annot_path, image_path) #no labels? # from random import shuffle # shuffle(all_imgs) # # with open('imgs_racoon_shfld', 'wb') as fp: # pickle.dump(all_imgs, fp) # # with open('imgs_racoon_shfld', 'rb') as fp: # all_imgs = pickle.load(fp) def normalize(image): return image / 255.
with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) yolo = YOLO(backend = None, input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors'], load_from_json = model_path, trained_weights = weights_path) yolo.set_batch(config['train']['batch_size']) #TODO insert bactch generator here if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation(config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: valid_imgs, valid_labels = parse_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) valid_generator = yolo.get_generator_from_data(valid_imgs) average_precisions, average_speed = yolo.evaluate(valid_generator) # print evaluation for label, average_precision in average_precisions.items(): print(yolo.get_label(label), '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format(sum(average_precisions.values()) / len(average_precisions)))
def makemodel(): # Layer 1 x = Conv2D(32, (3,3), strides=(1,1), padding='same', name='conv_1', use_bias=False)(input_image) x = BatchNormalization(name='norm_1')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 2 x = Conv2D(64, (3,3), strides=(1,1), padding='same', name='conv_2', use_bias=False)(x) x = BatchNormalization(name='norm_2')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 3 x = Conv2D(128, (3,3), strides=(1,1), padding='same', name='conv_3', use_bias=False)(x) x = BatchNormalization(name='norm_3')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 4 x = Conv2D(64, (1,1), strides=(1,1), padding='same', name='conv_4', use_bias=False)(x) x = BatchNormalization(name='norm_4')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 5 x = Conv2D(128, (3,3), strides=(1,1), padding='same', name='conv_5', use_bias=False)(x) x = BatchNormalization(name='norm_5')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 6 x = Conv2D(256, (3,3), strides=(1,1), padding='same', name='conv_6', use_bias=False)(x) x = BatchNormalization(name='norm_6')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 7 x = Conv2D(128, (1,1), strides=(1,1), padding='same', name='conv_7', use_bias=False)(x) x = BatchNormalization(name='norm_7')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 8 x = Conv2D(256, (3,3), strides=(1,1), padding='same', name='conv_8', use_bias=False)(x) x = BatchNormalization(name='norm_8')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 9 x = Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_9', use_bias=False)(x) x = BatchNormalization(name='norm_9')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 10 x = Conv2D(256, (1,1), strides=(1,1), padding='same', name='conv_10', use_bias=False)(x) x = BatchNormalization(name='norm_10')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 11 x = Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_11', use_bias=False)(x) x = BatchNormalization(name='norm_11')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 12 x = Conv2D(256, (1,1), strides=(1,1), padding='same', name='conv_12', use_bias=False)(x) x = BatchNormalization(name='norm_12')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 13 x = Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_13', use_bias=False)(x) x = BatchNormalization(name='norm_13')(x) x = LeakyReLU(alpha=0.1)(x) skip_connection = x x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 14 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_14', use_bias=False)(x) x = BatchNormalization(name='norm_14')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 15 x = Conv2D(512, (1,1), strides=(1,1), padding='same', name='conv_15', use_bias=False)(x) x = BatchNormalization(name='norm_15')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 16 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_16', use_bias=False)(x) x = BatchNormalization(name='norm_16')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 17 x = Conv2D(512, (1,1), strides=(1,1), padding='same', name='conv_17', use_bias=False)(x) x = BatchNormalization(name='norm_17')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 18 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_18', use_bias=False)(x) x = BatchNormalization(name='norm_18')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 19 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_19', use_bias=False)(x) x = BatchNormalization(name='norm_19')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 20 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_20', use_bias=False)(x) x = BatchNormalization(name='norm_20')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 21 skip_connection = Conv2D(64, (1,1), strides=(1,1), padding='same', name='conv_21', use_bias=False)(skip_connection) skip_connection = BatchNormalization(name='norm_21')(skip_connection) skip_connection = LeakyReLU(alpha=0.1)(skip_connection) skip_connection = Lambda(space_to_depth_x2)(skip_connection) x = concatenate([skip_connection, x]) # Layer 22 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_22', use_bias=False)(x) x = BatchNormalization(name='norm_22')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 23 x = Conv2D(BOX * (4 + 1 + CLASS), (1,1), strides=(1,1), padding='same', name='conv_23')(x) output = Reshape((GRID_H, GRID_W, BOX, 4 + 1 + CLASS))(x) # small hack to allow true_boxes to be registered when Keras build the model # for more information: https://github.com/fchollet/keras/issues/2790 output = Lambda(lambda args: args[0])([output, true_boxes]) model = Model([input_image, true_boxes], output) train_imgs, seen_train_labels = parse_annotation(train_annot_folder, train_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time #with open('train_imgs', 'wb') as fp: # pickle.dump(train_imgs, fp) ### read saved pickle of parsed annotations #with open ('train_imgs', 'rb') as fp: # train_imgs = pickle.load(fp) train_batch = BatchGenerator(train_imgs, generator_config, norm=normalize) valid_imgs, seen_valid_labels = parse_annotation(valid_annot_folder, valid_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time #with open('valid_imgs', 'wb') as fp: # pickle.dump(valid_imgs, fp) ### read saved pickle of parsed annotations #with open ('valid_imgs', 'rb') as fp: # valid_imgs = pickle.load(fp) optimizer = Adam(lr=0.5e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) #optimizer = SGD(lr=1e-4, decay=0.0005, momentum=0.9) #optimizer = RMSprop(lr=1e-4, rho=0.9, epsilon=1e-08, decay=0.0) model.compile(loss=custom_loss, optimizer=optimizer) return model
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### # parse annotations of the training set train_imgs, train_labels = parse_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation(config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: train_valid_split = int(0.8*len(train_imgs)) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] print train_labels if len(set(config['model']['labels']).intersection(set(train_labels.keys()))) == 0: print "Labels to be detected are not present in the dataset! Please revise the list of labels in the config.json file!" return ############################### # Construct the model ############################### yolo = YOLO(architecture = config['model']['architecture'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) ############################### # Load the pretrained weights (if any) ############################### if os.path.exists(config['train']['pretrained_weights']): print "Loading pre-trained weights in", config['train']['pretrained_weights'] yolo.load_weights(config['train']['pretrained_weights']) ############################### # Start the training process ############################### yolo.train(train_imgs = train_imgs, valid_imgs = valid_imgs, train_times = config['train']['train_times'], valid_times = config['valid']['valid_times'], nb_epoch = config['train']['nb_epoch'], learning_rate = config['train']['learning_rate'], batch_size = config['train']['batch_size'], warmup_bs = config['train']['warmup_batches'], object_scale = config['train']['object_scale'], no_object_scale = config['train']['no_object_scale'], coord_scale = config['train']['coord_scale'], class_scale = config['train']['class_scale'], saved_weights_name = config['train']['saved_weights_name'], debug = config['train']['debug'])
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations # 预处理部分 ############################### # parse annotations of the training set """ train_imgs是一个list,每个元素是一个dict,里面包括了每个图片的信息: img['filename']: str, 图片完整路径 img['width']: int, 图片宽度 img['height']: int, 图片长度 img['object']: list, 所有标注object的list,每个object是一个dict obj['name']: str object的label名字 obj['xmin']: int obj['xmax']: int obj['ymin']: int obj['ymax']: int train label是一个dictionary,key为label,value为出现的次数 """ train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) # parse annotations of the validation set, if any, otherwise split the training set np.random.shuffle(train_imgs) if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: train_valid_split = int(0.8 * len(train_imgs)) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] if len(config['model']['labels']) > 0: overlap_labels = set(config['model']['labels']).intersection( set(train_labels.keys())) print('Seen labels:\t', train_labels) print('Given labels:\t', config['model']['labels']) print('Overlap labels:\t', overlap_labels) if len(overlap_labels) < len(config['model']['labels']): print( 'Some labels have no annotations! Please revise the list of labels in the config.json file!' ) return else: print('No labels are provided. Train on all seen labels.') print(f"labels:{train_labels}") config['model']['labels'] = train_labels.keys() ############################### # Construct the model ############################### """ 这里创建了一个yolo类型的对象 模型特征提取部分使用config里backend的设置 注意这里的模型建立只对模型的特征提取部分,即卷积部分做了构建,没有对后面的分类部分,即全连接层做构建 labels是config中定义的labels,当空时为全部找到的label(看preprocessing的代码) max_box_per_image顾名思义,但是注意在config中的anchors的设置数量一定要一样,不然没有意义 anchors到底是什么可以看论文中对anchor权重的说明。 """ yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load the pretrained weights (if any) """ 注意这里load的weight是load之前训练好的 也就是说,之前跑过一遍这个代码训练出来的weight才能fit上去。 因为其实这里结构比较特殊,特征提取部分被独立成一个layer了 """ ############################### if os.path.exists(config['train']['pretrained_weights']): print("Loading pre-trained weights in", config['train']['pretrained_weights']) yolo.load_weights(config['train']['pretrained_weights']) ############################### # Start the training process ############################### yolo.train(train_imgs=train_imgs, valid_imgs=valid_imgs, train_times=config['train']['train_times'], valid_times=config['valid']['valid_times'], nb_epochs=config['train']['nb_epochs'], learning_rate=config['train']['learning_rate'], batch_size=config['train']['batch_size'], warmup_epochs=config['train']['warmup_epochs'], object_scale=config['train']['object_scale'], no_object_scale=config['train']['no_object_scale'], coord_scale=config['train']['coord_scale'], class_scale=config['train']['class_scale'], saved_weights_name=config['train']['saved_weights_name'], debug=config['train']['debug'])
import json import pandas as pd manual_check = pd.read_csv( "../large_dataset/whale_box/yolo_box/manual_check_train.csv") df = pd.read_csv("../large_dataset/whale_box/yolo_box/train_selected.csv") with open('config.json') as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### # parse annotations of the training set train_imgs, train_labels = parse_annotation( config['train']['missed_annot_folder'], config['train']['missed_image_folder'], config['model']['labels']) for i in range(len(train_imgs)): head, tail = os.path.split(train_imgs[i]['filename']) manual_check.at[manual_check.Image == tail, 'Xmin'] = train_imgs[i]['object'][0]['xmin'] manual_check.at[manual_check.Image == tail, 'Ymin'] = train_imgs[i]['object'][0]['ymin'] manual_check.at[manual_check.Image == tail, 'Xmax'] = train_imgs[i]['object'][0]['xmax'] manual_check.at[manual_check.Image == tail, 'Ymax'] = train_imgs[i]['object'][0]['ymax'] manual_check_final = manual_check.dropna() #manual_check_final.to_csv('manual_check_final.csv', encoding='utf-8', index=False)
def _main_(args): print('Hello World! This is {:s}'.format(args.desc)) '''************************************************************** I. Set parameters ''' config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) '''************************************************************** II. Prepare the data ''' # 1: Parse dataset train_imgs, train_labels = parse_annotation( ann_dir=config['train']['train_annot_folder'], img_dir=config['train']['train_image_folder'], labels=config['model']['labels']) if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation( ann_dir=config['valid']['valid_annot_folder'], img_dir=config['valid']['valid_image_folder'], labels=config['model']['labels']) else: train_valid_split = int(0.8 * len(train_imgs)) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] if len(config['model']['labels']) > 0: overlap_labels = set(config['model']['labels']).intersection( set(train_labels.keys())) print('Seen labels:\t', train_labels) print('Given labels:\t', config['model']['labels']) print('Overlap labels:\t', overlap_labels) if len(overlap_labels) < len(config['model']['labels']): print( 'Some labels have no annotations! Please revise the list of labels in the config.json file!' ) return else: print('No labels are provided. Train on all seen labels.') config['model']['labels'] = train_labels.keys() '''************************************************************** III. Create the model ''' # 1: Build the model architecture. yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) # 2: Load some weights into the model. if os.path.exists(config['train']['pretrained_weights']): print("Loading pre-trained weights in", config['train']['pretrained_weights']) yolo.load_weights(config['train']['pretrained_weights']) '''************************************************************** IV. Kick off the training ''' yolo.train(train_imgs=train_imgs, valid_imgs=valid_imgs, train_times=config['train']['train_times'], valid_times=config['valid']['valid_times'], nb_epoch=config['train']['nb_epochs'], learning_rate=config['train']['learning_rate'], batch_size=config['train']['batch_size'], warmup_epochs=config['train']['warmup_epochs'], object_scale=config['train']['object_scale'], no_object_scale=config['train']['no_object_scale'], coord_scale=config['train']['coord_scale'], class_scale=config['train']['class_scale'], saved_weights_name=config['train']['saved_weights_name'], debug=config['train']['debug']) '''************************************************************** V. Test & Evaluate ''' # 1: Set test parameters. input_path = args.input output_path = args.output weights_path = args.weights # 2: Obtain test image paths. image_paths = [] if os.path.isdir(input_path): for inp_file in os.listdir(input_path): image_paths += [input_path + inp_file] else: image_paths += [input_path] image_paths = [ inp_file for inp_file in image_paths if (inp_file[-4:] in ['.jpg', '.png', 'jpeg']) ] # 3: Load model. yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) yolo.load_weights(weights_path) # 4: Make predictions. for image_path in image_paths: image = cv2.imread(image_path) print(image_path) # predict the bounding boxes boxes = yolo.predict(image) # draw bounding boxes on the image using labels image = draw_boxes(image, boxes, config['model']['labels']) # display predicted results cv2.imshow("A", np.uint8(image)) cv2.waitKey(0) # write the image with bounding boxes to file cv2.imwrite(output_path + image_path.split('/')[-1], np.uint8(image))
def _main_(args): config_path = args.conf weights_path = args.weights with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Parse the annotations ############################### # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: raise ValueError( 'Validation folder does not exist or is not specified') ############################################ # Make validation generators ############################################ generator_config = { 'IMAGE_H': yolo.input_size, 'IMAGE_W': yolo.input_size, 'GRID_H': yolo.grid_h, 'GRID_W': yolo.grid_w, 'BOX': yolo.nb_box, 'LABELS': yolo.labels, 'CLASS': len(yolo.labels), 'ANCHORS': yolo.anchors, 'BATCH_SIZE': config['train']['batch_size'], 'TRUE_BOX_BUFFER': yolo.max_box_per_image, } generator = BatchGenerator(valid_imgs, generator_config, norm=yolo.feature_extractor.normalize, jitter=False) y_true = [] y_predicted = [] for i in range(generator.size()): raw_image = generator.load_image(i) raw_height, raw_width, raw_channels = raw_image.shape # make the boxes and the labels pred_boxes = yolo.predict(raw_image) score = np.array([box.score for box in pred_boxes]) pred_labels = np.array([box.label for box in pred_boxes]) if len(pred_boxes) > 0: pred_boxes = np.array([[ box.xmin * raw_width, box.ymin * raw_height, box.xmax * raw_width, box.ymax * raw_height, box.score ] for box in pred_boxes]) else: pred_boxes = np.array([[]]) # sort the boxes and the labels according to scores score_sort = np.argsort(-score) pred_labels = pred_labels[score_sort] pred_boxes = pred_boxes[score_sort] # store predicted label for the image i. # since multiple boxes may be predicted, choose the one with the highest score # TODO: find out why there are no predictions at all for certain images if pred_labels.any(): y_predicted.append(pred_labels[0]) else: y_predicted.append(4) # load true image annotations annotations = generator.load_annotation(i) if annotations.shape[0] > 1: raise ValueError('Multiple objects exist per image not supported') ### store the true label for the image i y_true.append(annotations[0, 4]) print('Processed ' + str(len(y_true)) + 'imgaes') print('Confusion Matrix') print(confusion_matrix(y_true, y_predicted)) print('Classification Report') # added NoPrediction label to number of classes as yolo model returned null prediction for some images target_names = config['model']['labels'] + ['NoPrediction'] print(classification_report(y_true, y_predicted, target_names=target_names))
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) pp.pprint(config) train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(str(config['valid']['valid_annot_folder'])): valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: print("Splitting into train and validation") train_valid_split = int(0.99 * len(train_imgs)) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] if len(config['model']['labels']) > 0: overlap_labels = set(config['model']['labels']).intersection( set(train_labels.keys())) print(('Seen labels:\t', train_labels)) print(('Given labels:\t', config['model']['labels'])) print(('Overlap labels:\t', overlap_labels)) if len(overlap_labels) < len(config['model']['labels']): print( 'Some labels have no annotations! Please revise the list of labels in the config.json file!' ) return else: print('No labels are provided. Train on all seen labels.') config['model']['labels'] = list(train_labels.keys()) yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) if os.path.exists(str(config['train']['pretrained_weights'])): print(("Loading pre-trained weights in", config['train']['pretrained_weights'])) if config['model']['backend'] == "MobileNet": is_mobilenet = True else: print((config['model']['backend'])) is_mobilenet = False yolo.load_weights(config['train']['pretrained_weights']) print("\nStarting training...") yolo.train(train_imgs=train_imgs, valid_imgs=valid_imgs, train_times=config['train']['train_times'], valid_times=config['valid']['valid_times'], nb_epochs=config['train']['nb_epochs'], learning_rate=config['train']['learning_rate'], batch_size=config['train']['batch_size'], warmup_epochs=config['train']['warmup_epochs'], object_scale=config['train']['object_scale'], no_object_scale=config['train']['no_object_scale'], coord_scale=config['train']['coord_scale'], class_scale=config['train']['class_scale'], saved_weights_name=config['train']['saved_weights_name'], debug=config['train']['debug'], full_log_dir=config['train']['full_log_dir'], early_stop_patience=config['train']['early_stop_patience'], early_stop_min_delta=config['train']['early_stop_min_delta'], learning_rate_decay_factor=config['train'] ['learning_rate_decay_factor'], learning_rate_decay_patience=config['train'] ['learning_rate_decay_patience'], learning_rate_decay_min_lr=config['train'] ['learning_rate_decay_min_lr'])
def _main_(args): config_path = args.conf keras.backend.tensorflow_backend.set_session(get_session()) with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) if config['backup']['create_backup']: config = create_backup(config) ############################### # Parse the annotations ############################### if config['parser_annotation_type'] == 'xml': # parse annotations of the training set train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) split = False else: split = True elif config['parser_annotation_type'] == 'csv': # parse annotations of the training set train_imgs, train_labels = parse_annotation_csv( config['train']['train_csv_file'], config['model']['labels'], config['train']['train_csv_base_path']) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_csv_file']): valid_imgs, valid_labels = parse_annotation_csv( config['valid']['valid_csv_file'], config['model']['labels'], config['valid']['valid_csv_base_path']) split = False else: print("Validation file not found commensing split") split = True else: raise ValueError( "'parser_annotations_type' must be 'xml' or 'csv' not {}.".format( config['parser_annotations_type'])) if split: train_valid_split = int(0.8 * len(train_imgs)) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] if len(config['model']['labels']) > 0: overlap_labels = set(config['model']['labels']).intersection( set(train_labels.keys())) print('Seen labels:\t', train_labels) print('Given labels:\t', config['model']['labels']) print('Overlap labels:\t', overlap_labels) if len(overlap_labels) < len(config['model']['labels']): print( 'Some labels have no annotations! Please revise the list of labels in the config.json file!' ) return else: print('No labels are provided. Train on all seen labels.') config['model']['labels'] = train_labels.keys() with open("labels.json", 'w') as outfile: json.dump({"labels": list(train_labels.keys())}, outfile) ############################### # Construct the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=(config['model']['input_size_h'], config['model']['input_size_w']), labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors'], gray_mode=config['model']['gray_mode']) ############################### # Load the pretrained weights (if any) ############################### if os.path.exists(config['train']['pretrained_weights']): print("Loading pre-trained weights in", config['train']['pretrained_weights']) yolo.load_weights(config['train']['pretrained_weights']) ############################### # Start the training process ############################### yolo.train(train_imgs=train_imgs, valid_imgs=valid_imgs, train_times=config['train']['train_times'], valid_times=config['valid']['valid_times'], nb_epochs=config['train']['nb_epochs'], learning_rate=config['train']['learning_rate'], batch_size=config['train']['batch_size'], warmup_epochs=config['train']['warmup_epochs'], object_scale=config['train']['object_scale'], no_object_scale=config['train']['no_object_scale'], coord_scale=config['train']['coord_scale'], class_scale=config['train']['class_scale'], saved_weights_name=config['train']['saved_weights_name'], debug=config['train']['debug'], early_stop=config['train']['early_stop'], workers=config['train']['workers'], max_queue_size=config['train']['max_queue_size'], tb_logdir=config['train']['tensorboard_log_dir'])
'GRID_H': GRID_H, 'GRID_W': GRID_W, 'BOX': N_BOX, 'LABELS': LABELS, 'CLASS': len(LABELS), 'ANCHORS': ANCHORS, 'BATCH_SIZE': BATCH_SIZE, 'TRUE_BOX_BUFFER': TRUE_BOX_BUFFER, } all_imgs = [] for i in range(0, len(LABELS)): image_path = '/Volumes/JS/UECFOOD100_JS/' + str(i+1) + '/' annot_path = '/Volumes/JS/UECFOOD100_JS/' + str(i+1) + '/' + '/annotations_new/' folder_imgs, seen_labels = parse_annotation(annot_path, image_path) all_imgs.extend(folder_imgs) print(np.array(all_imgs).shape) # add extensions to image name for img in all_imgs: img['filename'] = img['filename'] print('=> Generate BatchGenerator.') batches = BatchGenerator(all_imgs, generator_config) img = batches[0][0][0][5] plt.imshow(img.astype('uint8')) # plt_example_batch(batches, BATCH_SIZE) ''' Start training '''
def main(argstate): ############################### # Parse the annotations ############################### # parse annotations of the training set train_imgs, train_labels = parse_annotation(argstate.train.annot_folder, argstate.train.image_folder, argstate.labels) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(argstate.valid.annot_folder): valid_imgs, valid_labels = parse_annotation( argstate.valid.annot_folder, argstate.valid.image_folder, argstate.labels) else: train_valid_split = int(0.8 * len(train_imgs)) np.random.seed(42) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] print(train_labels) if len(set(argstate.labels).intersection(set(train_labels.keys()))) == 0: print( "Labels to be detected are not present in the dataset! Please revise the list of labels in the config.json file!" ) return ############################### # Construct the model ############################### global yolo yolo = YOLO(architecture=argstate.architecture, input_size=argstate.input_size, labels=argstate.labels, max_box_per_image=argstate.mbpi, anchors=argstate.anchors) ############################### # Load the pretrained weights (if any) ############################### if os.path.exists(argstate.pretrained_weights): print("Loading pre-trained weights in", argstate.pretrained_weights) yolo.load_weights(argstate.pretrained_weights) # Load pretrained weights into feature extractor and then freeze them yolo.feature_extractor.feature_extractor.load_weights('yolov2_weights.h5') yolo.feature_extractor.feature_extractor.trainable = True # Spawn train pauser pause_thread = Thread(target=spawn_pause_ui) pause_thread.isDaemon = True pause_thread.start() ############################### # Start the training process ############################### yolo.train(train_imgs=train_imgs, valid_imgs=valid_imgs, train_times=argstate.train.times, valid_times=argstate.valid.times, nb_epoch=argstate.nb_epoch, learning_rate=argstate.learning_rate, batch_size=argstate.batch_size, warmup_bs=argstate.warmup_bs, object_scale=argstate.object_scale, no_object_scale=argstate.no_object_scale, coord_scale=argstate.coord_scale, class_scale=argstate.class_scale, saved_weights_name=argstate.saved_weights_name, debug=argstate.debug)
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### # parse annotations of the training set train_imgs, train_labels = parse_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation(config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: train_valid_split = int(0.8*len(train_imgs)) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] if len(config['model']['labels']) > 0: overlap_labels = set(config['model']['labels']).intersection(set(train_labels.keys())) print 'Seen labels:\t', train_labels print 'Given labels:\t', config['model']['labels'] print 'Overlap labels:\t', overlap_labels if len(overlap_labels) < len(config['model']['labels']): print 'Some labels have no annotations! Please revise the list of labels in the config.json file!' return else: print 'No labels are provided. Train on all seen labels.' config['model']['labels'] = train_labels.keys() ############################### # Construct the model ############################### yolo = YOLO(architecture = config['model']['architecture'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) ############################### # Load the pretrained weights (if any) ############################### if os.path.exists(config['train']['pretrained_weights']): print "Loading pre-trained weights in", config['train']['pretrained_weights'] yolo.load_weights(config['train']['pretrained_weights']) ############################### # Start the training process ############################### yolo.train(train_imgs = train_imgs, valid_imgs = valid_imgs, train_times = config['train']['train_times'], valid_times = config['valid']['valid_times'], nb_epoch = config['train']['nb_epoch'], learning_rate = config['train']['learning_rate'], batch_size = config['train']['batch_size'], warmup_epochs = config['train']['warmup_epochs'], object_scale = config['train']['object_scale'], no_object_scale = config['train']['no_object_scale'], coord_scale = config['train']['coord_scale'], class_scale = config['train']['class_scale'], saved_weights_name = config['train']['saved_weights_name'], debug = config['train']['debug'])
'GRID_W': GRID_W, 'BOX': BOX, 'LABELS': LABELS, 'CLASS': len(LABELS), 'ANCHORS': ANCHORS, 'BATCH_SIZE': BATCH_SIZE, 'TRUE_BOX_BUFFER': 50, } def normalize(image): return image / 255. train_imgs, seen_train_labels = parse_annotation(train_annot_folder, train_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time with open('train_imgs', 'wb') as fp: pickle.dump(train_imgs, fp) ### read saved pickle of parsed annotations with open('train_imgs', 'rb') as fp: train_imgs = pickle.load(fp) train_batch = BatchGenerator(train_imgs, generator_config, norm=normalize) valid_imgs, seen_valid_labels = parse_annotation(valid_annot_folder, valid_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time with open('valid_imgs', 'wb') as fp:
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) os.environ["CUDA_VISIBLE_DEVICES"]=config['env']['gpu'] gpus = max(1, len(config['env']['gpu'].split(","))) #print("{}").format(config) ############################### # Parse the annotations ############################### # parse annotations of the training set train_imgs, train_labels = parse_annotation(config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels'], config['train']['image_ext_name'], config['train']['image_prefix']) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation(config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels'], config['train']['image_ext_name'], config['train']['image_prefix']) else: train_valid_split = int(0.8*len(train_imgs)) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] overlap_labels = set(config['model']['labels']).intersection(set(train_labels.keys())) print ('Seen labels:{}'.format(train_labels)) print ('Given labels:{}'.format(config['model']['labels'])) print ('Overlap labels:{}'.format(overlap_labels)) if len(overlap_labels) < len(config['model']['labels']): print ('Some labels have no images! Please revise the list of labels in the config.json file!') return ############################### # Construct the model ############################### yolo = YOLO(architecture = config['model']['architecture'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors'] gpus = gpus) ############################### # Load the pretrained weights (if any) ############################### if os.path.exists(config['train']['pretrained_weights']): print ("Loading pre-trained weights in {}".format(config['train']['pretrained_weights'])) yolo.load_weights(config['train']['pretrained_weights']) ############################### # Start the training process ############################### yolo.train(train_imgs = train_imgs, valid_imgs = valid_imgs, train_times = config['train']['train_times'], valid_times = config['valid']['valid_times'], nb_epoch = config['train']['nb_epoch'], learning_rate = config['train']['learning_rate'], batch_size = config['train']['batch_size'], warmup_bs = config['train']['warmup_batches'], object_scale = config['train']['object_scale'], no_object_scale = config['train']['no_object_scale'], coord_scale = config['train']['coord_scale'], class_scale = config['train']['class_scale'], saved_weights_name = config['train']['saved_weights_name'], debug = config['train']['debug'])
def _main_(args): config_path = args.conf with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) ############################### # Parse the annotations ############################### # parse annotations of the training set if 'csv' in config['train']['train_annot_folder']: train_imgs, train_labels = parse_csv_annotations( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) else: train_imgs, train_labels = parse_annotation( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): if 'csv' in config['valid']['valid_annot_folder']: valid_imgs, valid_labels = parse_csv_annotations( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: train_valid_split = int(0.8 * len(train_imgs)) np.random.shuffle(train_imgs) valid_imgs = train_imgs[train_valid_split:] train_imgs = train_imgs[:train_valid_split] if len(config['model']['labels']) > 0: overlap_labels = set(config['model']['labels']).intersection( set(train_labels.keys())) print('Seen labels:\t', train_labels) print('Given labels:\t', config['model']['labels']) print('Overlap labels:\t', overlap_labels) if len(overlap_labels) < len(config['model']['labels']): print( 'Some labels have no annotations! Please revise the list of labels in the config.json file!' ) return else: print('No labels are provided. Train on all seen labels.') config['model']['labels'] = train_labels.keys() ############################### # Construct the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load the pretrained weights (if any) ############################### if os.path.exists(config['train']['pretrained_weights']): print("Loading pre-trained weights in", config['train']['pretrained_weights']) yolo.load_weights(config['train']['pretrained_weights']) ############################### # Start the training process ############################### yolo.train(train_imgs=train_imgs, valid_imgs=valid_imgs, train_times=config['train']['train_times'], valid_times=config['valid']['valid_times'], nb_epochs=config['train']['nb_epochs'], learning_rate=config['train']['learning_rate'], batch_size=config['train']['batch_size'], warmup_epochs=config['train']['warmup_epochs'], object_scale=config['train']['object_scale'], no_object_scale=config['train']['no_object_scale'], coord_scale=config['train']['coord_scale'], class_scale=config['train']['class_scale'], saved_weights_name=config['train']['saved_weights_name'], debug=config['train']['debug'])
'BATCH_SIZE': BATCH_SIZE, 'TRUE_BOX_BUFFER': TRUE_BOX_BUFFER, } # define paths for training valid_image_folder = 'data/Validation_Images/' valid_annot_folder = 'data/Validation_Annotations/' # define normalize for images def normalize(image): return image / 255. # define the image and label datasets for training valid_imgs, valid_labels = parse_annotation(valid_annot_folder, valid_image_folder, labels=LABELS) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False) # load new model from training model = load_model('new_model_6.h5', custom_objects={ 'tf': tf, 'custom_loss': custom_loss }) average_precisions = evaluate(model, valid_generator)