예제 #1
0
def load_model(path, epoch, pretrain):
    pool = util.DataPool()
    x_dim, y_dim, timestamp = parse_params(path)
    xs = util.Gaussian_sampler(mean=np.zeros(x_dim), sd=1.0)
    ys = find_y_sampler()

    if data == 'mnist' or data == 'cifar10':
        from main_density_est_img import RoundtripModel
        g_net = model.Generator_img(input_dim=x_dim,
                                    output_dim=y_dim,
                                    name='g_net',
                                    nb_layers=2,
                                    nb_units=256,
                                    dataset=data,
                                    is_training=False)
        h_net = model.Encoder_img(input_dim=y_dim,
                                  output_dim=x_dim,
                                  name='h_net',
                                  nb_layers=2,
                                  nb_units=256,
                                  dataset=data)
        dx_net = model.Discriminator(input_dim=x_dim,
                                     name='dx_net',
                                     nb_layers=2,
                                     nb_units=128)
        dy_net = model.Discriminator_img(input_dim=y_dim,
                                         name='dy_net',
                                         nb_layers=2,
                                         nb_units=128,
                                         dataset=data)
        RTM = RoundtripModel(g_net,
                             h_net,
                             dx_net,
                             dy_net,
                             xs,
                             ys,
                             data,
                             pool,
                             batch_size=64,
                             nb_classes=10,
                             alpha=10.0,
                             beta=10.0,
                             df=1,
                             is_train=False)
    else:
        from main_density_est import RoundtripModel
        g_net = model.Generator(input_dim=x_dim,
                                output_dim=y_dim,
                                name='g_net',
                                nb_layers=10,
                                nb_units=512)
        h_net = model.Generator(input_dim=y_dim,
                                output_dim=x_dim,
                                name='h_net',
                                nb_layers=10,
                                nb_units=256)
        dx_net = model.Discriminator(input_dim=x_dim,
                                     name='dx_net',
                                     nb_layers=2,
                                     nb_units=128)
        dy_net = model.Discriminator(input_dim=y_dim,
                                     name='dy_net',
                                     nb_layers=4,
                                     nb_units=256)
        RTM = RoundtripModel(g_net,
                             h_net,
                             dx_net,
                             dy_net,
                             xs,
                             ys,
                             data,
                             pool,
                             batch_size=64,
                             alpha=10.0,
                             beta=10.0,
                             df=1,
                             is_train=False)
    RTM.load(pre_trained=pretrain, timestamp=timestamp, epoch=epoch)
    return RTM
예제 #2
0
                           nb_units=256)

    dx_net = model.Discriminator(input_dim=x_dim,
                                 name='dx_net',
                                 nb_layers=4,
                                 nb_units=256)

    dy_net1 = model.Discriminator(input_dim=y_dim1,
                                  name='dy_net1',
                                  nb_layers=4,
                                  nb_units=256)
    dy_net2 = model.Discriminator(input_dim=y_dim2,
                                  name='dy_net2',
                                  nb_layers=4,
                                  nb_units=256)
    pool = util.DataPool()

    #xs = util.Mixture_sampler_v2(nb_classes=nb_classes,N=10000,dim=x_dim,sd=1)
    xs = util.Mixture_sampler(nb_classes=nb_classes, N=10000, dim=x_dim, sd=1)
    #ys = util.DataSampler() #scRNA-seq data
    #ys = util.RA4_Sampler('scrna')
    ys = util.RA4CoupleSampler()
    #ys = util.scATAC_Sampler()
    #ys = util.GMM_sampler(N=10000,n_components=nb_classes,dim=y_dim,sd=8)

    CRTM = CoupleRTM(g_net1, g_net2, h_net1, h_net2, dx_net, dy_net1, dy_net2,
                     xs, ys, nb_classes, data, pool, batch_size, alpha, beta,
                     gamma, is_train)

    if args.train:
        CRTM.train(epochs=epochs, patience=patience)