def model_fn(model_dir):
"""Load the PyTorch model from the `model_dir` directory."""
print("Loading model.")
# First, load the parameters used to create the model.
model_info = {}
model_info_path = os.path.join(model_dir, 'model_info.pth')
with open(model_info_path, 'rb') as f:
model_info = torch.load(f)
print("model_info: {}".format(model_info))
# Determine the device and construct the model.
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = BinaryClassifier(model_info['input_features'],
model_info['hidden_dim'],
model_info['output_dim'])
# Load the stored model parameters.
model_path = os.path.join(model_dir, 'model.pth')
with open(model_path, 'rb') as f:
model.load_state_dict(torch.load(f))
# set to eval mode, could use no_grad
model.to(device).eval()
#test double
model = model.double()
print("Done loading model.")
return model
def model_fn(model_dir):
"""Load the PyTorch model from the `model_dir` directory."""
print("Loading model.")
model_info = {}
model_info_path = os.path.join(model_dir, 'model_info.pth')
with open(model_info_path, 'rb') as f:
model_info = torch.load(f)
print("model_info: {}".format(model_info))
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = BinaryClassifier(model_info['input_features'],
model_info['hidden_dim'],
model_info['output_dim'])
model_path = os.path.join(model_dir, 'model.pth')
with open(model_path, 'rb') as f:
model.load_state_dict(torch.load(f))
model.to(device).eval()
print("Done loading model.")
return model
def model_fn(model_dir):
"""Load the PyTorch model from the `model_dir` directory."""
print("Loading model.")
# First, load the parameters used to create the model.
model_info = {}
model_info_path = os.path.join(model_dir, "model_info.pth")
with open(model_info_path, "rb") as f:
model_info = torch.load(f)
print("model_info: {}".format(model_info))
# Determine the device and construct the model.
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = BinaryClassifier(
model_info["input_features"],
model_info["hidden_dim"],
model_info["output_dim"],
model_info["momentum"],
model_info["dropout_rate"],
model_info["num_layers"],
)
# Load the store model parameters.
model_path = os.path.join(model_dir, "model.pth")
with open(model_path, "rb") as f:
model.load_state_dict(torch.load(f))
# Prep for testing
model.to(device).eval()
print("Done loading model.")
return model
def build_model(self):
""" Rough """
if self.cfg.task == 'cls':
self.model = BinaryClassifier(num_classes=2)
elif self.cfg.task == 'seg':
self.model = UNet(num_classes=2)
self.criterion = nn.CrossEntropyLoss()
self.optim = torch.optim.Adam(self.model.parameters(),
lr=self.cfg.lr,
betas=(self.cfg.beta0, self.cfg.beta1))
if self.n_gpus > 1:
print('### {} of gpus are used!!!'.format(self.n_gpus))
self.model = nn.DataParallel(self.model)
self.model = self.model.to(self.device)
import os
import cv2
import torch
from model import BinaryClassifier
from c3d_detector import C3D_detector
from feature_extractor import FeatureExtractor
LOG = True
CLIP_LEN = 60
## Load C3D feature extractor
extractor = FeatureExtractor('c3d_sports1m.h5')
## Load Binary Classifier
classifier = BinaryClassifier()
detector = C3D_detector(classifier, checkpoint='checkpoints/model_epoch19.pth')
## Obtain list of videos
BASE_DIR = '../../data/videos/'
video_list = os.listdir(BASE_DIR)
print("Processing %d videos"%len(video_list))
for video_p in video_list:
print(video_p)
## Setup reading from video stream
video_path = os.path.join(BASE_DIR, video_p)
video_stream = cv2.VideoCapture(video_path)
## Setup output video
# Read in csv training file
training_dir = args.data_dir
train_data = pd.read_csv(os.path.join(training_dir, "train.csv"),
header=None,
names=None)
# Labels are in the first column
train_y = train_data.iloc[:, 0]
train_x = train_data.iloc[:, 1:]
## --- Your code here --- ##
## DONE: Define a model
# .to(device) for GPU usage
model = BinaryClassifier(args.input_features, args.hidden_dim,
args.output_dim).to(device)
## TODO: Define an optimizer and loss function for training
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = torch.nn.BCELoss()
## DONE: Train the model
# same code as usual
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_features,
'hidden_dim': args.hidden_dim,
'output_dim': args.output_dim
}
torch.save(model_info, f)
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
## --- Your code here --- ##
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
model = BinaryClassifier(args.input_features, args.hidden_dim,
args.output_dim).to(device)
## TODO: Define an optimizer and loss function for training
model_params = list(model.parameters())
optimizer = optim.Adam(model_params, lr=args.lr)
criterion = nn.BCELoss()
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, args.epochs, criterion, optimizer, device)
## TODO: complete in the model_info by adding three argument names, the first is given
# Keep the keys of this dictionary as they are
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_features,
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
## --- Your code here --- ##
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
model = BinaryClassifier(
args.input_features,
args.hidden_dim,
args.output_dim
).to(device)
## TODO: Define an optimizer and loss function for training
BEST_LEARNING_RATE_ACCORDING_TO_REDDIT_ARTICLE = 0.0003
optimizer = optim.Adam(model.parameters(), lr=BEST_LEARNING_RATE_ACCORDING_TO_REDDIT_ARTICLE)
criterion = nn.BCELoss()
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, args.epochs, criterion, optimizer, device)
## TODO: complete in the model_info by adding three argument names, the first is given
# Keep the keys of this dictionary as they are
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
## --- Your code here --- ##
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
model = BinaryClassifier(args.input_features, args.hidden_dim,
args.output_dim).to(device)
## TODO: Define an optimizer and loss function for training
optimizer = optim.AdamW(model.parameters(), lr=0.001, betas=(0.9, 0.999))
criterion = torch.nn.BCELoss()
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, args.epochs, criterion, optimizer, device)
## TODO: complete in the model_info by adding three argument names, the first is given
# Keep the keys of this dictionary as they are
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_features,
'hidden_dim': args.hidden_dim,
print(f"Trained for {args.epochs} epochs with model {model_name}")
print(
f"Best validation accuracy obtained: {logs.best_model_acc} at epoch {logs.best_model_ep}"
)
print(
f"Final training model Loss: {sum(logs.losses[-logs.train_size:]) / logs.train_size}"
)
print(f"Training took {logs.total_training_time} seconds.")
if __name__ == "__main__":
# Init everything
if args.model == "custom":
model = CustomCNN()
else:
model = BinaryClassifier(args.model)
model.apply(weights_init)
criterion = nn.BCEWithLogitsLoss(reduction="mean")
optimizer = optim.SGD(model.parameters(), lr=args.lr)
lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)
# Log some things
logger = Logger(
f"{model.name}_ep{args.epochs}_lr{args.lr}_{args.exp_name}")
# Define data augments and transforms
if args.disable_transform:
train_transforms = None
test_transforms = None
else:
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
## --- Your code here --- ##
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
model = BinaryClassifier(args.input_dim, args.hidden_dim, 1)
## TODO: Define an optimizer and loss function for training
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.BCELoss()
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, args.epochs, criterion, optimizer, device)
## TODO: complete in the model_info by adding three argument names, the first is given
# Keep the keys of this dictionary as they are
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_dim,
'hidden_dim': args.hidden_dim,
# args holds all passed-in arguments
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
val_loader = _get_validation_data_loader(args.batch_size, args.data_dir)
## Build the model by passing in the input params
model = BinaryClassifier(args.input_features, args.hidden_dim1,
args.hidden_dim2, args.hidden_dim3,
args.output_dim, args.dropout_rate).to(device)
## Define an optimizer and loss function for training
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.l2_reg)
criterion = nn.BCELoss()
model_path = os.path.join(args.model_dir, 'model.pth')
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, val_loader, args.epochs, args.patience,
criterion, optimizer, device, model_path)
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
## --- Your code here --- ##
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
model = BinaryClassifier(args.embedding_dim, args.hidden_dim, args.vocab_size).to(device)
## TODO: Define an optimizer and loss function for training
optimizer = optim.Adam(model.parameters())
criterion = torch.nn.BCELoss()
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, args.epochs, criterion, optimizer, device)
## TODO: complete in the model_info by adding three argument names, the first is given
# Keep the keys of this dictionary as they are
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_features,
'hidden_dim': <add_arg>,
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
## --- Your code here --- ##
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
model = BinaryClassifier(input_features=args.input_features,
hidden_dim=args.hidden_dim,
output_dim=args.output_dim)
## TODO: Define an optimizer and loss function for training
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = torch.nn.BCELoss()
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, args.epochs, criterion, optimizer, device)
## TODO: complete in the model_info by adding three argument names, the first is given
# Keep the keys of this dictionary as they are
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_features,
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
## --- Your code here --- ##
## TODO: Build the model by passing in the input params
# To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim
# Don't forget to move your model .to(device) to move to GPU , if appropriate
input_features = args.input_features
hidden_dim = args.hidden_dim
output_dim = args.output_dim
model = BinaryClassifier(input_features, hidden_dim, output_dim).to(device)
## TODO: Define an optimizer and loss function for training
optimizer = optim.Adam(model.parameters())
criterion = torch.nn.BCELoss()
# Trains the model (given line of code, which calls the above training function)
train(model, train_loader, args.epochs, criterion, optimizer, device)
## TODO: complete in the model_info by adding three argument names, the first is given
# Keep the keys of this dictionary as they are
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_features,
'hidden_dim': args.hidden_dim,
label_encoder.fit(action_names)
print("List of classes: ", list(label_encoder.classes_))
## Prepare Training and Testing dataset
train_list, test_list, train_label, test_label = get_data(
ROOT_DIR, label_encoder)
train_set = Dataset_C3D(ROOT_DIR, train_list, train_label)
valid_set = Dataset_C3D(ROOT_DIR, test_list, test_label)
train_loader = data.DataLoader(train_set, **params)
valid_loader = data.DataLoader(valid_set, **params)
## Initialize model
classifier = BinaryClassifier()
optimizer = torch.optim.Adam(list(classifier.parameters()),
lr=LEARNING_RATE)
# record training process
epoch_train_losses = []
epoch_train_scores = []
epoch_test_losses = []
epoch_test_scores = []
# start training
import time
for epoch in range(epochs):
# train, test model
train_losses, train_scores = train(log_interval, classifier, device,
# Model parameters
parser.add_argument('--input_features', type=int, default=3)
parser.add_argument('--hidden_dim', type=int, default= 32)
parser.add_argument('--output_dim', type=int, default=1)
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device {}.".format(device))
torch.manual_seed(args.seed)
# Load the training data.
train_loader = _get_train_data_loader(args.batch_size, args.data_dir)
model = BinaryClassifier(args.input_features, args.hidden_dim, args.output_dim).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.BCELoss()
train(model, train_loader, args.epochs, criterion, optimizer, device)
model_info_path = os.path.join(args.model_dir, 'model_info.pth')
with open(model_info_path, 'wb') as f:
model_info = {
'input_features': args.input_features,
'hidden_dim': args.hidden_dim,
'output_dim': args.output_dim,
}
torch.save(model_info, f)
# Save the model parameters
def prepare(args):
resume_from_checkpoint = args.resume_from_checkpoint
prepare_start_time = time.time()
logger.info('global', 'Start preparing.')
check_config_dir()
logger.info('setting', config_info(), time_report=False)
model = Baseline(num_classes=Config.nr_class).cuda()
logger.info('setting', model_summary(model), time_report=False)
logger.info('setting', str(model), time_report=False)
bclassifier = BinaryClassifier(Config.in_planes).cuda()
train_transforms = transforms.Compose([
transforms.Resize(Config.input_shape),
transforms.RandomApply([
transforms.ColorJitter(
brightness=0.3, contrast=0.3, saturation=0.3, hue=0)
],
p=0.5),
transforms.RandomHorizontalFlip(),
transforms.Pad(10),
transforms.RandomCrop(Config.input_shape),
transforms.ToTensor(),
transforms.RandomErasing(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
test_transforms = transforms.Compose([
transforms.Resize(Config.input_shape),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
trainset = Veri776_train(transforms=train_transforms)
testset = Veri776_test(transforms=test_transforms)
pksampler = PKSampler(trainset, p=Config.P, k=Config.K)
train_loader = torch.utils.data.DataLoader(trainset,
batch_size=Config.batch_size,
sampler=pksampler,
num_workers=Config.nr_worker,
pin_memory=True)
test_loader = torch.utils.data.DataLoader(
testset,
batch_size=Config.batch_size,
sampler=torch.utils.data.SequentialSampler(testset),
num_workers=Config.nr_worker,
pin_memory=True)
weight_decay_setting = parm_list_with_Wdecay(model)
weight_decay_setting_bc = parm_list_with_Wdecay(bclassifier)
weight_decay_setting += weight_decay_setting_bc
optimizer = torch.optim.Adam(weight_decay_setting, lr=Config.lr)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer,
lr_lambda=lr_multi_func)
losses = {}
losses['cross_entropy_loss'] = torch.nn.CrossEntropyLoss()
losses['pair_loss'] = torch.nn.CrossEntropyLoss()
for k in losses.keys():
losses[k] = losses[k].cuda()
start_epoch = 0
if resume_from_checkpoint and os.path.exists(Config.checkpoint_path):
checkpoint = load_checkpoint()
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
scheduler.load_state_dict(checkpoint['scheduler'])
# continue training for next the epoch of the checkpoint, or simply start from 1
start_epoch += 1
ret = {
'start_epoch': start_epoch,
'model': model,
'bclassifier': bclassifier,
'train_loader': train_loader,
'test_loader': test_loader,
'optimizer': optimizer,
'scheduler': scheduler,
'losses': losses
}
prepare_end_time = time.time()
time_spent = sec2min_sec(prepare_start_time, prepare_end_time)
logger.info(
'global', 'Finish preparing, time spend: {}mins {}s.'.format(
time_spent[0], time_spent[1]))
return ret
