"Rumo ao alinhamento de face densa 3D rápido, preciso e estável" Estudo de artigo 3DDFA-V2 e implementação de engenharia

1: As 4 partes principais do artigo

1: Usando uma rede leve, o modelo de treinamento regride 62 parâmetros 3DMM.
a saída padrão é dimensão com comprimento 62 = 12 (pose) + 40 (forma) +10 (expressão)
O projeto anunciou três modelos: mb05_120x120, mb05_120x120, resnet_120x120 (mobilenet 0.5, mobilenet 1.0, resnet 1.0)
2: Otimização meta-junta proposta Estratégia de Otimização.
Ou seja, combinar dinamicamente as funções de perda fwpdc e vdc para acelerar o ajuste.
Ou seja, um conjunto de métodos de meta-aprendizado é usado para ajustar dinamicamente os pesos de fwpdc e vdc.
A operação específica é:
usar vdc para ajustar o modelo treinado pela função de perda wpdc (ou usar wpdc para ajustar vdc). Ou seja, primeiro use a função de perda wpdc acima para treinar o modelo; salve os parâmetros do modelo; ao reiniciar este treinamento, inicialize os parâmetros do modelo de rede neural com os parâmetros do modelo recém-treinado com wpdc e depois continue para usar a função de perda vdc para treinar o modelo, conforme mostrado abaixo.


(1) O parâmetro Vertex Distance Cost (Vdc)

aqui são os 62 parâmetros 3DMM da regressão do modelo (12(pose) + 40(shape) +10(expression)).
V3d aqui significa usar 62 parâmetros 3DMM para calcular pontos no modelo de cabeça 3DMM.
O código é implementado como:

pts3d = R @ (self.u_base + self.w_shp_base @ alpha_shp + self.w_exp_base @ alpha_exp). \
                    reshape(3, -1, order='F') + offset

Há uma matriz 3X4 contendo coeficientes de pose. A última matriz 3X1 representa informações de deslocamento.

offset = R_[:, -1].reshape(3, 1)

Molde de cabeça básico.
Usando os parâmetros previstos pelo modelo, calcule o ponto facial 3D P_pre e, em seguida, use os pontos 3D com o mesmo ponto de índice no modelo principal (esses dados foram previamente armazenados no arquivo PKL) para fazer a perda do paradigma L2.
(2) Fwpdc

calcula a perda de distância entre os parâmetros 3DMM regredidos e os parâmetros 3DMM reais no peso fixo.
3: Regularização de regressão de rótulo de recurso:
Adicione uma ramificação de regressão para retornar 68 pontos 2D após a camada de pooling global.
4: Síntese de vídeo curta (não preste atenção)

2: Use o projeto de papel para executar o conjunto de dados de pontos 3D da face

Endereço oficial do projeto: https://github.com/cleardusk/3DDFA_V2

O projeto não divulgou o código de treinamento, apenas a demonstração de teste. Você pode usar o projeto como uma ferramenta de execução de dados para gerar pontos faciais 3D, e o efeito não é ruim.
1: Use diretamente os dados de demonstração publicados no artigo:

o formato do rosto da mesma pessoa em ângulos diferentes é diferente na visão 2D. Este fenômeno é normal. A visão 2D não combina informações de profundidade, portanto haverá diferenças visuais.No entanto, não importa como a perspectiva mude para a mesma pessoa, a relação entre quaisquer dois pontos 3D no espaço 3D permanece inalterada. Por exemplo, na figura abaixo, os comprimentos dos módulos do vetor BA e do vetor BC permanecem inalterados e o ângulo entre eles também permanece inalterado.
Portanto, é normal que um rosto gordo pareça menor quando visto de cima.2

: Endireite o rosto de todos os ângulos .
Ou seja, o coeficiente de pose no modelo da cabeça é removido e o formato do rosto pode ser comparado intuitivamente.
Altere os coeficientes previstos pela matriz pose 3*3 para a matriz identidade inicializada.
O código precisa ser atualizado:

def recon_vers(self, param_lst, roi_box_lst, **kvs):
        dense_flag = kvs.get('dense_flag', False)
        size = self.size

        ver_lst = []
        inp_lst=[]
        for param, roi_box in zip(param_lst, roi_box_lst):
            R, offset, alpha_shp, alpha_exp = _parse_param(param)
            if dense_flag:
                inp_dct = {
    
    
                    'R': R, 'offset': offset, 'alpha_shp': alpha_shp, 'alpha_exp': alpha_exp
                }
                pts3d = self.bfm_session.run(None, inp_dct)[0]

                pts3d = similar_transform(pts3d, roi_box, size)
            else:
                a = [-(self.param_std[0] + self.param_mean[0]),0,0]
                b = [0,self.param_std[5] + self.param_mean[5],0]
                c = [0,0,-(self.param_std[10] + self.param_mean[10])]
               
                R2 = []
                R2.append(a)
                R2.append(b)
                R2.append(c)
                
                R2=np.array(R2)

                #d=np.array([self.param_std[3] + self.param_mean[3],self.param_std[7] + self.param_mean[7],self.param_std[11] + self.param_mean[11]])
                d=np.array([0,0,self.param_std[11] + self.param_mean[11]])
                #d=np.array([self.param_std[3] + self.param_mean[3],self.param_std[7] + self.param_mean[7],0])
                d=d.reshape(3, 1)

                pts3d = R @ (self.u_base + self.w_shp_base @ alpha_shp + self.w_exp_base @ alpha_exp). \
                    reshape(3, -1, order='F') + offset
                
                pts3d_front = R2 @(self.u_base + self.w_shp_base @ alpha_shp + self.w_exp_base @ alpha_exp). \
                    reshape(3, -1, order='F')+ d

               
                pts3d = similar_transform(pts3d, roi_box, size)
                pts3d_front = similar_transform(pts3d_front, roi_box, size)

            ver_lst.append(pts3d)
            inp_lst.append(pts3d_front)


        return ver_lst,inp_lst

Efeito: