| |
| |
| |
| |
| """Load only KaoLRM's image-to-FLAME-parameter network, without mesh/render assets.""" |
| import importlib |
| import json |
| from pathlib import Path |
| import sys |
| import types |
|
|
| import numpy as np |
| from safetensors import safe_open |
| import torch |
| from torch import nn |
| from torch.nn import functional as F |
|
|
|
|
| def components(repo): |
| |
| |
| name = '_ellsa2_kaolrm_components' |
| path = str(Path(repo).resolve() / 'kaolrm/models') |
| if name not in sys.modules: |
| package = types.ModuleType(name) |
| package.__path__ = [path] |
| sys.modules[name] = package |
| assert sys.modules[name].__path__ == [path], 'Use one KaoLRM revision per process' |
| return lambda module: importlib.import_module(name + '.' + module) |
|
|
|
|
| class ParameterModel(nn.Module): |
| def __init__(self, repo, checkpoint): |
| super().__init__() |
| |
| torch._dynamo.config.disable = True |
| from accelerate import PartialState |
| PartialState() |
| module = components(repo) |
| cfg = json.loads((Path(checkpoint) / 'config.json').read_text()) |
| assert cfg['encoder_type'] == 'dinov2' and cfg['ortho_proj'], 'Use the KaoLRM mono checkpoint' |
| self.encoder = nn.Module() |
| backbone = getattr(module('encoders.dinov2.hub.backbones'), cfg['encoder_model_name']) |
| |
| self.encoder.model = backbone(pretrained=False) |
| self.camera_embedder = module('embedder').CameraEmbedder(16, cfg['camera_embed_dim']) |
| self.low_res = cfg['triplane_low_res'] |
| self.pos_embed = nn.Parameter(torch.empty(1, 3 * self.low_res**2, cfg['transformer_dim'])) |
| self.transformer = module('transformer').TransformerDecoder( |
| block_type='cond_mod', num_layers=cfg['transformer_layers'], |
| num_heads=cfg['transformer_heads'], inner_dim=cfg['transformer_dim'], |
| cond_dim=cfg['encoder_feat_dim'], mod_dim=cfg['camera_embed_dim']) |
| self.upsampler = nn.ConvTranspose2d(cfg['transformer_dim'], cfg['triplane_dim'], 2, 2) |
| self.flame_decoder = module('flame_decoder').FLAMEDecoder( |
| cfg['triplane_dim'], cfg['triplane_high_res']) |
| with safe_open(Path(checkpoint) / 'model.safetensors', framework='pt', device='cpu') as weights: |
| state = {key: weights.get_tensor(key) for key in weights.keys() |
| if not key.startswith(('flame_model.', 'gaussian_decoder.'))} |
| self.load_state_dict(state, strict=True) |
| self.eval() |
|
|
| def forward(self, image): |
| features = self.encoder.model(image, is_training=True) |
| features = torch.cat([features['x_norm_clstoken'][:, None], features['x_norm_patchtokens']], dim=1) |
| |
| camera = image.new_tensor([[1, 0, 0, 0, 0, 0, -1, -2, 0, 1, 0, 0, .75, .75, .5, .5]]) |
| camera = self.camera_embedder(camera.expand(len(image), -1)) |
| tokens = self.transformer(self.pos_embed.repeat(len(image), 1, 1), cond=features, mod=camera) |
| planes = tokens.view(len(image), 3, self.low_res, self.low_res, -1) |
| planes = planes.permute(1, 0, 4, 2, 3).reshape(3 * len(image), -1, self.low_res, self.low_res) |
| planes = self.upsampler(planes) |
| planes = planes.view(3, len(image), *planes.shape[-3:]).permute(1, 0, 2, 3, 4).contiguous() |
| return self.flame_decoder(planes) |
|
|
| @torch.no_grad() |
| def predict(self, crop): |
| |
| image = torch.from_numpy(np.ascontiguousarray(crop[..., ::-1])).to(self.pos_embed.device) |
| image = image.permute(2, 0, 1)[None] / 255.0 |
| image = F.interpolate(image, (224, 224), mode='bicubic', align_corners=True).clamp(0, 1) |
| output = self(image) |
| return {key: output[key][0].cpu().numpy() for key in ['expression', 'pose', 'shape']} |
|
|
