def __init__(self, train, debug=False):
self.debug = debug
self.train = train
train_datasets = [
CocoDataset(
'train2017',
'annotations_trainval2017/annotations/captions_train2017.json')
]
if train:
self.datasets = train_datasets
if not train:
self.datasets = [
CocoDataset(
'val2017',
'annotations_trainval2017/annotations/captions_val2017.json'
)
]
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if train:
self.transforms = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.2,
contrast=0.2,
saturation=0.2),
augmentation.OutputTransform(),
normalize,
])
if not train:
self.transforms = transforms.Compose([
transforms.Resize((224, 224)),
augmentation.OutputTransform(),
normalize,
])
vectorizer_path = 'vectorizer.p'
if os.path.exists(vectorizer_path):
self.vectorizer = pickle.load(open(vectorizer_path, "rb"))
else:
self.vectorizer = WordVocabulary(32768)
texts = np.concatenate([x.get_vocab_list() for x in self.datasets])
self.vectorizer.build_vocab(texts)
with open(vectorizer_path, 'wb') as handle:
pickle.dump(self.vectorizer, handle)
if self.debug == 1:
self.data_ids = [(i, j) for i, dataset in enumerate(self.datasets)
for j in range(50)]
else:
self.data_ids = [(i, j) for i, dataset in enumerate(self.datasets)
for j in range(len(self.datasets[i]))]
self.data_ids = np.array(self.data_ids)
def post(self):
data = tornado.escape.json_decode(self.request.body)
for d in data['progress_bars']:
data[d['name']] = d['value']
for d in data['check_boxes']:
data[d['name']] = d['checked']
image_data = data['frame'].replace('data:image/jpeg;base64,', "")
byte_image = io.BytesIO(pybase64._pybase64.b64decode(image_data))
img_input = Image.open(byte_image)
model_key = data['model_name']
if model_key not in camera_models:
if model_key not in model_paths:
raise Exception("Model {} not found.".format(model_key))
model_path = model_paths[model_key]['path']
model = torch.load(model_path).eval().cuda()
model.preprocessing = augmentation.PairCompose([
augmentation.PaddTransform(pad_size=2**model.depth),
augmentation.OutputTransform()
])
camera_models[model_key] = model.cuda()
model = camera_models[model_key]
img_tensor, _, _ = model.preprocessing(img_input, None, None)
img_tensor = img_tensor.unsqueeze(0).float().cuda()
output = model(img_tensor).detach()[
0,
0, :img_input.size[1], :img_input.size[0]].sigmoid().cpu().numpy()
mask_byte_arr = io.BytesIO()
Image.fromarray((output * 255).astype('uint8')).save(mask_byte_arr,
format='jpeg')
encoded_mask = 'data:image/jpeg;base64,' + pybase64.b64encode(
mask_byte_arr.getvalue()).decode('utf-8')
self.write(tornado.escape.json_encode(encoded_mask))
def __init__(self,
net,
batch_size=1,
train_transforms=None,
val_transforms=None,
th_count=mu.cpu_count()):
if train_transforms is None:
train_transforms = augmentation.PairCompose([
augmentation.ResizeDownToSizeTransform(768),
augmentation.RandomResizeTransform(),
augmentation.RandomHorizontalFlipTransform(),
augmentation.RandomCropTransform((512, 512)),
# augmentation.RandomNoiseTransform(),
augmentation.RandomColorJitterTransform(),
# augmentation.RandomBlurTransform(),
augmentation.OutputTransform()
])
if val_transforms is None:
val_transforms = augmentation.PairCompose([
augmentation.ResizeDownToSizeTransform(512),
augmentation.PaddTransform(pad_size=2**net.depth)
])
self.trainset = SegmentationDataLoader(
image_path='/Data/dataset_10224_raw/raw_split/train/',
label_path='/Data/dataset_10224_glass_full/glass_full',
transform=train_transforms,
testing=th_count == 1)
self.validationset = SegmentationDataLoader(
image_path='/Data/dataset_10224_raw/raw_split/validation/',
label_path='/Data/dataset_10224_glass_full/glass_full',
transform=val_transforms,
testing=th_count == 1)
self.testset = SegmentationDataLoader(
image_path='/Data/dataset_10224_raw/raw_split/test/',
label_path='/Data/dataset_10224_glass_full/glass_full',
transform=val_transforms,
testing=th_count == 1)
self.trainloader = torch.utils.data.DataLoader(self.trainset,
batch_size=batch_size,
shuffle=True,
num_workers=th_count,
pin_memory=True)
self.validationloader = torch.utils.data.DataLoader(
self.validationset,
batch_size=1,
shuffle=False,
num_workers=th_count,
pin_memory=True)
self.testloader = torch.utils.data.DataLoader(self.testset,
batch_size=1,
shuffle=False,
num_workers=th_count,
pin_memory=True)
def __init__(self, train, depth, debug=False, category='person'):
self.debug = debug
self.train = train
train_datasets = [
VOCDataset('train', 'Voc'),
ADEChallengeData2016('train', 'ADEChallengeData2016'),
CityscapesDataset('train', 'fine', 'Cityscapes'),
CocoDataset(
'train2017',
'annotations_trainval2017/annotations/instances_train2017.json'
),
]
self.labels = sorted(
list(set(sum([x.labels for x in train_datasets], []))))
if category != None:
self.supported_labels = [category]
else:
self.supported_labels = self.labels
if train:
self.datasets = train_datasets
if not train:
self.datasets = [
VOCDataset('val', 'Voc'),
ADEChallengeData2016('val', 'ADEChallengeData2016'),
CityscapesDataset('val', 'fine', 'Cityscapes'),
CocoDataset(
'val2017',
'annotations_trainval2017/annotations/instances_val2017.json'
),
]
self.selector = [[
self.supported_labels.index(u) +
1 if u in self.supported_labels else 0 for u in x.labels
] for x in self.datasets]
if train:
self.transforms = augmentation.PairCompose([
augmentation.RandomHorizontalFlipTransform(),
augmentation.RandomResizeTransform(),
augmentation.RandomCropTransform((448, 448)),
augmentation.RandomNoiseTransform(),
augmentation.RandomColorJitterTransform(),
augmentation.RandomBlurTransform(),
augmentation.JPEGcompression(95),
augmentation.OneHotTransform(
len(self.supported_labels) + 1, self.selector),
augmentation.OutputTransform()
])
if not train:
self.transforms = augmentation.PairCompose([
augmentation.PaddTransform(2**depth),
augmentation.JPEGcompression(95),
augmentation.OneHotTransform(
len(self.supported_labels) + 1, self.selector),
augmentation.OutputTransform()
])
if self.debug == 1:
self.data_ids = [(i, j) for i, dataset in enumerate(self.datasets)
for j in range(50)]
else:
self.data_ids = [(i, j) for i, dataset in enumerate(self.datasets)
for j in range(len(self.datasets[i]))]
# self.data_ids = self.data_ids[150:]
random.seed(0)
self.color_set = [[random.random() for _ in range(3)]
for _ in range(len(self.labels))]
app = Flask(__name__)
model_path = 'checkpoints/YoloV2/64/0,5-1,0-2,0/Coco_checkpoints.pth'
model = torch.load(model_path).eval().cuda()
# feature_range = range(model.feature_start_layer, model.feature_start_layer + model.feature_count)
prior_box_sizes = model.prior_box_sizes
strides = model.strides
target_to_box_transform = output_transform.TargetTransformToBoxes(
prior_box_sizes=prior_box_sizes,
classes=model.classes,
ratios=model.ratios,
strides=strides)
padder = augmentation.PaddTransform(pad_size=2**model.depth)
transfor = augmentation.OutputTransform()
camera_models = {}
# nparr = np.fromstring(request.data, np.uint8)
# img_input = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
img_input = cv2.imread('/Data/Coco/val2017/000000581357.jpg')
img = imutils.resize(img_input, height=416)
padded_img, _ = padder(Image.fromarray(img), None)
model_key = '_'.join(str(x) for x in list(img.shape))
img_tensor, _ = transfor(padded_img, None)
img_tensor = img_tensor.unsqueeze(0).float().cuda()
if model_key not in camera_models:
camera_models[model_key] = torch2trt(model, [img_tensor])
outputs = camera_models[model_key](img_tensor),
outs = [
model.ranges.activate_output(out).squeeze(0).cpu().numpy()
def __init__(self,
net,
annDir='/Data/Coco/',
batch_size=1,
train_transforms=None,
val_transforms=None,
th_count=mu.cpu_count()):
if train_transforms is None:
train_transforms = augmentation.PairCompose([
augmentation.RandomResizeTransform(),
augmentation.RandomHorizontalFlipTransform(),
augmentation.RandomCropTransform((416, 416)),
augmentation.RandomNoiseTransform(),
augmentation.RandomColorJitterTransform(),
augmentation.RandomBlurTransform(),
augmentation.RandomJPEGcompression(95),
augmentation.TargetTransform(
prior_box_sizes=net.prior_box_sizes,
classes=net.classes,
ratios=net.ratios,
strides=net.strides),
augmentation.OutputTransform()
])
if val_transforms is None:
val_transforms = augmentation.PairCompose([
augmentation.PaddTransform(pad_size=2**net.depth),
augmentation.TargetTransform(
prior_box_sizes=net.prior_box_sizes,
classes=net.classes,
ratios=net.ratios,
strides=net.strides),
augmentation.OutputTransform()
])
self.target_to_box_transform = output_transform.TargetTransformToBoxes(
prior_box_sizes=net.prior_box_sizes,
classes=net.classes,
ratios=net.ratios,
strides=net.strides)
train_dir = os.path.join(annDir, 'train2017')
train_ann_file = os.path.join(
annDir,
'annotations_trainval2017/annotations/instances_train2017.json')
validation_dir = os.path.join(annDir, 'val2017')
validation_add_file = os.path.join(
annDir,
'annotations_trainval2017/annotations/instances_val2017.json')
self.trainset = CocoDetection(root=train_dir,
annFile=train_ann_file,
transforms=train_transforms)
self.validationset = CocoDetection(root=validation_dir,
annFile=validation_add_file,
transforms=val_transforms)
if th_count == 1:
self.trainset.ids = self.trainset.ids[:100]
self.validationset.ids = self.validationset.ids[:10]
self.trainloader = torch.utils.data.DataLoader(self.trainset,
batch_size=batch_size,
shuffle=True,
num_workers=th_count,
pin_memory=True)
self.validationloader = torch.utils.data.DataLoader(
self.validationset,
batch_size=1,
shuffle=False,
num_workers=th_count,
pin_memory=True)
self.trainloader.cats = net.classes
self.validationloader.cats = net.classes