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