Python myNet示例

示例#1

文件： four_test_fig.py 项目： DreamBlack/APCNet

def get_result_for_myNet(incomplete,image,netpath):
    net = myNet(3, 128, 128, MLP_dimsG, FC_dimsG, grid_dims, Folding1_dims, Folding2_dims, Weight1_dims,
                Weight3_dims, folding=opt.folding_decoder, attention=opt.attention_encoder,
                pointnetplus=opt.pointnetplus_encoder)
    net = torch.nn.DataParallel(net)
    net.to(device)
    net.load_state_dict(torch.load(netpath, map_location=lambda storage, location: storage)['state_dict'],
                        strict=False)
    net.eval()
    fake = net(incomplete, image)
    return fake.cuda().data.cpu().squeeze(0).numpy()

示例#2

grid_dims = (16, 16)  # defaul 45
Folding1_dims = (514, 512, 512, 3)  # for foldingnet
Folding2_dims = (515, 512, 512, 3)  # for foldingnet
Weight1_dims = (16 * 16 + 512, 512, 512, 128
                )  # for weight matrix estimation 45x45+512 = 2537
Weight3_dims = (512 + 128, 1024, 1024, 256)
knn = 48
sigma = 0.008
mynet = myNet(3,
              128,
              128,
              MLP_dimsG,
              FC_dimsG,
              grid_dims,
              Folding1_dims,
              Folding2_dims,
              Weight1_dims,
              Weight3_dims,
              folding=opt.folding_decoder,
              attention=opt.attention_encoder,
              pointnetplus=opt.pointnetplus_encoder)
mynet = torch.nn.DataParallel(mynet)
mynet.to(device)
mynet.load_state_dict(torch.load(
    opt.netG, map_location=lambda storage, location: storage)['state_dict'],
                      strict=False)
mynet.eval()

criterion_PointLoss = PointLoss_test().to(device)

示例#3

文件： train_completion_net.py 项目： DreamBlack/APCNet

    elif classname.find("BatchNorm1d") != -1:
        torch.nn.init.normal_(m.weight.data, 1.0, 0.02)
        torch.nn.init.constant_(m.bias.data, 0.0)


MLP_dims = (3, 64, 64, 64, 128, 1024)
FC_dims = (1024, 1024, 512)
grid_dims = (16, 16)  # defaul 45
Folding1_dims = (514, 512, 512, 3)  # for foldingnet
Folding2_dims = (515, 512, 512, 3)  # for foldingnet
Weight1_dims = (16 * 16 + 512, 512, 512, 128
                )  # for weight matrix estimation 45x45+512 = 2537
Weight3_dims = (512 + 128, 1024, 1024, 256)
knn = 48
sigma = 0.008
mynet = myNet(3, 128, 128, MLP_dims, FC_dims, grid_dims, Folding1_dims,
              Folding2_dims, Weight1_dims, Weight3_dims)

print("Let's use", torch.cuda.device_count(), "GPUs!")
mynet = torch.nn.DataParallel(mynet)
mynet.to(device)
mynet.apply(weights_init_normal)

if opt.netG != '':
    mynet.load_state_dict(
        torch.load(
            opt.netG,
            map_location=lambda storage, location: storage)['state_dict'])
    resume_epoch = torch.load(opt.netG)['epoch']

if opt.manualSeed is None:
    opt.manualSeed = random.randint(1, 10000)

示例#4

文件： train_with_D.py 项目： DreamBlack/APCNet

    elif classname.find("BatchNorm1d") != -1:
        torch.nn.init.normal_(m.weight.data, 1.0, 0.02)
        torch.nn.init.constant_(m.bias.data, 0.0)

MLP_dimsG = (3, 64, 64, 64, 128, 1024)
FC_dimsG = (1024, 1024, 512)
MLP_dimsD = (3, 64, 64, 64, 128, 1024)
FC_dimsD = (1024, 1024, 512)
grid_dims = (16, 16)  # defaul 45
Folding1_dims = (514, 512, 512, 3)  # for foldingnet
Folding2_dims = (515, 512, 512, 3)  # for foldingnet
Weight1_dims = (16 * 16 + 512, 512, 512, 128)  # for weight matrix estimation 45x45+512 = 2537
Weight3_dims = (512 + 128, 1024, 1024, 256)
knn = 48
sigma = 0.008
myNet = myNet(3, 128, 128, MLP_dimsG, FC_dimsG, grid_dims, Folding1_dims, Folding2_dims, Weight1_dims, Weight3_dims,folding=opt.fc_decoder)
myNetD=myDiscriminator(256,MLP_dimsD,FC_dimsD)

print("Let's use", torch.cuda.device_count(), "GPUs!")
myNet = torch.nn.DataParallel(myNet)
myNet.to(device)
myNet.apply(weights_init_normal)
myNetD = torch.nn.DataParallel(myNetD)
myNetD.to(device)
myNetD.apply(weights_init_normal)

if opt.netG != '' :
    myNet.load_state_dict(torch.load(opt.netG, map_location=lambda storage, location: storage)['state_dict'])
    resume_epoch = torch.load(opt.netG)['epoch']
if opt.netD != '' :
    myNetD.load_state_dict(torch.load(opt.netD,map_location=lambda storage, location: storage)['state_dict'])

示例#5

grid_dims = (16, 16)  # defaul 45
Folding1_dims = (514, 512, 512, 3)  # for foldingnet
Folding2_dims = (515, 512, 512, 3)  # for foldingnet
Weight1_dims = (16 * 16 + 512, 512, 512, 128
                )  # for weight matrix estimation 45x45+512 = 2537
Weight3_dims = (512 + 128, 1024, 1024, 256)
knn = 48
sigma = 0.008
myNet = myNet(3,
              128,
              128,
              MLP_dimsG,
              FC_dimsG,
              grid_dims,
              Folding1_dims,
              Folding2_dims,
              Weight1_dims,
              Weight3_dims,
              dropout=opt.drop,
              folding=opt.folding_decoder,
              dropout_feature=opt.dropout_feature,
              attention=opt.attention_encoder,
              pointnetplus=opt.pointnetplus_encoder)
myNetD = myDiscriminator(256, MLP_dimsD, FC_dimsD)

print("Let's use", torch.cuda.device_count(), "GPUs!")
myNet = torch.nn.DataParallel(myNet)
myNet.to(device)
myNet.apply(weights_init_normal)
myNetD = torch.nn.DataParallel(myNetD)
myNetD.to(device)