# from bbox_loss import MultiboxLoss
from PIL import Image, ImageDraw
# import torchvision.transforms as transforms
import os
import matplotlib.pyplot as plt
import matplotlib.patches as patches
use_gpu = True
img_dir = '../cityscapes_samples/'
label_dir = '../cityscapes_samples_labels/'
learning_rate = 0.001
max_epochs = 20
test_list = get_list(img_dir, label_dir)
# test_list = test_list[0:-20]
test_dataset = csd.CityScapeDataset(test_list, train=False, show=False)
test_data_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=16,
shuffle=False,
num_workers=0)
print('test items:', len(test_dataset))
file_name = 'SSD'
test_net_state = torch.load(os.path.join('.', file_name + '.pth'))
net = SSD(3)
if use_gpu:
net = net.cuda()
net.load_state_dict(test_net_state)
itr = 0
import numpy as np
import matplotlib.patches as patches
from matplotlib import pyplot as plt
import torch.nn
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
test_model = torch.load('trained_model/ssd_net_1017.pth')
test_model.to('cuda:0')
test_model.eval()
test_img_dir_list = pd.read_csv('train_img_dir_list.csv').iloc[:, 1].tolist()
test_json_dir_list = pd.read_csv('train_json_dir_list.csv').iloc[:, 1].tolist()
test_dataset = cityscape_dataset.CityScapeDataset(test_img_dir_list,
test_json_dir_list,
mode='eval',
transform=None)
test_loader = DataLoader(test_dataset,
batch_size=16,
shuffle=True,
num_workers=4)
for batch_idx, (img, bbox, label, priors) in enumerate(test_loader):
# print(batch_idx)
inputs = img.float().to(device)
pred_conf, pred_locs = test_model.forward(inputs)
# print(pred_conf)
# softmax = torch.nn.LogSoftmax(dim = 2)
# pred_conf = softmax(pred_conf)
for i in range(pred_locs.shape[0]):
from ssd_net import SSD
from bbox_loss import MultiboxLoss
import torch.optim as optim
import torch
import pandas as pd
import os
import copy
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
train_img_dir_list = pd.read_csv('train_img_dir_list.csv').iloc[:, 1].tolist()
train_json_dir_list = pd.read_csv('train_json_dir_list.csv').iloc[:,
1].tolist()
val_img_dir_list = pd.read_csv('val_img_dir_list.csv').iloc[:, 1].tolist()
val_json_dir_list = pd.read_csv('val_json_dir_list.csv').iloc[:, 1].tolist()
train_dataset = cityscape_dataset.CityScapeDataset(train_img_dir_list,
train_json_dir_list,
transform=None,
mode="train")
val_dataset = cityscape_dataset.CityScapeDataset(val_img_dir_list,
val_json_dir_list,
transform=None,
mode="eval")
train_loader = DataLoader(train_dataset,
batch_size=128,
shuffle=True,
num_workers=4)
val_loader = DataLoader(val_dataset,
batch_size=128,
shuffle=True,
num_workers=4)
from bbox_loss import MultiboxLoss
from PIL import Image, ImageDraw
import torchvision.transforms as transforms
import os
use_gpu = True
img_dir = '../cityscapes_samples/'
label_dir = '../cityscapes_samples_labels/'
learning_rate = 0.001
max_epochs = 200
train_list = get_list(img_dir, label_dir)
# print('list',train_list)
# valid_list = train_list[-20: ]
# train_list = train_list[0:-20]
train_dataset = csd.CityScapeDataset(train_list, train=True, show=False)
train_data_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=32,
shuffle=True,
num_workers=0)
# print('train items:', len(train_dataset))
idx, (bbox, label, img) = next(enumerate(train_data_loader))
# valid_dataset = csd.CityScapeDataset(train_list, False, False)
# valid_data_loader = torch.utils.data.DataLoader(valid_dataset,
# batch_size=4,
# shuffle=False,
# num_workers=0)
# print('validation items:', len(valid_dataset))
class Training():
# Set default tenosr type, 'torch.cuda.FloatTensor' is the GPU based FloatTensor
torch.set_default_tensor_type('torch.cuda.FloatTensor')
current_directory = os.getcwd() # current working directory
training_ratio = 0.8
if __name__ == '__main__':
poly_init_fol_name = "cityscapes_samples_labels"
init_img_path = "cityscapes_samples"
compl_poly_path = os.path.join(current_directory, poly_init_fol_name,
"*", "*_polygons.json")
polygon_folder = glob(compl_poly_path)
polygon_folder = np.array(polygon_folder)
img_label_list = []
for file in polygon_folder:
with open(file, "r") as f:
frame_info = json.load(f)
obj_length = len(frame_info['objects'])
file_path = file
image_name = file_path.split("/")[-1][:-23]
for i in range(obj_length):
label = frame_info['objects'][i]['label']
if label == "ego vehicle":
break
polygon = np.array(frame_info['objects'][i]['polygon'],
dtype=np.float32)
left_top = np.min(polygon, axis=0)
right_bottom = np.max(polygon, axis=0)
concat = np.concatenate((left_top, right_bottom))
img_label_list.append({
'image_name': image_name,
'file_path': file_path,
'label': label,
'bbox': concat
})
label_length = len(img_label_list)
# get images list
img_path = os.path.join(init_img_path, "*", "*")
images = glob(img_path)
images = np.array(images)
train_datalist = []
for i in range(0, len(images)):
img_folder = images[i].split('/')[-2]
img_name = images[i].split('/')[-1]
img_class = img_name[:-16]
image_path = os.path.join(init_img_path, img_folder, img_name)
#print(image_path)
bound_boxes = []
labels = []
for i in range(label_length):
if img_label_list[i]["image_name"] == img_class:
bbox = img_label_list[i]['bbox']
bound_boxes.append(bbox)
if img_label_list[i]['label'] in ('car', 'cargroup'):
label = 1
elif img_label_list[i]['label'] in ('person',
'persongroup'):
label = 2
elif img_label_list[i]['label'] == 'traffic sign':
label = 3
else:
label = 0
labels.append(label)
train_datalist.append({
'image_path': image_path.rstrip(),
'labels': labels,
'bound_boxes': bound_boxes
})
random.shuffle(train_datalist)
#print(train_datalist)
n_train_sets = 0.8 * len(train_datalist)
train_sets = train_datalist[:int(n_train_sets)]
im = np.array(Image.open(train_sets[1]['image_path']), dtype=np.uint8)
# Create figure and axes
fig, ax = plt.subplots(1)
# Display the image
ax.imshow(im)
# Create a Rectangle patch
for i in range(0, len(train_sets[1]['labels'])):
if train_sets[1]['labels'][i] != 0:
rect = patches.Rectangle((train_sets[1]['bound_boxes'][i][0],
train_sets[1]['bound_boxes'][i][1]),
train_sets[1]['bound_boxes'][i][2],
train_sets[1]['bound_boxes'][i][3],
linewidth=1,
edgecolor='r',
facecolor='none')
# Add the patch to the Axes
ax.add_patch(rect)
plt.show()
train_dataset = cityscape_dataset.CityScapeDataset(train_sets)
train_data_loader: object = torch.utils.data.DataLoader(train_dataset,
batch_size=20,
shuffle=True,
num_workers=0)
print('Total training items', len(train_dataset),
', Total training mini-batches in one epoch:',
len(train_data_loader))
n_valid_sets = 0.2 * len(train_datalist)
valid_sets = train_datalist[int(n_train_sets):int(n_train_sets +
n_valid_sets)]
valid_set = cityscape_dataset.CityScapeDataset(valid_sets)
valid_data_loader = torch.utils.data.DataLoader(valid_set,
batch_size=20,
shuffle=True,
num_workers=0)
print('Total validation set:', len(valid_set),
', Total training mini-batches in one epoch:',
len(valid_data_loader))
ssd = ssd_net.SSD().cuda()
#print(ssd)
criterion = bbox_loss.MultiboxLoss((0.1, 0.2))
optimizer = torch.optim.Adam(ssd.classifier.parameters(), lr=0.01)
train_losses = []
max_epochs = 1
itr = 0
#print(train_data_loader)
for epoch_idx in range(0, max_epochs):
for img_tensor, train_input, train_label in train_data_loader:
itr += 1
# Set the network works in GPU
device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
ssd = ssd.to(device)
# print(device)
for img, features, targets in train_data_loader:
features = features.to(device)
targets = targets.to(device)
# switch to train model
ssd.train()
# zero the parameter gradients
optimizer.zero_grad()
# Forward
train_input = Variable(img_tensor.cuda(
)) # use Variable(*) to allow gradient flow
#print(train_input.dim())
confidence, train_out = ssd.forward(
train_input) # forward once
#print(train_out)
# compute loss
train_label = Variable(train_label.cuda().float())
loss = criterion.forward(confidence, train_out, train_label,
train_input)
# do the backward and compute gradients
loss.backward()
#
# update the parameters with SGD
optimizer.step()
train_losses.append((itr, loss.item()))
if itr % 200 == 0:
print('Epoch: %d Itr: %d Loss: %f' %
(epoch_idx, itr, loss.item()))
train_losses = np.asarray(train_losses)