def main():
from model.transform import get_train_transforms, get_valid_transforms
from model.dataloader import prepare_dataloader
from model.model import FlowerImgClassifier
from model.epoch_api import train_one_epoch, valid_one_epoch
from model.utils import seed_everything
logger.debug(CFG)
train = load_train_df("./data/train/")
seed_everything(CFG['seed'])
folds = StratifiedKFold(n_splits=CFG['fold_num'], shuffle=True, random_state=CFG['seed']).split(np.arange(train.shape[0]), train.label.values)
for fold, (trn_idx, val_idx) in enumerate(folds):
# debug
if fold > 0 and options.debug:
break
logger.debug(f'Training with fold {fold} started (train:{len(trn_idx)}, val:{len(val_idx)})')
train_loader, val_loader = prepare_dataloader(train, (CFG["img_size_h"], CFG["img_size_w"]), trn_idx, val_idx, data_root='./data/train', train_bs=CFG["train_bs"], valid_bs=CFG["valid_bs"], num_workers=CFG["num_workers"], transform_way=CFG["transform_way"])
device = torch.device(CFG['device'])
model = FlowerImgClassifier(CFG['model_arch'], train.label.nunique(), pretrained=True).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=CFG['lr'], weight_decay=CFG['weight_decay'])
#scheduler = torch.optim.lr_scheduler.StepLR(optimizer, gamma=0.1, step_size=CFG['epochs']-1)
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=CFG['T_0'], T_mult=1, eta_min=CFG['min_lr'], last_epoch=-1)
#scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer=optimizer, pct_start=0.1, div_factor=25,
# max_lr=CFG['lr'], epochs=CFG['epochs'], steps_per_epoch=len(train_loader))
loss_tr = nn.CrossEntropyLoss().to(device) #MyCrossEntropyLoss().to(device)
loss_fn = nn.CrossEntropyLoss().to(device)
patience = CFG['patience']
min_epoch = CFG['min_epoch']
early_stopping = EarlyStopping(patience=patience, verbose=True)
for epoch in range(CFG['epochs']):
train_one_epoch(epoch, model, loss_tr, optimizer, train_loader, device, CFG['verbose_step'],scheduler=scheduler, schd_batch_update=False)
with torch.no_grad():
loss_val, accuracy_val = valid_one_epoch(epoch, model, loss_fn, val_loader, device, CFG['verbose_step'], scheduler=None, schd_loss_update=False)
logger.debug(f'epoch : {epoch}, loss_val : {loss_val:.4f}, accuracy_val = {accuracy_val:.4f}')
torch.save(model.state_dict(),f'save/all_{config_filename}_{CFG["model_arch"]}_fold_{fold}_{epoch}')
# early stopping
if epoch > min_epoch:
early_stopping(loss_val)
if early_stopping.early_stop:
print("Early stopping")
logger.debug(f'Finished epoch : {epoch}, patience : {patience}')
break
del model, optimizer, train_loader, val_loader, scheduler
torch.cuda.empty_cache()
logger.debug("\n")
elif target_dataset == "ImageNet":
# TODO(write code to load DataSet for ImageNet)
print("TODO(load DataSet for ImageNet)")
else:
raise ValueError(
"Now you can use only 'CIFER-10' for training. "
"Please specify valid DataSet {'CIFER-10'} or "
"write build_model method in ResidualAttentionModel class by yourself."
)
print("build graph...")
model = ResidualAttentionModel()
model(target=target_dataset)
early_stopping = EarlyStopping(limit=30)
x = tf.placeholder(tf.float32, [None, 32, 32, 3])
t = tf.placeholder(tf.float32, [None, 10])
y = model.f_prop(x)
loss = tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=t)
# self.cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train = tf.train.AdamOptimizer(1e-4).minimize(tf.reduce_mean(loss))
valid = tf.argmax(y, 1)
print("check shape of data...")
print("train_X: {shape}".format(shape=train_X.shape))
print("train_y: {shape}".format(shape=train_y.shape))
print(os.path.join(plot_dir, '{}.png'.format(name)))
plt.savefig(os.path.join(plot_dir, '{}.png'.format(name)),
bbox_inches='tight')
if __name__ == "__main__":
print("start to train ResidualAttentionModel")
print('tensorflow_version', tf.__version__)
print('keras version', keras.__version__)
num = 5
train_X, train_y_class, train_y_seg, valid_X, valid_y_class, valid_y_seg, test_X, test_y, test_class_y = utils.load_data_new_dcm_128(
num)
print("build graph...")
model = ResidualAttentionNetwork()
early_stopping = EarlyStopping(limit=20)
x = tf.placeholder(tf.float32, [None, 128, 128, 1], name='x')
# t_seg = tf.placeholder(tf.float32, [None, 128, 128, 2])
t_class = tf.placeholder(tf.float32, [None, 2])
# lr = tf.Variable(0.01, dtype=tf.float32)
is_training = tf.placeholder(tf.bool, shape=())
y_class = model.f_prop(x)
# loss = tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=t)
# 交叉熵
# loss_class = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_class, labels=t_class))
# loss_seg = tf.reduce_mean(-tf.reduce_sum(t_seg * tf.log(y_seg + 1e-7), reduction_indices=[1]))
loss_class = tf.reduce_mean(-tf.reduce_sum(
if __name__ == "__main__":
print("start to train ResidualAttentionModel")
X_train, Y_train, X_test, Y_test = loadData(9)
# 将label变为向量
ty = np_utils.to_categorical(Y_train, 2)
ey = np_utils.to_categorical(Y_test, 2)
print(ty.shape)
print(ey.shape)
print("build graph...")
model = ResidualAttentionNetwork()
early_stopping = EarlyStopping(limit=1)
x = tf.placeholder(tf.float32, [None, hp.PATCH_H, hp.PATCH_W, hp.CHANNEL])
y = tf.placeholder(tf.float32, [None, hp.NUM_CLASSES])
is_training = tf.placeholder(tf.bool, shape=())
output = model.attention_92(x)
# loss
with tf.name_scope('loss'):
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=output,labels=y))
tf.summary.scalar('loss', loss)
# optimizer
with tf.name_scope('optimizer'):
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4)
train = optimizer.minimize(loss)