Esempio n. 1
0
def get_dataset(dataset_root, batch_size, net_size):
    subset = [('2007', 'test')]
    datatransform = transform.YOLO3DefaultValTransform(mean=(0, 0, 0),
                                                       std=(1, 1, 1))
    valset = VOCdataset(dataset_root,
                        datatransform,
                        subset,
                        batch_size,
                        net_size,
                        shuffle=False)

    valset_iter = tf.data.Dataset.from_generator(
        valset, ((tf.float32, tf.string, tf.string, tf.float32, tf.float32,
                  tf.float32, tf.float32, tf.float32)))
    valset_iter = valset_iter.batch(1).prefetch(tf.data.experimental.AUTOTUNE)

    subset = [('2007', 'trainval'), ('2012', 'trainval')]
    datatransform = transform.YOLO3DefaultTrainTransform(mean=(0, 0, 0),
                                                         std=(1, 1, 1))
    trainset = VOCdataset(dataset_root,
                          datatransform,
                          subset,
                          batch_size,
                          net_size,
                          shuffle=True)
    trainset_iter = tf.data.Dataset.from_generator(
        trainset, ((tf.float32, tf.string, tf.string, tf.float32, tf.float32,
                    tf.float32, tf.float32, tf.float32)))
    # be careful to drop the last smaller batch if using tf.function
    trainset_iter = trainset_iter.batch(1, drop_remainder=True).prefetch(
        tf.data.experimental.AUTOTUNE)
    return trainset_iter, valset_iter
Esempio n. 2
0
def get_dataset(dataset_root, batch_size, net_size):
    subset = [('2007', 'test')]
    datatransform = transform.YOLO3DefaultValTransform(mean=(0, 0, 0),
                                                       std=(1, 1, 1))
    valset = VOCdataset(dataset_root,
                        datatransform,
                        subset,
                        batch_size,
                        net_size,
                        istrain=False)

    valset = DataLoader(dataset=valset,
                        batch_size=1,
                        shuffle=False,
                        num_workers=1,
                        pin_memory=True)

    subset = [('2007', 'trainval'), ('2012', 'trainval')]
    datatransform = transform.YOLO3DefaultTrainTransform(mean=(0, 0, 0),
                                                         std=(1, 1, 1))
    trainset = VOCdataset(dataset_root,
                          datatransform,
                          subset,
                          batch_size,
                          net_size,
                          istrain=True)
    trainset = DataLoader(dataset=trainset,
                          batch_size=1,
                          shuffle=True,
                          num_workers=1,
                          pin_memory=True)
    return trainset, valset
Esempio n. 3
0
def get_dataset(config):
    config['subset'] = 'val'
    datatransform = transform.YOLO3DefaultValTransform(height=416,
                                                       width=416,
                                                       mean=(0, 0, 0),
                                                       std=(1, 1, 1))
    valset = PascalDataset(config, datatransform)
    generator = DataGenerator(valset)
    valset = tf.data.Dataset.from_generator(
        generator, ((tf.float32, tf.string, tf.float32, tf.float32, tf.float32,
                     tf.float32, tf.float32)))
    valset = valset.batch(config['batch_size']).prefetch(
        tf.data.experimental.AUTOTUNE)

    config["subset"] = 'train'
    datatransform = transform.YOLO3DefaultTrainTransform(height=416,
                                                         width=416,
                                                         mean=(0, 0, 0),
                                                         std=(1, 1, 1))
    trainset = PascalDataset(config, datatransform)
    generator = DataGenerator(trainset, shuffle=True)
    trainset = tf.data.Dataset.from_generator(
        generator, ((tf.float32, tf.string, tf.float32, tf.float32, tf.float32,
                     tf.float32, tf.float32)))
    #be careful to drop the last smaller batch if using tf.function
    trainset = trainset.batch(config['batch_size'],
                              drop_remainder=True).prefetch(
                                  tf.data.experimental.AUTOTUNE)
    return trainset, valset
Esempio n. 4
0
def get_dataset(dataset_root, batch_size, net_size):
  datatransform = transform.YOLO3DefaultValTransform(mean=(0, 0, 0), std=(1, 1, 1))
  valset = COCOdataset(dataset_root, datatransform, subset='val', batchsize=batch_size, netsize=net_size,istrain=False)
  valset = torch.utils.data.DataLoader(dataset=valset,batch_size=1,shuffle=False,num_workers=4,pin_memory=True)

  trainset = COCOdataset(dataset_root, datatransform, subset='train', batchsize=batch_size, netsize=net_size,istrain=True)
  trainset = torch.utils.data.DataLoader(dataset=trainset,batch_size=1,shuffle=True,num_workers=4,pin_memory=True)
  return trainset, valset
Esempio n. 5
0
def get_dataset(dataset_root, batch_size, trainsizes, testsize, numworkers=4, debug=False, gt_pergrid=3):
    subset = [('2007', 'trainval'), ('2012', 'trainval')]
    datatransform = transform.YOLO3DefaultTrainTransform(mean=(0, 0, 0), std=(1, 1, 1))
    trainset = VOCdataset(dataset_root, datatransform, subset, batch_size, trainsizes=trainsizes, testsize=testsize,
                          istrain=True, gt_pergrid=gt_pergrid)
    trainset = DataLoader(dataset=trainset, batch_size=1, shuffle=False, num_workers=numworkers, pin_memory=True)

    subset = [('2007', 'test')]
    datatransform = transform.YOLO3DefaultValTransform(mean=(0, 0, 0), std=(1, 1, 1))
    valset = VOCdataset(dataset_root, datatransform, subset, batch_size, trainsizes=trainsizes, testsize=testsize,
                        istrain=False, gt_pergrid=gt_pergrid)

    valset = DataLoader(dataset=valset, batch_size=1, shuffle=False, num_workers=numworkers, pin_memory=True)
    return trainset, valset
Esempio n. 6
0
def get_dataset(dataset_root,batch_size,net_size):
  datatransform = transform.YOLO3DefaultValTransform(mean=(0, 0, 0), std=(1, 1, 1))
  valset = COCOdataset(dataset_root,datatransform,subset='val',shuffle=False,batchsize=batch_size,netsize=net_size)
  valset = tf.data.Dataset.from_generator(valset,
                                          ((tf.float32, tf.string,tf.string, tf.float32, tf.float32, tf.float32, tf.float32,
                                            tf.float32)))
  valset = valset.batch(1).prefetch(tf.data.experimental.AUTOTUNE)

  datatransform = transform.YOLO3DefaultTrainTransform(mean=(0, 0, 0), std=(1, 1, 1))
  trainset = COCOdataset(dataset_root,datatransform,subset='train',shuffle=True,batchsize=batch_size,netsize=net_size)
  trainset = tf.data.Dataset.from_generator(trainset,
                                            ((tf.float32, tf.string,tf.string, tf.float32, tf.float32, tf.float32, tf.float32,
                                              tf.float32)))
  #be careful to drop the last smaller batch if using tf.function
  trainset = trainset.batch(1,drop_remainder=True).prefetch(tf.data.experimental.AUTOTUNE)

  return trainset, valset
Esempio n. 7
0
def get_dataset(dataset_root,
                batch_size,
                trainsizes,
                testsize,
                numworkers=4,
                debug=False,
                gt_pergrid=3):
    datatransform = transform.YOLO3DefaultValTransform(mean=(0, 0, 0),
                                                       std=(1, 1, 1))
    valset = COCOdataset(dataset_root,
                         datatransform,
                         subset='val',
                         batchsize=batch_size,
                         trainsizes=trainsizes,
                         testsize=testsize,
                         istrain=False,
                         gt_pergrid=gt_pergrid)
    valset = torch.utils.data.DataLoader(dataset=valset,
                                         batch_size=1,
                                         shuffle=False,
                                         num_workers=numworkers,
                                         pin_memory=True)
    if debug:
        return valset, valset
    trainset = COCOdataset(dataset_root,
                           datatransform,
                           subset='train',
                           batchsize=batch_size,
                           trainsizes=trainsizes,
                           testsize=testsize,
                           istrain=True,
                           gt_pergrid=gt_pergrid)
    trainset = torch.utils.data.DataLoader(dataset=trainset,
                                           batch_size=1,
                                           shuffle=True,
                                           num_workers=numworkers,
                                           pin_memory=True)
    return trainset, valset