def main():
# parse arguments from command line
args = parse_arguments()
# save model info to file
save_model_info(args)
# general parameters
name = args.name
# data parameters
max_length = args.maxlen
batch_size = args.bsize
parts = list(range(1, args.parts+1))
# learning parameters
val = args.val
epochs = args.epochs
lr = args.lr
wdecay = args.wdecay
momentum = args.momentum
# fixed parameter
init_fn = nn.init.kaiming_normal_
# datasets and loaders
train_dataset = TrainDataset('dataset', parts, max_length)
train_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=RandomSampler(train_dataset))
if val:
val_dataset = ValDataset('dataset/dev.preprocessed.npz', max_length)
val_loader = DataLoader(val_dataset, batch_size=batch_size//2, sampler=RandomSampler(val_dataset))
else:
val_loader = None
# model
if args.existing:
net = torch.load(args.existing)
else:
net = Resnet(train_dataset._nspeak, alpha=16)
# initialization
for layer in net.children():
if isinstance(layer, nn.Conv2d):
init_fn(layer.weight)
elif isinstance(layer, ResidualBlock):
for llayer in layer.children():
if isinstance(llayer, nn.Conv2d):
init_fn(llayer.weight)
# training parameters
optimizer = torch.optim.SGD(net.parameters(), nesterov=True, momentum=momentum, dampening=0, lr=lr, weight_decay=wdecay)
scheduler = None
criterion = nn.modules.loss.CrossEntropyLoss()
# initialize trainer
trainer = Trainer(train_loader, val_loader, name, net, optimizer, criterion, scheduler)
# run the training
trainer.train(epochs)
def get_model(model_name, num_classes):
model = None
if 'resnet' in model_name:
model = Resnet(model_name, num_classes)
elif 'efficientnet' in model_name:
model = EfficientNet(model_name, num_classes)
else:
raise ValueError(f'Undefined model name: {model_name}')
return model
def net(netname,num_classes,Train=True,Dataset=None):
netname=netname.lower()
if netname == "dnet34-34":
return Resnet.Dnet34_34(num_classes)
elif netname=="dnet50-34":
return Resnet.Dnet50_34(num_classes)
elif netname=="dnet34-18":
return Resnet.Dnet34_18(num_classes)
elif netname=="dnet18-18":
return Resnet.Dnet18_18(num_classes)
elif netname=="resnet18":
return Resnet.Resnet18(num_classes)
elif netname=="resnet34":
return Resnet.Resnet34(num_classes)
elif netname=="resnet50":
return Resnet.Resnet50(num_classes)
elif netname=="vgg19":
return VGG.VGG19(num_classes)
elif netname=="vgg16":
return VGG.VGG16(num_classes)
elif netname=="resnet50-vgg16":
return VGG.Resnet50_VGG16(num_classes)
else:
raise RuntimeError('Unspported networks')
model_ft = model_ft.to(device)
return model_ft
is_inception = False
if model_type == 'Simple':
is_inception = False
model_ft = NeuralNetwork(classes, image_size).to(device)
elif model_type == 'Inception3':
is_inception = True
model_ft = Inception3(num_classes=len(classes)).to(device)
elif model_type == 'Inception_transfer':
is_inception = False
model_ft = Inceptionnet(classes, aux_logits=True).to(device)
elif model_type == 'Resnet':
model_ft = Resnet(classes).to(device)
elif model_type == 'Alexnet':
model_ft = Alexnet(classes).to(device)
# print("model:", model_ft)
#train model
loss_fn = nn.CrossEntropyLoss()
optimizer_ft = torch.optim.SGD(model_ft.parameters(), lr=1e-3)
# set model: options [model, model_ft]
train_model = model_ft
train_optimizer = optimizer_ft
def train(dataloader, model, loss_fn, optimizer, is_inception=False):
size = len(dataloader.dataset)
print("train size", size)
4, 5, 8, 10
] #Mutiple scale to train the model on (you can use more scale if your pc is strong enough)
EPOCHS = args.num_epoch
save_location = 'model_data/' #model save location
if args.visdom:
vis = GraphVisualization() #initialize the visdom object
train_set = DataGenerator(root=args.root, scale=SCALE, split='train')
trainloader = DataLoader(train_set, shuffle=True)
test_set = DataGenerator(root=args.root, scale=5, split='test', augment=False)
testloader = DataLoader(test_set)
model = Resnet(n_classes=2, layers=args.layers).cuda() #load model into gpu
opt = Adam(filter(lambda p: p.requires_grad, model.parameters()),
lr=1e-5,
weight_decay=1e-3) #set optimizer
if args.epoch > 0: #if initial epoch given load corresponding model and opt state
print('Loading model and opt state_dict....')
model.load_state_dict(
torch.load(save_location + 'model/' + str(args.epoch) + '.pth'))
opt.load_state_dict(
torch.load(save_location + 'opt/' + str(args.epoch) + '.pth'))
r = range(args.epoch, EPOCHS) if args.epoch > 0 else range(
EPOCHS) #Either start from beginning or continue
for epoch in r:
def main_predict(cfg, model_name, verbose=False):
device = get_device()
try:
if model_name == "resnet":
model_path = cfg["models"][model_name]
print(model_path)
model = Resnet(cfg=cfg)
model.load_state_dict(
torch.load(model_path, map_location=torch.device('cpu')))
model.to(device)
print(f'Loaded model from file: {model_path}')
elif model_name == "efficientnet":
model_path = cfg["models"][model_name]
model = EfficientNet(cfg=cfg)
model.load_state_dict(
torch.load(model_path, map_location=torch.device('cpu')))
model.to(device)
print(f'Loaded model from file: {model_path}')
else:
resnet = Resnet(cfg=cfg)
resnet.load_state_dict(
torch.load(cfg["models"]["resnet"], map_location=device))
efficientnet = EfficientNet(cfg=cfg)
efficientnet.load_state_dict(
torch.load(cfg["models"]["efficientnet"],
map_location=torch.device('cpu')))
model = Ensemble(resnet=resnet, efficientnet=efficientnet)
except:
print("Wrong model name")
return
model.eval()
df_test = pd.read_csv(f'{cfg["DATASET_DIR"]}/sample_submission.csv')
test_dataset = DatasetTransformer_prediction(cfg=cfg, df=df_test)
test_dataset_loader = torch.utils.data.DataLoader(
dataset=test_dataset, batch_size=cfg["BATCH_SIZE"], shuffle=True)
if verbose and model_name != "ensemble":
summary(
model,
(3, cfg["IMAGE_SIZE"][model_name], cfg["IMAGE_SIZE"][model_name]))
predictions = get_prediction(model, test_dataset_loader, device,
model_name)
df_test[cfg["TARGET_COLS"]] = predictions
df_test[[cfg["IMAGE_COL"]] + cfg["TARGET_COLS"]].to_csv('submission.csv',
index=False)
if verbose:
print(df_test.head(20))
def main_train(cfg, model_name, verbose=False):
device = get_device()
data = get_data(cfg=cfg)
if data is not None:
train_data = data.sample(frac=cfg["TRAIN_VALIDATION_FRAC"])
validation_data = data.drop(train_data.index)
else:
return
train_transform = get_transform(image_size=cfg["IMAGE_SIZE"][model_name],
model_name=model_name,
cfg=cfg,
augmented=True)
validation_transform = get_transform(
image_size=cfg["IMAGE_SIZE"][model_name],
model_name=model_name,
cfg=cfg,
)
train_dataset = DatasetTransformer(train_data,
transform=train_transform,
cfg=cfg)
validation_dataset = DatasetTransformer(validation_data,
transform=validation_transform,
cfg=cfg)
train_dataset_loader = torch.utils.data.DataLoader(
dataset=train_dataset, batch_size=cfg["BATCH_SIZE"], shuffle=True)
validation_dataset_loader = torch.utils.data.DataLoader(
dataset=validation_dataset, batch_size=cfg["BATCH_SIZE"], shuffle=True)
if model_name == "resnet":
model = Resnet(cfg=cfg, pretrained=True)
pass
elif model_name == "efficientnet":
model = EfficientNet(cfg=cfg, pretrained=True)
else:
print("Wrong model name")
return
model.to(device)
if verbose:
summary(
model,
(3, cfg["IMAGE_SIZE"][model_name], cfg["IMAGE_SIZE"][model_name]))
optimizer = torch.optim.Adam(model.parameters(),
lr=cfg["LR"],
weight_decay=cfg["WEIGHT_DECAY"])
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,
patience=3,
factor=0.5,
verbose=verbose,
mode='min',
threshold=2 * 1e-2)
loss = nn.BCELoss()
train_updater = GraphUpdater(type="Train")
validation_updater = GraphUpdater(type="Validation")
model_checkpoint = ModelCheckpoint(model)
print(f"Training on {len(train_dataset)} images")
for t in range(cfg["EPOCHS"]):
print(f'Epoch: {t}')
train_loss, train_auc = train(model=model,
data_loader=train_dataset_loader,
loss_function=loss,
optimizer=optimizer,
device=device)
train_updater.update(**{"loss": train_loss, "accuracy": train_auc})
print(f'\tTraining step: Loss: {train_loss}, AUC: {train_auc}',
end='\n')
val_loss, val_auc = test(model=model,
data_loader=validation_dataset_loader,
loss_function=loss,
device=device)
validation_updater.update(**{"loss": val_loss, "accuracy": val_auc})
print(f'\tValidation step: Loss: {val_loss}, AUC: {val_auc}', end='\n')
torch.save(model.state_dict(), f'checkpoint_epoch_{t}.pth')
print('\tModel saved')
model_checkpoint.update(loss=val_loss)
scheduler.step(val_loss)
train_updater.display()
validation_updater.display()
# in windows has some issue when try to use DataLoader in pytorch, i don't know why...
train_loader = DataLoader(dataset=train_dataset,
batch_sampler=train_sampler,
num_workers=0 if os.name == 'nt' else 4,
pin_memory=True)
val_loader = DataLoader(dataset=val_dataset,
batch_sampler=val_sampler,
num_workers=0 if os.name == 'nt' else 4,
pin_memory=True)
# select a model, i prepaired two models for simple testing
if args.model == "resnet":
model = Resnet(
way=args.way,
shot=args.shot,
query=args.query,
num_layers=args.num_layers,
hidden_size=args.hidden_size,
bidirectional=args.bidirectional,
)
if args.model == "r2plus1d":
model = R2Plus1D(
way=args.way,
shot=args.shot,
query=args.query,
)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
optimizer = torch.optim.SGD(model.parameters(),
help="model predix (defult prefix)",
type=str)
parser.set_defaults(model_path="model/torch_model.pkl")
args = parser.parse_args()
# set device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# output_dir
out_dir = 'demo_img'
# load trained model
if args.net == 'ConvBnNet':
model = ConvBnNet([10, 20, 40], 10)
elif args.net == 'Resnet':
model = Resnet([10, 20, 40], 10)
else:
raise ValueError("Oops! not valid model arch. ")
model.load_state_dict(torch.load(args.model_path))
# img transform
transform = transforms.Compose([transforms.ToTensor()])
# request session
session = requests.Session()
response = session.get('http://www.taifex.com.tw/cht/captcha',
cookies={'from-my': 'browser'})
if not os.path.exists(out_dir):
os.makedirs(out_dir)
print("[test] number of videos / classes: {} / {}".format(
len(test_dataset), test_dataset.num_classes))
test_sampler = CategoriesSampler(test_dataset.classes, 400, args.way,
args.shot, args.query)
# in windows has some issue when try to use DataLoader in pytorch, i don't know why..
test_loader = DataLoader(dataset=test_dataset,
batch_sampler=test_sampler,
num_workers=0 if os.name == 'nt' else 4,
pin_memory=True)
if args.model == 'resnet':
model = Resnet(
way=args.way,
shot=args.shot,
query=args.query,
num_layers=args.num_layers,
hidden_size=args.hidden_size,
bidirectional=args.bidirectional,
)
if args.model == 'r2plus1d':
model = R2Plus1D(
way=args.way,
shot=args.shot,
query=args.query,
)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
model.load_state_dict(torch.load(load_path))
from torch.utils.data.dataloader import DataLoader
from tqdm import tqdm
import utils
from utils import logger
from config import config
from dataset import CustomTensorDataset
from models import Resnet, fcn_autoencoder, conv_autoencoder, VAE
from loss import VaeLoss
import numpy as np
import pandas as pd
from torch_optimizer import AdaBound
model_classes = {
"resnet": Resnet(),
"fcn": fcn_autoencoder(),
"cnn": conv_autoencoder(),
"vae": VAE(),
}
def train(device):
logger.info("start training...")
if config.use_wandb:
wandb.login(key="8e7f40150f49731a42b58b0284c816eed0e2e9c5")
wandb.init(project="MLHW8", entity="shawnhung", config=config)
dataset = CustomTensorDataset(Path(config.root_dir) / "trainingset.npy")
train_set, val_set = utils.train_val_dataset(dataset, 0.2)
'-t',
'--threshold',
default=0.9,
type=float,
help=
'Threshold to consider as positive, (predictions > threshold) will be counted as 1'
)
args = parser.parse_args()
gen = DataGenerator(root=args.root,
scale=args.scale,
split=args.split,
augment=False)
testloader = DataLoader(gen)
model = Resnet(n_classes=2, layers=101).cuda() #load model into gpu
model.load_state_dict(torch.load(args.model_name)) #load model weights
full_save_location = args.save_location + args.split + '/'
with tqdm(testloader) as t:
for i, batch in enumerate(t):
t.set_description('TESTING:') #set description for progress bar
out = model(batch['images'].cuda()) #get output
#softmax the output from model and load into cpu and convert to numpy array and get proper predictions
out = (torch.nn.functional.softmax(out, 1).cpu().detach().numpy()[0][1]
> args.threshold).astype(int)
img = np.asarray(batch['OG_image'][0]) #get the original image
if not os.path.exists(
random_interval=False,
)
train_loader = DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=0 if os.name == 'nt' else 4)
test_loader = DataLoader(test_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=0 if os.name == 'nt' else 4)
if args.model == "resnet":
model = Resnet(
num_classes=train_dataset.num_classes,
num_layers=args.num_layers,
hidden_size=args.hidden_size,
bidirectional=args.bidirectional,
)
if args.model == "r2plus1d":
model = R2Plus1D(num_classes=train_dataset.num_classes, )
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
# optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate)
optimizer = torch.optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=0.9,
weight_decay=5e-4)
lr_scheduler = torch.optim.lr_scheduler.StepLR(
optimizer,