text stringlengths 1 93.6k |
|---|
b3 = torch.cross(b1, b2, dim=1)
|
return torch.stack([b1, b2, b3], dim=-1)
|
class ReverseLayerF(Function):
|
@staticmethod
|
def forward(ctx, x, alpha):
|
ctx.alpha = alpha
|
return x.view_as(x)
|
@staticmethod
|
def backward(ctx, grad_output):
|
output = grad_output.neg() * ctx.alpha
|
return output, None
|
class OptDE(object):
|
def __init__(self, args):
|
args.vp_mode = 'angle'
|
self.args = args
|
if self.args.dist:
|
self.rank = dist.get_rank()
|
self.world_size = dist.get_world_size()
|
else:
|
self.rank, self.world_size = 0, 1
|
# init seed for static masks: ball_hole, knn_hole, voxel_mask
|
self.to_reset_mask = True
|
self.mask_type = self.args.mask_type
|
self.update_G_stages = self.args.update_G_stages
|
self.iterations = self.args.iterations
|
self.args.G_lrs = [2e-4]
|
self.G_lrs = self.args.G_lrs
|
self.z_lrs = self.args.z_lrs
|
self.select_num = self.args.select_num
|
self.loss_log = []
|
# create model
|
self.Encoder = Encoder().cuda()
|
#args.DEGREE = [1, 2, 4, 4, 64]
|
#args.G_FEAT = [1024, 96, 128, 128, 64, 3]
|
#args.G_FEAT[0] = 1024
|
args.G_FEAT[0] = 288
|
self.Decoder = Generator(features=args.G_FEAT, degrees=args.DEGREE, support=args.support,args=self.args).cuda()#Decoder().cuda()
|
self.DI_Disentangler = Disentangler(f_dims=96).cuda()
|
self.MS_Disentangler = Disentangler(f_dims=96).cuda()
|
self.DS_Disentangler = Disentangler(f_dims=96).cuda()
|
#self.Z_Mapper = Z_Mapper(f_dims=84).cuda()
|
self.DI_Classifier = Classifier(f_dims=96).cuda()
|
self.DS_Classifier = Classifier(f_dims=96).cuda()
|
if self.args.vp_mode == 'matrix':
|
self.V_Predictor = ViewPredictor(f_dims=96, out_dims=6).cuda()
|
self.rotmatdecoder = RotMatDecoder()
|
elif self.args.vp_mode == 'angle':
|
self.V_Predictor = ViewPredictor(f_dims=96).cuda()
|
else:
|
raise NotImplementedError
|
self.D = Discriminator(features=args.D_FEAT).cuda()
|
#self.models = {"Encoder": self.Encoder, "Decoder": self.Decoder, "DI": self.DI_Disentangler, "DS": self.DS_Disentangler, "Mapper": self.Z_Mapper, "DIC": self.DI_Classifier, "DSC": self.DS_Classifier, "D": self.D}
|
self.models = {"Encoder": self.Encoder, "Decoder": self.Decoder, "DI": self.DI_Disentangler, "DS": self.DS_Disentangler, "MS": self.MS_Disentangler, "DIC": self.DI_Classifier, "DSC": self.DS_Classifier, "VP":self.V_Predictor, "D": self.D}
|
###Obtain trainable parameters
|
for model_name in ["Encoder", "Decoder", "DI", "DS", "MS", "DIC", "DSC", "VP"]:
|
trainable_params_tmp = self.models[model_name].parameters()
|
self.models[model_name].optim = torch.optim.Adam(
|
trainable_params_tmp,
|
lr=self.G_lrs[0],
|
betas=(0,0.99),
|
weight_decay=0,
|
eps=1e-8)
|
self.z = torch.zeros((1, 288)).normal_().cuda()
|
self.z = Variable(self.z, requires_grad=True)
|
self.z_optim = torch.optim.Adam([self.z], lr=self.args.z_lrs[0], betas=(0,0.99))
|
# load weights
|
checkpoint = torch.load(args.ckpt_load, map_location=self.args.device)
|
self.D.load_state_dict(checkpoint['D_state_dict'])
|
for model_name in ["Encoder", "Decoder", "DI", "DS", "MS", "DIC", "DSC", "VP"]:
|
self.models[model_name].eval()
|
if self.D is not None:
|
self.D.eval()
|
# prepare latent variable and optimizer
|
self.schedulers = dict()
|
for model_name in ["Encoder", "Decoder", "DI", "DS", "MS", "DIC", "DSC", "VP"]:
|
self.schedulers[model_name] = LRScheduler(self.models[model_name].optim, self.args.warm_up)
|
self.z_scheduler = LRScheduler(self.z_optim, self.args.warm_up)
|
# loss functions
|
self.ftr_net = self.D
|
self.criterion = DiscriminatorLoss()
|
self.di_criterion = nn.CrossEntropyLoss()
|
self.ds_criterion = nn.CrossEntropyLoss()
|
self.vp_criterion = nn.MSELoss()
|
self.consistency_criterion = nn.MSELoss()
|
self.directed_hausdorff = DirectedHausdorff()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.