Пример #1
0
"""
Created on Sat Jun 29 10:06:03 2019

@author: NguyenHoangThuan
"""

from keras.preprocessing.image import *
from prepare_data import *
from loss_and_metrics import *
from model import VGG
from keras.models import *
from keras.callbacks import *
import config as cf
train_x,train_y,val_x,val_y = create_data()

model = VGG(shape=(64, 256, 1))
model.summary()

model.compile(loss = custom_loss,
                  optimizer='adam',
                  metrics=[char_acc,image_acc])

datagen = ImageDataGenerator(width_shift_range=0.14,
                                 height_shift_range=0.08,
                                 fill_mode='constant',
                                 zoom_range = 0.1,
                                 rotation_range = 10,
                                 #rescale  =1./255
                                 )
mcp_save = ModelCheckpoint(cf.CKP_PATH, save_best_only=True, monitor='val_loss', mode='min',verbose=1)
Пример #2
0

if __name__ == "__main__":
    # hyper param
    init_lr = 0.0001
    weight_decay = 0.0005
    Epochs = 1000
    train_dir = r"C:\Users\13249\Desktop\20200115-20200205\Calcification\Data\INBreast\Sample\train"
    valid_dir = r"C:\Users\13249\Desktop\20200115-20200205\Calcification\Data\INBreast\Sample\valid"

    # data_loader
    train_loader = get_data_loader(train_dir, data_augment=True)
    valid_loader = get_data_loader(train_dir, data_augment=False, batch_size=128)

    # model
    net = VGG(1).cuda()

    # define loss function (criterion) and optimizer
    loss_func = FocalLoss().cuda()
    opt = optim.Adam(net.parameters(), init_lr, weight_decay=weight_decay)
    lr_decay = torch.optim.lr_scheduler.StepLR(opt, step_size=5, gamma=0.5)

    # train
    writer = SummaryWriter()
    for epoch in range(0, Epochs + 1):
        net.train()
        losses = []
        for i, (images, target) in enumerate(train_loader):
            images = images.cuda()
            target = target.cuda()
Пример #3
0
                              window_size=args.window_size,
                              window_stride=args.window_stride,
                              window_type=args.window_type,
                              normalize=args.normalize)
test_loader = torch.utils.data.DataLoader(test_dataset,
                                          batch_size=args.test_batch_size,
                                          shuffle=None,
                                          num_workers=20,
                                          pin_memory=args.cuda,
                                          sampler=None)

# build model
if args.arc == 'LeNet':
    model = LeNet()
elif args.arc.startswith('VGG'):
    model = VGG(args.arc)
else:
    model = LeNet()

if args.cuda:
    print('Using CUDA with {0} GPUs'.format(torch.cuda.device_count()))
    model = torch.nn.DataParallel(model, device_ids=[0]).cuda()

# define optimizer
if args.optimizer.lower() == 'adam':
    optimizer = optim.Adam(model.parameters(), lr=args.lr)
elif args.optimizer.lower() == 'sgd':
    optimizer = optim.SGD(model.parameters(),
                          lr=args.lr,
                          momentum=args.momentum)
else: