示例#1
0
def train(**kwargs):
    # train model
    opt.parse(kwargs)

    batch_size, validationRatio = opt.batch_size, opt.validationRatio
    LR, epoch, global_seed = opt.LR, opt.epoch, opt.global_seed
    vis.vis.env = opt.env

    fixSeed(opt.global_seed)

    min_loss = 10

    model = models.SimpleNet()
    for i in range(epoch):
        print("Ensamble number:" + str(i))
        #model = models.ResNetLike(BasicBlock, [1, 3, 3, 1], num_channels=2, num_classes=1)
        data, full_img = readSuffleData(opt.global_seed, opt.BASE_FOLDER)
        train_loader, val_loader, train_ds, val_ds = getTrainValLoaders(
            data, full_img, batch_size, num_workers, validationRatio)
        #train_loader, val_loader, train_ds, val_ds = getCustomTrainValLoaders(data,full_img,batch_size,num_workers,validationRatio,global_seed)

        model, val_result, train_result = generateSingleModel(
            model, train_loader, val_loader, train_ds, val_ds, LR,
            opt.global_epoches)
        # if min_loss<val_result:
        # 	LR = LR * 0.5
        # else:
        # 	min_loss = val_result

        vis.plot('val_loss', val_result)
        vis.plot("train_loss", train_result)
        #print (model)
    df_pred = testModel(model)
    savePred(df_pred, val_result)
示例#2
0
def get_feature_model(model_string, experiment_name, load_pretrained=False, opti=None, lr=None, mom=None,
                      checkpoint_pretrained=None,
                      learn_pos=False, force_on_cpu=False,cat=False):
    print('Loading feature model: {}, expname {}, pretrained? {}, checkpoint pretrained {}, learn pos? {} , cat? {}'.format(model_string, experiment_name,load_pretrained,checkpoint_pretrained,learn_pos,cat),flush=True)
    if model_string == 'vgg':
        vgg = models.vgg16(pretrained=False)
        vgg.load_state_dict(torch.load('/mnt/synology/breast/projects/lisa/koel/vgg16-397923af.pth'))
        model = m.ModifiedVGG(vgg, learn_pos=learn_pos)
    elif model_string == 'simple':
        model = m.SimpleNet(learn_pos=learn_pos, cat=cat)
    elif model_string == 'resnet' or model_string == 'resnet_pool':
        if learn_pos:
            num_classes = 3
        elif cat:
            num_classes=5
        else:
            num_classes = 1
        model = res.get_resnet_classification(pretrained=True, num_classes=num_classes)
#         resnet = models.resnet18(pretrained=True)
#         model = m.ModifiedResNet(resnet, learn_pos=learn_pos)
    elif model_string == 'resnet_less':
        model = m.ModiefiedResNetLessFilter(learn_pos=learn_pos)                                
    elif model_string == 'fcresnet':
        if learn_pos:
            raise ValueError('Position learning not implemented for Fully Convolutional NN')
        resnet = models.resnet18(pretrained=True)
        normal_model = m.ModifiedResNet(resnet)
        if load_pretrained:
            normal_model = m.FCResNet(normal_model)

        optimizer = get_optimizer(normal_model.parameters(), opti, lr, mom)

        checkpoint_filename = os.path.join(checkpoint_pretrained, 'warmup_model_{}.pth.tar'.format(experiment_name))
        if os.path.exists(checkpoint_filename):
            model, _, initial_epoch = load_checkpoint(normal_model, optimizer, filename=checkpoint_filename)
        else:
            raise ValueError('Checkpoint {} does not exist.'.format(os.path.abspath(checkpoint_filename)))
        if load_pretrained:
            model = m.FCResNet(model)
    elif model_string == 'auto':
        model = res.get_resnet_auto(given_model=None)

    if load_pretrained and not ( model_string == 'fcresnet' or model_string =='resnet_pool'):
        optimizer = get_optimizer(model.parameters(), opti, lr, mom)

        checkpoint_filename = os.path.join(checkpoint_pretrained, 'warmup_model_{}.pth.tar'.format(experiment_name))
        if os.path.exists(checkpoint_filename):
            model, _, _ = load_checkpoint(model, optimizer, filename=checkpoint_filename)
        else:
            raise ValueError('Checkpoint {} does not exist.'.format(checkpoint_filename))
    elif load_pretrained and model_string == 'resnet_pool':
        optimizer = get_optimizer(model.parameters(), opti, lr, mom)

        checkpoint_filename = os.path.join(checkpoint_pretrained, 'warmup_model_resnet.pth.tar')
        if os.path.exists(checkpoint_filename):
            model, _, _ = load_checkpoint(model, optimizer, filename=checkpoint_filename)
        else:
            raise ValueError('Checkpoint {} does not exist.'.format(checkpoint_filename))
    if torch.cuda.is_available() and not force_on_cpu:
        print('Got model with cuda available', flush=True)
        model.cuda()
    return model
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('env', type=str)
    parser.add_argument('--num_rollouts',
                        type=int,
                        default=20,
                        help='Number of expert roll outs')
    parser.add_argument('--epochs',
                        type=int,
                        default=20,
                        help='Number of epochs to train')
    parser.add_argument('--max_batches',
                        type=int,
                        default=10000,
                        help='Max number of batches to train')
    args = parser.parse_args()

    print('training immitation...')

    data_path = os.path.join('data', args.env)
    file_name = 'train_{}.p'.format(args.num_rollouts)
    with open(os.path.join(data_path, file_name), 'rb') as f:
        expert_data = pickle.load(f)

    X = expert_data['observations']
    Y = expert_data['actions']
    assert len(Y.shape) == 2
    print('number of training data:', len(X))

    # for debug purpose
    # TODO: ask Alex about selu at output?
    env = gym.make(args.env)
    obs_shape = list(env.observation_space.shape)
    act_shape = list(env.action_space.shape)
    print(env.action_space.low, env.action_space.high)

    obs_ph = tf.placeholder(tf.float32,
                            shape=[None] + obs_shape,
                            name='obs_ph')
    act_ph = tf.placeholder(tf.float32,
                            shape=[None] + act_shape,
                            name='act_ph')
    net = models.SimpleNet()
    act_out, loss, train_step = net.CreateGraph(obs_ph, act_ph)
    tf.summary.scalar('losses/total_loss', loss)

    batch_size = 100
    batch_index = 0
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        tf_board = os.path.join('/tmp/gube/imitation', args.env)
        # [print(f) for f in glob.glob(os.path.join(tf_board, '*'))]
        # [os.remove(f) for f in glob.glob(os.path.join(tf_board, '*'))]
        writer = tf.summary.FileWriter(
            os.path.join(tf_board, str(int(time.time()))))
        writer.add_graph(sess.graph)
        merged_summary = tf.summary.merge_all()

        for i in range(args.epochs):
            x, y = shuffle(X, Y)
            print('Epoch {}'.format(i + 1))
            offset = 0
            while offset + batch_size <= len(x):
                start, end = offset, offset + batch_size
                sess.run(train_step,
                         feed_dict={
                             obs_ph: x[start:end],
                             act_ph: y[start:end]
                         })
                offset = end
                batch_index += 1
                if batch_index >= args.max_batches:
                    break

            s = sess.run(merged_summary, feed_dict={obs_ph: x, act_ph: y})
            writer.add_summary(s, batch_index)
            print('Batch {}'.format(batch_index))
            if batch_index >= args.max_batches:
                break

        saver = tf.train.Saver()
        saver.save(sess, os.path.join('policy/imitation', args.env, args.env))
示例#4
0

use_cuda=True if torch.cuda.is_available() else False
device=torch.device('cuda:0') if use_cuda else torch.device('cpu')


classifier = models.ClassifierPro()
classifier2 = models.ClassifierPro()
#encoder = models.Encoder()
encoder = tmodels.resnet50(pretrained=True)
#encoder = tmodels.inception_v3(pretrained=True)
#encoder.aux_logits=False
encoder.fc = nn.Sequential()
discriminator = models.DCDPro()
#discriminator = models.DCDPro(input_features=128)
ssnet = models.SimpleNet(2048, 64)

classifier.to(device)
encoder.to(device)
#classifier2.to(device)
#encoder2.to(device)
discriminator.to(device)
ssnet.to(device)

loss_fn=torch.nn.CrossEntropyLoss()
loss_fn2 = ContrastiveLoss()  ##quitar
loss_fn3 = SpecLoss()  ##quitar
# -----------------------------------------------------------------------------
## etapa 1: entrenar g y h
print("||||| Stage 1 |||||")
optimizer=torch.optim.Adam(list(encoder.parameters())+list(classifier.parameters()), lr = 0.0001)
示例#5
0
#datadir = '/home/villacis/Desktop/a4-code-v2-updated/minidigits'
datadir = '/home/villacis/Desktop/villacis/datasets/plantclef_superminida_17_20_split'
#datadir = '/home/villacis/Desktop/villacis/datasets/plantclef_minida_cropped'

num_epochs1 = 40
num_epochs2 = 100
num_epochs3 = 2500000

use_cuda = True if torch.cuda.is_available() else False
device = torch.device('cuda:0') if use_cuda else torch.device('cpu')

classifier = models.ClassifierPro()
#encoder = models.Encoder()
encoder = tmodels.resnet18(pretrained=True)
num_ftrs = encoder.fc.in_features
ssnet = models.SimpleNet(num_ftrs, 4)
#encoder = tmodels.inception_v3(pretrained=True)
#encoder.aux_logits=False
encoder.fc = nn.Sequential()
discriminator = models.DCDPro()
#discriminator = models.DCDPro(input_features=128)

classifier.to(device)
encoder.to(device)
discriminator.to(device)
ssnet = ssnet.to(device)

loss_fn = torch.nn.CrossEntropyLoss()
loss_fn2 = ContrastiveLoss()  ##quitar
loss_fn3 = SpecLoss()  ##quitar
# -----------------------------------------------------------------------------
示例#6
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('env', type=str)
    parser.add_argument('--num_rollouts',
                        type=int,
                        default=20,
                        help='Number of roll outs')
    parser.add_argument('--max_steps',
                        type=int,
                        default=10000,
                        help='Max number of steps per roll out')
    parser.add_argument('--num_experts',
                        type=int,
                        default=1,
                        help='Number of expert roll outs')
    parser.add_argument('--epochs_per_rollout',
                        type=int,
                        default=5,
                        help='Number of epochs to train for every roll out')
    parser.add_argument('--max_batches',
                        type=int,
                        default=10000,
                        help='Max number of batches to train')
    args = parser.parse_args()

    print('training DAgger...')

    # set up
    env = gym.make(args.env)
    obs_shape = list(env.observation_space.shape)
    act_shape = list(env.action_space.shape)
    assert len(act_shape) == 1
    print(env.action_space.low, env.action_space.high)
    max_steps = args.max_steps or env.spec.timestep_limit
    policy_module = importlib.import_module("policy.expert")
    expert = policy_module.get_policy(args.env)

    obs_ph = tf.placeholder(tf.float32,
                            shape=[None] + obs_shape,
                            name='obs_ph')
    act_ph = tf.placeholder(tf.float32,
                            shape=[None] + act_shape,
                            name='act_ph')
    net = models.SimpleNet()
    act_out, loss, train_step = net.CreateGraph(obs_ph, act_ph)
    tf.summary.scalar('losses/total_loss', loss)

    batch_size = 100
    batch_index = 0
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        tf_board = os.path.join('/tmp/gube/dagger', args.env)
        # [os.remove(f) for f in glob.glob(os.path.join(tf_board, '*'))]
        writer = tf.summary.FileWriter(
            os.path.join(tf_board, str(int(time.time()))))
        writer.add_graph(sess.graph)
        merged_summary = tf.summary.merge_all()

        X = np.empty([0] + obs_shape)  # float
        Y = np.empty([0] + act_shape)  # float
        returns = []
        for i in range(args.num_rollouts):
            print('rollout', i)
            obs = env.reset()
            done = False
            totalr = 0.
            steps = 0
            while not done:
                # obs[None, :] = [obs], adding 1 to the shape
                policy_action = sess.run(act_out,
                                         feed_dict={obs_ph: obs[None, :]})[0]
                expert_action = expert.act(obs)
                X = np.vstack((X, obs))
                Y = np.vstack((Y, expert_action))
                if i < args.num_experts:
                    obs, r, done, _ = env.step(expert_action)
                else:
                    obs, r, done, _ = env.step(policy_action)
                totalr += r
                steps += 1
                if steps % 100 == 0: print("%i/%i" % (steps, max_steps))
                if steps >= max_steps:
                    break
            returns.append(totalr)

            for j in range(args.epochs_per_rollout):
                x, y = shuffle(X, Y)
                offset = 0
                while offset + batch_size <= len(x):
                    start, end = offset, offset + batch_size
                    sess.run(train_step,
                             feed_dict={
                                 obs_ph: x[start:end],
                                 act_ph: y[start:end]
                             })
                    offset = end
                    batch_index += 1
                    if batch_index >= args.max_batches:
                        break

            s = sess.run(merged_summary, feed_dict={obs_ph: x, act_ph: y})
            writer.add_summary(s, batch_index)
            if batch_index >= args.max_batches:
                break

            print('batch', batch_index)

        print('returns', returns)
        print('mean return', np.mean(returns))
        print('std of return', np.std(returns))

        saver = tf.train.Saver()
        saver.save(sess, os.path.join('policy/dagger', args.env, args.env))