def train(batch_size=32, num_epochs=2000):
train_set_x, train_set_y, test_set_x, test_set_y, y_classes = load_dataset()
tr_mini_batches = get_minibatches(train_set_x, train_set_y, batch_size)
num_classes = len(y_classes)
net = Net(num_classes)
num_batches = len(tr_mini_batches)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.85)
for e in range(num_epochs):
data_loss = 0.0
for idx, batch in enumerate(tr_mini_batches):
mini_batch_x, mini_batch_y = batch
tr_shape = mini_batch_x.shape
x_tensor = torch.from_numpy(mini_batch_x.reshape((tr_shape[0], 3, 64, 64)))
x_tensor = x_tensor.type('torch.FloatTensor')
y_tensor = torch.from_numpy(mini_batch_y)
# zero the parameter gradients
optimizer.zero_grad()
# Forward pass
output = net(x_tensor)
# loss
loss = criterion(output, y_tensor)
loss.backward()
optimizer.step()
# print statistics
data_loss += loss.item()
print('[%d, %5d] loss: %.5f' % (e + 1, idx + 1, loss.item()))
print('Average loss after epoch %d is : %.5f' % (e + 1, data_loss / num_batches))
test(test_set_x, test_set_y, net)
return net
def train(loaders, save_path):
"""returns trained model"""
# Initialize custom defined cnn
model = Net()
use_cuda = torch.cuda.is_available()
if use_cuda:
model.cuda()
# cross entropy loss for classification task
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=config.lr)
# initialize tracker for minimum validation loss
valid_loss_min = np.Inf
n_epochs = config.n_epochs
for epoch in range(1, n_epochs + 1):
# initialize variables to monitor training and validation loss
train_loss = 0.0
valid_loss = 0.0
model.train()
for batch_idx, (data, target) in enumerate(loaders['train']):
# move to GPU
if use_cuda:
data, target = data.cuda(), target.cuda()
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
# average training loss
train_loss += (1 / (batch_idx + 1)) * (loss.data - train_loss)
# vaidation
model.eval()
for batch_idx, (data, target) in enumerate(loaders['valid']):
# move to GPU
if use_cuda:
data, target = data.cuda(), target.cuda()
## update the average validation loss
output = model(data)
loss = criterion(output, target)
valid_loss += (1 / (batch_idx + 1)) * (loss.data - valid_loss)
# print training/validation statistics
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.
format(epoch, train_loss, valid_loss))
# save the model if validation loss has decreased
if valid_loss <= valid_loss_min:
torch.save(model.state_dict(), save_path)
# Updating the validation loss minimum
valid_loss_min = valid_loss
# return trained model
return model
def main():
start_time = time()
net = Net().to(setting.device)
net.train()
print('The modle has been initialized.')
# define loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)
train_dataloader = data_preprocess.get_train_dataloader()
for epoch in tqdm(range(num_epochs)):
start = time()
# for train accuracy
# total = setting.train_img_nums
# correct = 0
for batch_idx, (imgs, labels) in enumerate(train_dataloader):
# imgs = Variable(imgs)
# label = Variable(labels)
imgs, labels = imgs.to(setting.device), labels.to(setting.device)
labels = labels.long()
labels_ohe_predict = net(imgs)
loss = 0
for i in range(setting.char_num):
one_label = labels[:, i * setting.pool_length:(i + 1) *
setting.pool_length]
one_class = one_label.argmax(dim=1)
one_predict_label = labels_ohe_predict[:,
i * setting.pool_length:
(i + 1) *
setting.pool_length]
one_loss = criterion(one_predict_label, one_class)
loss += one_loss
optimizer.zero_grad()
loss.backward()
optimizer.step()
# for single in range(labels_ohe_predict.shape[0]):
# single_labels_ohe_predict = labels_ohe_predict[single, :]
# predict_label = ''
# # get predict_label
# for slice in range(setting.char_num):
# char = ohe.num2char[np.argmax(
# single_labels_ohe_predict[slice*setting.pool_length:(slice+1)*setting.pool_length].cpu().data.numpy())]
# predict_label += char
# # get true label
# true_label = ohe.decode(labels[single, :].cpu().numpy())
# if predict_label == true_label:
# correct += 1
end = time()
print('epoch: {}, time: {:.2f}s loss: {:.04}'.format(
epoch, end - start, loss.item()))
# print('epoch: {}, time: {:.2f}s loss: {:.04} accuracy: {}/{} -- {:.4f}'.format(
# epoch, end-start, loss.item(), correct, total, correct/total))
torch.save(net.state_dict(), './model.pt')
finnal_time = time()
print('End at {}, cost {:.0f}s'.format(finnal_time,
finnal_time - start_time))
def main():
net = Net().to(setting.device)
net.eval()
net.load_state_dict(torch.load('model.pt'))
print('model has been loaded.')
correct = 0
valid_dataloader = data_preprocess.get_valid_dataloader()
total = len(os.listdir(setting.valid_folder_path))
with torch.no_grad():
miss_character = {}
for (imgs, labels) in tqdm((valid_dataloader)):
imgs, labels = imgs.to(setting.device), labels.to(setting.device)
labels_ohe_predict = net(imgs)
# for each img in one batch
for single in range(labels_ohe_predict.shape[0]):
single_labels_ohe_predict = labels_ohe_predict[single, :]
predict_label = ''
# get predict_label
for slice in range(setting.char_num):
char = ohe.num2char[np.argmax(
single_labels_ohe_predict[slice*setting.pool_length:(slice+1)*setting.pool_length].cpu().data.numpy())]
predict_label += char
# get true label
true_label = ohe.decode(labels[single, :].cpu().numpy())
# print('true label:', true_label, ' predict label:', predict_label)
if predict_label == true_label:
correct += 1
else:
for i in range(setting.char_num):
if predict_label[i] != true_label[i]:
error_info = '{} -> {}'.format(true_label[i], predict_label[i])
if error_info in miss_character:
miss_character[error_info] +=1
else:
miss_character[error_info] =1
sorted_miss = sorted(miss_character.items(), key=lambda kv:kv[1], reverse=True)
sorted_miss=collections.OrderedDict(sorted_miss)
with open('miss_character.txt','w') as f:
for i in sorted_miss:
f.write('{} : {}\n'.format(i, sorted_miss[i]))
print('accuracy: {}/{} -- {:.4f}'.format(correct, total, correct/total))
import torch
warnings.filterwarnings(action='ignore')
data_transform1 = transforms.Compose([ToTensor()])
animals_dataset = AnimalsDataset(filename='meta-data_new/meta-data/train.csv', root_dir='./train_new/train/', train=True,
transform=data_transform1)
test_dataset = AnimalsDataset(filename='meta-data_new/meta-data/test.csv', root_dir='./test_new/test', train=False,
transform=data_transform1)
test_loader = DataLoader(test_dataset, batch_size=60)
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print(device)
net = Net().to(device)
print(net)
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
net.load_state_dict(torch.load("./models/model_ep50.net"))
net.eval()
#######################
# Testing an image
data_iter = iter(test_dataset)
sample = next(data_iter)
data, labels = sample['image'], sample['labels']
img = data
img = torch.unsqueeze(img, 0)
# Creating PT data samplers and loaders:
train_sampler = SubsetRandomSampler(train_indices)
valid_sampler = SubsetRandomSampler(val_indices)
train_loader = torch.utils.data.DataLoader(face_dataset,
batch_size=32,
sampler=train_sampler)
validation_loader = torch.utils.data.DataLoader(face_dataset,
batch_size=32,
sampler=valid_sampler)
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print(device)
net = Net().to(device)
print(net)
optimizer = optim.Adam(net.parameters())
epochs = 50
# net.load_state_dict(torch.load('model.net'))
for epoch in range(1, epochs + 1):
train(net, device, train_loader, optimizer, epoch)
test(net, device, validation_loader)
torch.save(net.state_dict(), "model_2.net")
for i_batch, sample_batched in enumerate(validation_loader):
net.eval()
def cnn_model_train(args):
train_transforms = transforms.Compose([transforms.Resize(( \
args.cnn_helmet_resize_width,
args.cnn_helmet_resize_height)),
transforms.ToTensor()])
train_data = datasets.ImageFolder(args.dataset_location,
transform=train_transforms)
train_loader = data_utils.DataLoader(train_data,
batch_size=args.batch_size,
shuffle=True,
drop_last = True)
model = Net()
if torch.cuda.is_available():
model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(),
lr = args.learning_rate)
for epoch in range(args.epoch):
start_time = time.time()
running_loss = 0.0
for i, data in enumerate(train_loader, 0):
inputs, labels = data
if torch.cuda.is_available():
inputs = inputs.cuda()
labels = labels.cuda()
optimizer.zero_grad()
np.random.shuffle(indices)
train_indices, val_indices = indices[split:], indices[:split]
# Creating PT data samplers and loaders:
train_sampler = SubsetRandomSampler(train_indices)
valid_sampler = SubsetRandomSampler(val_indices)
#dataloader = DataLoader(face_dataset, batch_size=32, shuffle=True)
train_loader = torch.utils.data.DataLoader(face_dataset, batch_size=32, sampler=train_sampler)
validation_loader = torch.utils.data.DataLoader(face_dataset, batch_size=32, sampler=valid_sampler)
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
print(device)
net = Net().to(device)
print(net)
# params = list(net.parameters())
# print(len(params))
# for i in range(10):
# print(params[i].size())
# optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
optimizer = optim.Adam(net.parameters())
epochs = 20
# net.load_state_dict(torch.load('model.net'))
for epoch in range(1, epochs + 1):
help='whether to use dropout in network')
parser.add_argument('--epochs', default=20, help='Number of Epochs')
parser.add_argument('--lr', default=0.01, help='Default LR set to one')
return parser.parse_args()
if __name__ == '__main__':
args = parse()
# is cuda available?
use_cuda = not args.no_cuda and torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
# load the data
train_loader, test_loader = LoadData().load_data()
model = Net(dropout=args.dropout).to(device)
logging.debug("Model Summary {}".format(
summary(model, input_size=(3, 32, 32))))
model = Net().to(device)
optimizer = optim.SGD(model.parameters(),
lr=0.01,
momentum=0.9,
nesterov=False)
# scheduler = StepLR(optimizer, step_size=8, gamma=0.1)
for epoch in range(args.epochs):
# print('Epoch:', epoch+1,'LR:', scheduler.get_lr()[0])
model.train(model, device, train_loader, optimizer)
model.test(model, device, test_loader)
import torch
from cnn_model import Net
from PIL import Image
from torchvision import transforms
import warnings
warnings.filterwarnings("ignore", category=UserWarning)
warnings.filterwarnings("ignore", category=DeprecationWarning)
model = Net()
if torch.cuda.is_available():
model.cuda()
def helmet_detection(img, args):
model.load_state_dict(torch.load(args.cnn_model_location))
predict_transforms = transforms.Compose([transforms.Resize(( \
args.cnn_helmet_resize_width,
args.cnn_helmet_resize_height)),
transforms.ToTensor()])
image_tensor = predict_transforms(Image.open(img)).float()
out = model(
image_tensor.view(1, 3, args.cnn_helmet_resize_width,
args.cnn_helmet_resize_height))
return (int(torch.argmax(out.cpu())))
#
X, Y = make_XY(traing_data, label_ids)
X_test, Y_test = make_XY(testing_data, label_ids)
train_dataset = makeTorchDataset(X, Y)
test_dataset = makeTorchDataset(X_test, Y_test)
train_dataloader = makeTorchDataLoader(train_dataset,
batch_size=32,
shuffle=True)
test_dataloader = makeTorchDataLoader(test_dataset,
batch_size=1,
shuffle=True)
# setting & init
model = Net()
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
print("using device %s" % device)
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.AdamW(model.parameters(), lr=5e-6)
# train
train_model_options = {
'model': model,
'optimizer': optimizer,
'loss_func': criterion,
'train_dataloader': train_dataloader,
'device': device
}
6: 'Neutral'
}
def process_img(original_image):
processed_img = cv2.cvtColor(original_image, cv2.COLOR_BGR2GRAY)
#processed_img = cv2.Canny(processed_img, threshold1 = 100, threshold2 = 200)
return processed_img
def image_to_tensor(img):
img = cv2.resize(img, dsize=(48, 48), interpolation=cv2.INTER_CUBIC)
return torch.Tensor(img.reshape(1, 1, 48, 48))
model = Net()
dir_path = os.path.dirname(os.path.realpath(__file__))
model.load_state_dict(torch.load(dir_path + '/models/current_model.pth'))
curr_emotion = "Neutral"
emotion_ave = []
last_time = time.time()
while (True):
#Grabs image from screen
screen = np.array(ImageGrab.grab(bbox=(300, 300, 500, 500)))
processed_img = cv2.cvtColor(screen, cv2.COLOR_BGR2RGB)
new_screen = process_img(screen)
# Convert iamge to tensor and predict the emotion
x = new_screen