diff --git a/reconstruction/ostec/README.md b/reconstruction/ostec/README.md
index 33da61e..fcc563f 100644
--- a/reconstruction/ostec/README.md
+++ b/reconstruction/ostec/README.md
@@ -114,6 +114,21 @@ OSTeC
 
 ```
 
+### 4. Download Face Segmentation models
+- Download the Graphonomy model here: https://drive.google.com/file/d/1eUe18HoH05p0yFUd_sN6GXdTj82aW0m9/view?usp=sharing
+(If the link doesn't work for some reason check the original [Graphonomy](https://github.com/Gaoyiminggithub/Graphonomy) github page and download 'CIHP trained model')
+
+- And place it under 'models' directory like the following:
+```
+OSTeC
+│
+└─── models
+     │
+     └─── Graphonomy
+         │
+         └─── inference.pth
+```
+
 <!--- ### 4. Download StyleGANv2 model
 - Download the model from the original repo: https://nvlabs-fi-cdn.nvidia.com/stylegan2/networks/stylegan2-ffhq-config-f.pkl
 And place it under 'models' directory like the following:
@@ -150,6 +165,7 @@ OSTeC
 - Our projection relies on NVIDIA's [StyleGANv2](https://github.com/NVlabs/stylegan2)
 - Thanks [@jiankangdeng](https://jiankangdeng.github.io/) for providing Face Recognition and Landmark Detection models
 - We use [MTCNN](https://github.com/ipazc/mtcnn) for face detection
+- We use [Graphonomy](https://github.com/Gaoyiminggithub/Graphonomy) for face segmentation (i.e. to exclude hairs, occlusion)
 - 3D face reconstruction has been originally solved by [GANFit](https://github.com/barisgecer/GANFit). However, since it is commercialized and will not be public, I had to re-implement the ports for [Deep3DFaceRecon_pytorch](https://github.com/sicxu/Deep3DFaceRecon_pytorch).
 - We initialize StyleGAN parameters by [Style-Encoder](https://github.com/rolux/stylegan2encoder/issues/2) (by [@rolux](https://github.com/rolux), [@pbaylies](https://github.com/pbaylies)).
 - Thanks [Zhang et al.](https://richzhang.github.io/PerceptualSimilarity/) for VGG16 model
diff --git a/reconstruction/ostec/core/config.py b/reconstruction/ostec/core/config.py
index 51172e2..731862f 100644
--- a/reconstruction/ostec/core/config.py
+++ b/reconstruction/ostec/core/config.py
@@ -25,6 +25,7 @@ parser.add_argument('-m', '--mode',default='hard', choices=['soft', 'auto', 'har
                     help='Soft: keep original texture, Hard: generate all, auto: soft for frontal, hard for profile')
 parser.add_argument('-f', '--frontalize', action='store_true', help='Run frontalization at the end')
 parser.add_argument('-p', '--pickle', action='store_true', help='Save pickle with everything')
+parser.add_argument('-g', '--ganfit', action='store_true', help='Reconstruction from GANFit is a must. If not raised, it is automatic: GANFit rec. if pickle found, Deep3DRecon otherwise.')
 parser.add_argument('--iterations_frontalize', default=300, help='Number of optimization steps for each batch', type=int)
 
 parser.add_argument('--load_last', default='', help='Start with embeddings from directory')
diff --git a/reconstruction/ostec/core/operator.py b/reconstruction/ostec/core/operator.py
index 2a5ff59..de5e16d 100644
--- a/reconstruction/ostec/core/operator.py
+++ b/reconstruction/ostec/core/operator.py
@@ -10,6 +10,7 @@ import time
 from utils.ganfit_camera import apply_camera_only3d, get_pose
 from utils.utils import *
 from core.arcface_handler import Arcface_Handler
+import cv2
 
 class Face:
     def __init__(self, tmesh,
@@ -188,7 +189,8 @@ class Operator:
             cv2.fillConvexPoly(mask, vertices, 1)
 
         final_mask = mask * (1 - mask_mouth)
-        # final_mask = binary_erosion(final_mask, disk(5))
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+        final_mask = cv2.erode(final_mask, kernel, iterations=1)
         return im * (np.tile(np.expand_dims(final_mask, 2), [1, 1, 3])), final_mask
 
     def render_uv_image(self, generated, tcoords):
@@ -257,10 +259,10 @@ class Operator:
         landmarks = landmarks[:,::-1]
         landmarks[:,0] = 1 - landmarks[:,0]
         aligned_meshes = aligned_meshes[self.mask]
-
+        #TODO: landmarks to heatmaps
         return imgs, masks, landmarks, aligned_meshes
 
-    def get_tmesh(self, im, reconstruction_dict):
+    def get_tmesh(self, im, reconstruction_dict, face_mask):
         id_features = self.arcface_handler.get_identity_features(im, reconstruction_dict['dense_lms'][self.lms_ind])
 
         _, yaw_angle, _ = reconstruction_dict['euler_angles']
@@ -271,6 +273,11 @@ class Operator:
         landmarks = reconstruction_dict['dense_lms'][self.lms_ind].astype(np.int32)
 
         im_masked, mask_landmarks = self.mask_face(np.array(im_menpo2PIL(im)), landmarks, yaw_angle)
+
+        if face_mask is not None:
+            im_masked = im_masked * np.repeat(np.expand_dims(np.array(face_mask,np.bool),2),3,2)
+            mask_landmarks *= np.array(face_mask, np.uint8)
+
         im_masked = fill_UV(im_PIL2menpo(im_masked))
         im_masked.pixels = np.concatenate([im_masked.pixels, np.expand_dims(mask_landmarks,0)],0)
         img_uv_src = self.render_uv_image(im_masked, dense_lms[self.mask])
@@ -402,7 +409,7 @@ class Operator:
 
         return face, results_dict
 
-    def run(self, im, reconstruction_dict):
+    def run(self, im, reconstruction_dict, face_mask=None):
         start = time.time()
         print('Preprocessing...', end=" ")
         # GANFit compatibility
@@ -415,7 +422,7 @@ class Operator:
             reconstruction_dict['euler_angles'] =  get_pose(reconstruction_dict['camera_params'])
 
         # Prepare Textured Trimesh with visible part of the face
-        face = self.get_tmesh(im, reconstruction_dict)
+        face = self.get_tmesh(im, reconstruction_dict, face_mask)
 
         img_uv_src = face.img_uv_src.copy()
         angle_uv_src = face.angle_uv_src.copy()
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/MaskExtractor.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/MaskExtractor.py
new file mode 100644
index 0000000..bb815ea
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/MaskExtractor.py
@@ -0,0 +1,64 @@
+import torch
+from PIL import Image
+from torchvision.transforms import transforms
+
+from FaceHairMask import deeplab_xception_transfer
+from FaceHairMask.graphonomy_inference import inference
+
+import numpy as np
+import cv2
+
+def preprocess(image, size=256, normalize=1):
+    if size is None:
+        image = transforms.Resize((1024, 1024))(image)
+    else:
+        image = transforms.Resize((size, size))(image)
+    image = transforms.ToTensor()(image)
+    if normalize is not None:
+        image = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])(image)
+    return image
+
+def postProcess(faceMask, hairMask):
+    hairMask = hairMask.cpu().permute(1,2,0).detach().numpy()
+    faceMask = faceMask.cpu().permute(1,2,0).detach().numpy()
+    return faceMask, hairMask
+
+class MaskExtractor:
+    def __init__(self):
+        
+        #? Hair Face Extractors
+        self.net = deeplab_xception_transfer.deeplab_xception_transfer_projection_savemem(n_classes=20, hidden_layers=128, source_classes=7)
+        stateDict = torch.load("models/Graphonomy/inference.pth")
+        self.net.load_source_model(stateDict)
+        self.net.to("cuda")
+        self.net.eval()
+        
+
+    def processInput4(self, image):
+        preprocessedImage = preprocess(image, size=256, normalize=1)
+        preprocessedImage = preprocessedImage.unsqueeze(0).to("cuda")
+        return preprocessedImage
+    
+    def getMask(self, image):
+        preprocessedImage = self.processInput4(image)
+        _, hairMask, faceMask = inference(net=self.net, img=preprocessedImage, device="cuda")
+        faceMask, hairMask = postProcess(faceMask, hairMask)
+        return hairMask, faceMask
+        
+    def main(self, image):
+        image = (image.pixels_with_channels_at_back()[:, :, ::-1] * 255).astype('uint8')
+        hairMask, faceMask = self.getMask(Image.fromarray(image))
+        hairMask = transforms.Resize((Image.fromarray(image).size[1], Image.fromarray(image).size[0]))(Image.fromarray((hairMask[:,:,0]* 255).astype('uint8')))
+        faceMask = transforms.Resize((Image.fromarray(image).size[1], Image.fromarray(image).size[0]))(Image.fromarray((faceMask[:,:,0]* 255).astype('uint8')))
+
+        # Additional Morphology
+        hairMask = np.array(hairMask) / 255
+        faceMask = np.array(faceMask) / 255
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+        faceMask = cv2.erode(faceMask, kernel, iterations=1)
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (35, 35))
+        hairMask = cv2.dilate(hairMask, kernel, iterations=1)
+        faceMask = faceMask * (1 - hairMask)
+
+
+        return hairMask, faceMask
\ No newline at end of file
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/ParsingModel.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/ParsingModel.py
new file mode 100644
index 0000000..7f165b2
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/ParsingModel.py
@@ -0,0 +1,265 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ParsingResnet import Resnet18
+
+class ConvBNReLU(nn.Module):
+    def __init__(self, in_chan, out_chan, ks=3, stride=1, padding=1, *args, **kwargs):
+        super(ConvBNReLU, self).__init__()
+        self.conv = nn.Conv2d(in_chan,
+                out_chan,
+                kernel_size = ks,
+                stride = stride,
+                padding = padding,
+                bias = False)
+        self.bn = nn.BatchNorm2d(out_chan)
+        self.init_weight()
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = F.relu(self.bn(x))
+        return x
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+class BiSeNetOutput(nn.Module):
+    def __init__(self, in_chan, mid_chan, n_classes, *args, **kwargs):
+        super(BiSeNetOutput, self).__init__()
+        self.conv = ConvBNReLU(in_chan, mid_chan, ks=3, stride=1, padding=1)
+        self.conv_out = nn.Conv2d(mid_chan, n_classes, kernel_size=1, bias=False)
+        self.init_weight()
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.conv_out(x)
+        return x
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, nn.Linear) or isinstance(module, nn.Conv2d):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+class AttentionRefinementModule(nn.Module):
+    def __init__(self, in_chan, out_chan, *args, **kwargs):
+        super(AttentionRefinementModule, self).__init__()
+        self.conv = ConvBNReLU(in_chan, out_chan, ks=3, stride=1, padding=1)
+        self.conv_atten = nn.Conv2d(out_chan, out_chan, kernel_size= 1, bias=False)
+        self.bn_atten = nn.BatchNorm2d(out_chan)
+        self.sigmoid_atten = nn.Sigmoid()
+        self.init_weight()
+
+    def forward(self, x):
+        feat = self.conv(x)
+        atten = F.avg_pool2d(feat, feat.size()[2:])
+        atten = self.conv_atten(atten)
+        atten = self.bn_atten(atten)
+        atten = self.sigmoid_atten(atten)
+        out = torch.mul(feat, atten)
+        return out
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+
+class ContextPath(nn.Module):
+    def __init__(self, *args, **kwargs):
+        super(ContextPath, self).__init__()
+        self.resnet = Resnet18()
+        self.arm16 = AttentionRefinementModule(256, 128)
+        self.arm32 = AttentionRefinementModule(512, 128)
+        self.conv_head32 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1)
+        self.conv_head16 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1)
+        self.conv_avg = ConvBNReLU(512, 128, ks=1, stride=1, padding=0)
+
+        self.init_weight()
+
+    def forward(self, x):
+        H0, W0 = x.size()[2:]
+        feat8, feat16, feat32 = self.resnet(x)
+        H8, W8 = feat8.size()[2:]
+        H16, W16 = feat16.size()[2:]
+        H32, W32 = feat32.size()[2:]
+
+        avg = F.avg_pool2d(feat32, feat32.size()[2:])
+        avg = self.conv_avg(avg)
+        avg_up = F.interpolate(avg, (H32, W32), mode='nearest')
+
+        feat32_arm = self.arm32(feat32)
+        feat32_sum = feat32_arm + avg_up
+        feat32_up = F.interpolate(feat32_sum, (H16, W16), mode='nearest')
+        feat32_up = self.conv_head32(feat32_up)
+
+        feat16_arm = self.arm16(feat16)
+        feat16_sum = feat16_arm + feat32_up
+        feat16_up = F.interpolate(feat16_sum, (H8, W8), mode='nearest')
+        feat16_up = self.conv_head16(feat16_up)
+
+        return feat8, feat16_up, feat32_up  # x8, x8, x16
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, (nn.Linear, nn.Conv2d)):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+### This is not used, since I replace this with the resnet feature with the same size
+class SpatialPath(nn.Module):
+    def __init__(self, *args, **kwargs):
+        super(SpatialPath, self).__init__()
+        self.conv1 = ConvBNReLU(3, 64, ks=7, stride=2, padding=3)
+        self.conv2 = ConvBNReLU(64, 64, ks=3, stride=2, padding=1)
+        self.conv3 = ConvBNReLU(64, 64, ks=3, stride=2, padding=1)
+        self.conv_out = ConvBNReLU(64, 128, ks=1, stride=1, padding=0)
+        self.init_weight()
+
+    def forward(self, x):
+        feat = self.conv1(x)
+        feat = self.conv2(feat)
+        feat = self.conv3(feat)
+        feat = self.conv_out(feat)
+        return feat
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, nn.Linear) or isinstance(module, nn.Conv2d):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+class FeatureFusionModule(nn.Module):
+    def __init__(self, in_chan, out_chan, *args, **kwargs):
+        super(FeatureFusionModule, self).__init__()
+        self.convblk = ConvBNReLU(in_chan, out_chan, ks=1, stride=1, padding=0)
+        self.conv1 = nn.Conv2d(out_chan,
+                out_chan//4,
+                kernel_size = 1,
+                stride = 1,
+                padding = 0,
+                bias = False)
+        self.conv2 = nn.Conv2d(out_chan//4,
+                out_chan,
+                kernel_size = 1,
+                stride = 1,
+                padding = 0,
+                bias = False)
+        self.relu = nn.ReLU(inplace=True)
+        self.sigmoid = nn.Sigmoid()
+        self.init_weight()
+
+    def forward(self, fsp, fcp):
+        fcat = torch.cat([fsp, fcp], dim=1)
+        feat = self.convblk(fcat)
+        atten = F.avg_pool2d(feat, feat.size()[2:])
+        atten = self.conv1(atten)
+        atten = self.relu(atten)
+        atten = self.conv2(atten)
+        atten = self.sigmoid(atten)
+        feat_atten = torch.mul(feat, atten)
+        feat_out = feat_atten + feat
+        return feat_out
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, nn.Linear) or isinstance(module, nn.Conv2d):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+class BiSeNet(nn.Module):
+    def __init__(self, n_classes, *args, **kwargs):
+        super(BiSeNet, self).__init__()
+        self.cp = ContextPath()
+        ## here self.sp is deleted
+        self.ffm = FeatureFusionModule(256, 256)
+        self.conv_out = BiSeNetOutput(256, 256, n_classes)
+        self.conv_out16 = BiSeNetOutput(128, 64, n_classes)
+        self.conv_out32 = BiSeNetOutput(128, 64, n_classes)
+        self.init_weight()
+
+    def forward(self, x):
+        H, W = x.size()[2:]
+        feat_res8, feat_cp8, feat_cp16 = self.cp(x)  # here return res3b1 feature
+        feat_sp = feat_res8  # use res3b1 feature to replace spatial path feature
+        feat_fuse = self.ffm(feat_sp, feat_cp8)
+
+        feat_out = self.conv_out(feat_fuse)
+        feat_out16 = self.conv_out16(feat_cp8)
+        feat_out32 = self.conv_out32(feat_cp16)
+
+        feat_out = F.interpolate(feat_out, (H, W), mode='bilinear', align_corners=True)
+        feat_out16 = F.interpolate(feat_out16, (H, W), mode='bilinear', align_corners=True)
+        feat_out32 = F.interpolate(feat_out32, (H, W), mode='bilinear', align_corners=True)
+        return feat_out, feat_out16, feat_out32
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params, lr_mul_wd_params, lr_mul_nowd_params = [], [], [], []
+        for name, child in self.named_children():
+            child_wd_params, child_nowd_params = child.get_params()
+            if isinstance(child, FeatureFusionModule) or isinstance(child, BiSeNetOutput):
+                lr_mul_wd_params += child_wd_params
+                lr_mul_nowd_params += child_nowd_params
+            else:
+                wd_params += child_wd_params
+                nowd_params += child_nowd_params
+        return wd_params, nowd_params, lr_mul_wd_params, lr_mul_nowd_params
\ No newline at end of file
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/ParsingResnet.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/ParsingResnet.py
new file mode 100644
index 0000000..6a58284
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/ParsingResnet.py
@@ -0,0 +1,93 @@
+
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.model_zoo as modelzoo
+
+resnet18_url = 'https://download.pytorch.org/models/resnet18-5c106cde.pth'
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    def __init__(self, in_chan, out_chan, stride=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(in_chan, out_chan, stride)
+        self.bn1 = nn.BatchNorm2d(out_chan)
+        self.conv2 = conv3x3(out_chan, out_chan)
+        self.bn2 = nn.BatchNorm2d(out_chan)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = None
+        if in_chan != out_chan or stride != 1:
+            self.downsample = nn.Sequential(
+                nn.Conv2d(in_chan, out_chan,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(out_chan),
+                )
+
+    def forward(self, x):
+        residual = self.conv1(x)
+        residual = F.relu(self.bn1(residual))
+        residual = self.conv2(residual)
+        residual = self.bn2(residual)
+
+        shortcut = x
+        if self.downsample is not None:
+            shortcut = self.downsample(x)
+
+        out = shortcut + residual
+        out = self.relu(out)
+        return out
+
+
+def create_layer_basic(in_chan, out_chan, bnum, stride=1):
+    layers = [BasicBlock(in_chan, out_chan, stride=stride)]
+    for i in range(bnum-1):
+        layers.append(BasicBlock(out_chan, out_chan, stride=1))
+    return nn.Sequential(*layers)
+
+
+class Resnet18(nn.Module):
+    def __init__(self):
+        super(Resnet18, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = create_layer_basic(64, 64, bnum=2, stride=1)
+        self.layer2 = create_layer_basic(64, 128, bnum=2, stride=2)
+        self.layer3 = create_layer_basic(128, 256, bnum=2, stride=2)
+        self.layer4 = create_layer_basic(256, 512, bnum=2, stride=2)
+        self.init_weight()
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = F.relu(self.bn1(x))
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        feat8 = self.layer2(x) # 1/8
+        feat16 = self.layer3(feat8) # 1/16
+        feat32 = self.layer4(feat16) # 1/32
+        return feat8, feat16, feat32
+
+    def init_weight(self):
+        state_dict = modelzoo.load_url(resnet18_url)
+        self_state_dict = self.state_dict()
+        for k, v in state_dict.items():
+            if 'fc' in k: continue
+            self_state_dict.update({k: v})
+        self.load_state_dict(self_state_dict)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, (nn.Linear, nn.Conv2d)):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module,  nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
\ No newline at end of file
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/deeplab_xception.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/deeplab_xception.py
new file mode 100644
index 0000000..e2d98d5
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/deeplab_xception.py
@@ -0,0 +1,986 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from collections import OrderedDict
+import torch.utils.model_zoo as model_zoo
+from torch.nn.parameter import Parameter
+
+
+
+class SeparableConv2d(nn.Module):
+    def __init__(
+        self,
+        inplanes,
+        planes,
+        kernel_size=3,
+        stride=1,
+        padding=0,
+        dilation=1,
+        bias=False,
+    ):
+        super(SeparableConv2d, self).__init__()
+
+        self.conv1 = nn.Conv2d(
+            inplanes,
+            inplanes,
+            kernel_size,
+            stride,
+            padding,
+            dilation,
+            groups=inplanes,
+            bias=bias,
+        )
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.pointwise(x)
+        return x
+
+
+def fixed_padding(inputs, kernel_size, rate):
+    kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
+    pad_total = kernel_size_effective - 1
+    pad_beg = pad_total // 2
+    pad_end = pad_total - pad_beg
+    padded_inputs = F.pad(inputs, (pad_beg, pad_end, pad_beg, pad_end))
+    return padded_inputs
+
+
+class SeparableConv2d_aspp(nn.Module):
+    def __init__(
+        self,
+        inplanes,
+        planes,
+        kernel_size=3,
+        stride=1,
+        dilation=1,
+        bias=False,
+        padding=0,
+    ):
+        super(SeparableConv2d_aspp, self).__init__()
+
+        self.depthwise = nn.Conv2d(
+            inplanes,
+            inplanes,
+            kernel_size,
+            stride,
+            padding,
+            dilation,
+            groups=inplanes,
+            bias=bias,
+        )
+        self.depthwise_bn = nn.BatchNorm2d(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+        self.pointwise_bn = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU()
+
+    def forward(self, x):
+        #         x = fixed_padding(x, self.depthwise.kernel_size[0], rate=self.depthwise.dilation[0])
+        x = self.depthwise(x)
+        x = self.depthwise_bn(x)
+        x = self.relu(x)
+        x = self.pointwise(x)
+        x = self.pointwise_bn(x)
+        x = self.relu(x)
+        return x
+
+
+class Decoder_module(nn.Module):
+    def __init__(self, inplanes, planes, rate=1):
+        super(Decoder_module, self).__init__()
+        self.atrous_convolution = SeparableConv2d_aspp(
+            inplanes, planes, 3, stride=1, dilation=rate, padding=1
+        )
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        return x
+
+
+class ASPP_module(nn.Module):
+    def __init__(self, inplanes, planes, rate):
+        super(ASPP_module, self).__init__()
+        if rate == 1:
+            raise RuntimeError()
+        else:
+            kernel_size = 3
+            padding = rate
+            self.atrous_convolution = SeparableConv2d_aspp(
+                inplanes, planes, 3, stride=1, dilation=rate, padding=padding
+            )
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        return x
+
+
+class ASPP_module_rate0(nn.Module):
+    def __init__(self, inplanes, planes, rate=1):
+        super(ASPP_module_rate0, self).__init__()
+        if rate == 1:
+            kernel_size = 1
+            padding = 0
+            self.atrous_convolution = nn.Conv2d(
+                inplanes,
+                planes,
+                kernel_size=kernel_size,
+                stride=1,
+                padding=padding,
+                dilation=rate,
+                bias=False,
+            )
+            self.bn = nn.BatchNorm2d(planes, eps=1e-5, affine=True)
+            self.relu = nn.ReLU()
+        else:
+            raise RuntimeError()
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        x = self.bn(x)
+        return self.relu(x)
+
+
+class SeparableConv2d_same(nn.Module):
+    def __init__(
+        self,
+        inplanes,
+        planes,
+        kernel_size=3,
+        stride=1,
+        dilation=1,
+        bias=False,
+        padding=0,
+    ):
+        super(SeparableConv2d_same, self).__init__()
+
+        self.depthwise = nn.Conv2d(
+            inplanes,
+            inplanes,
+            kernel_size,
+            stride,
+            padding,
+            dilation,
+            groups=inplanes,
+            bias=bias,
+        )
+        self.depthwise_bn = nn.BatchNorm2d(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+        self.pointwise_bn = nn.BatchNorm2d(planes)
+
+    def forward(self, x):
+        x = fixed_padding(
+            x, self.depthwise.kernel_size[0], rate=self.depthwise.dilation[0]
+        )
+        x = self.depthwise(x)
+        x = self.depthwise_bn(x)
+        x = self.pointwise(x)
+        x = self.pointwise_bn(x)
+        return x
+
+
+class Block(nn.Module):
+    def __init__(
+        self,
+        inplanes,
+        planes,
+        reps,
+        stride=1,
+        dilation=1,
+        start_with_relu=True,
+        grow_first=True,
+        is_last=False,
+    ):
+        super(Block, self).__init__()
+
+        if planes != inplanes or stride != 1:
+            self.skip = nn.Conv2d(inplanes, planes, 1, stride=2, bias=False)
+            if is_last:
+                self.skip = nn.Conv2d(inplanes, planes, 1, stride=1, bias=False)
+            self.skipbn = nn.BatchNorm2d(planes)
+        else:
+            self.skip = None
+
+        self.relu = nn.ReLU(inplace=True)
+        rep = []
+
+        filters = inplanes
+        if grow_first:
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation)
+            )
+            #             rep.append(nn.BatchNorm2d(planes))
+            filters = planes
+
+        for i in range(reps - 1):
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(filters, filters, 3, stride=1, dilation=dilation)
+            )
+        #             rep.append(nn.BatchNorm2d(filters))
+
+        if not grow_first:
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation)
+            )
+        #             rep.append(nn.BatchNorm2d(planes))
+
+        if not start_with_relu:
+            rep = rep[1:]
+
+        if stride != 1:
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(planes, planes, 3, stride=2, dilation=dilation)
+            )
+
+        if is_last:
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(planes, planes, 3, stride=1, dilation=dilation)
+            )
+
+        self.rep = nn.Sequential(*rep)
+
+    def forward(self, inp):
+        x = self.rep(inp)
+
+        if self.skip is not None:
+            skip = self.skip(inp)
+            skip = self.skipbn(skip)
+        else:
+            skip = inp
+        # print(x.size(),skip.size())
+        x += skip
+
+        return x
+
+
+class Block2(nn.Module):
+    def __init__(
+        self,
+        inplanes,
+        planes,
+        reps,
+        stride=1,
+        dilation=1,
+        start_with_relu=True,
+        grow_first=True,
+        is_last=False,
+    ):
+        super(Block2, self).__init__()
+
+        if planes != inplanes or stride != 1:
+            self.skip = nn.Conv2d(inplanes, planes, 1, stride=stride, bias=False)
+            self.skipbn = nn.BatchNorm2d(planes)
+        else:
+            self.skip = None
+
+        self.relu = nn.ReLU(inplace=True)
+        rep = []
+
+        filters = inplanes
+        if grow_first:
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation)
+            )
+            #             rep.append(nn.BatchNorm2d(planes))
+            filters = planes
+
+        for i in range(reps - 1):
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(filters, filters, 3, stride=1, dilation=dilation)
+            )
+        #             rep.append(nn.BatchNorm2d(filters))
+
+        if not grow_first:
+            rep.append(self.relu)
+            rep.append(
+                SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation)
+            )
+        #             rep.append(nn.BatchNorm2d(planes))
+
+        if not start_with_relu:
+            rep = rep[1:]
+
+        if stride != 1:
+            self.block2_lastconv = nn.Sequential(
+                *[
+                    self.relu,
+                    SeparableConv2d_same(
+                        planes, planes, 3, stride=2, dilation=dilation
+                    ),
+                ]
+            )
+
+        if is_last:
+            rep.append(SeparableConv2d_same(planes, planes, 3, stride=1))
+
+        self.rep = nn.Sequential(*rep)
+
+    def forward(self, inp):
+        x = self.rep(inp)
+        low_middle = x.clone()
+        x1 = x
+        x1 = self.block2_lastconv(x1)
+        if self.skip is not None:
+            skip = self.skip(inp)
+            skip = self.skipbn(skip)
+        else:
+            skip = inp
+
+        x1 += skip
+
+        return x1, low_middle
+
+
+class Xception(nn.Module):
+    """
+    Modified Alighed Xception
+    """
+
+    def __init__(self, inplanes=3, os=16, pretrained=False):
+        super(Xception, self).__init__()
+
+        if os == 16:
+            entry_block3_stride = 2
+            middle_block_rate = 1
+            exit_block_rates = (1, 2)
+        elif os == 8:
+            entry_block3_stride = 1
+            middle_block_rate = 2
+            exit_block_rates = (2, 4)
+        else:
+            raise NotImplementedError
+
+        # Entry flow
+        self.conv1 = nn.Conv2d(inplanes, 32, 3, stride=2, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(32)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(32, 64, 3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(64)
+
+        self.block1 = Block(64, 128, reps=2, stride=2, start_with_relu=False)
+        self.block2 = Block2(
+            128, 256, reps=2, stride=2, start_with_relu=True, grow_first=True
+        )
+        self.block3 = Block(
+            256,
+            728,
+            reps=2,
+            stride=entry_block3_stride,
+            start_with_relu=True,
+            grow_first=True,
+        )
+
+        # Middle flow
+        self.block4 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block5 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block6 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block7 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block8 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block9 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block10 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block11 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block12 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block13 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block14 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block15 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block16 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block17 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block18 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+        self.block19 = Block(
+            728,
+            728,
+            reps=3,
+            stride=1,
+            dilation=middle_block_rate,
+            start_with_relu=True,
+            grow_first=True,
+        )
+
+        # Exit flow
+        self.block20 = Block(
+            728,
+            1024,
+            reps=2,
+            stride=1,
+            dilation=exit_block_rates[0],
+            start_with_relu=True,
+            grow_first=False,
+            is_last=True,
+        )
+
+        self.conv3 = SeparableConv2d_aspp(
+            1024,
+            1536,
+            3,
+            stride=1,
+            dilation=exit_block_rates[1],
+            padding=exit_block_rates[1],
+        )
+        # self.bn3 = nn.BatchNorm2d(1536)
+
+        self.conv4 = SeparableConv2d_aspp(
+            1536,
+            1536,
+            3,
+            stride=1,
+            dilation=exit_block_rates[1],
+            padding=exit_block_rates[1],
+        )
+        # self.bn4 = nn.BatchNorm2d(1536)
+
+        self.conv5 = SeparableConv2d_aspp(
+            1536,
+            2048,
+            3,
+            stride=1,
+            dilation=exit_block_rates[1],
+            padding=exit_block_rates[1],
+        )
+        # self.bn5 = nn.BatchNorm2d(2048)
+
+        # Init weights
+        # self.__init_weight()
+
+        # Load pretrained model
+        if pretrained:
+            self.__load_xception_pretrained()
+
+    def forward(self, x):
+        # Entry flow
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        # print('conv1 ',x.size())
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
+
+        x = self.block1(x)
+        # print('block1',x.size())
+        # low_level_feat = x
+        x, low_level_feat = self.block2(x)
+        # print('block2',x.size())
+        x = self.block3(x)
+        # print('xception block3 ',x.size())
+
+        # Middle flow
+        x = self.block4(x)
+        x = self.block5(x)
+        x = self.block6(x)
+        x = self.block7(x)
+        x = self.block8(x)
+        x = self.block9(x)
+        x = self.block10(x)
+        x = self.block11(x)
+        x = self.block12(x)
+        x = self.block13(x)
+        x = self.block14(x)
+        x = self.block15(x)
+        x = self.block16(x)
+        x = self.block17(x)
+        x = self.block18(x)
+        x = self.block19(x)
+
+        # Exit flow
+        x = self.block20(x)
+        x = self.conv3(x)
+        # x = self.bn3(x)
+        x = self.relu(x)
+
+        x = self.conv4(x)
+        # x = self.bn4(x)
+        x = self.relu(x)
+
+        x = self.conv5(x)
+        # x = self.bn5(x)
+        x = self.relu(x)
+
+        return x, low_level_feat
+
+    def __init_weight(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                # m.weight.data.normal_(0, math.sqrt(2. / n))
+                torch.nn.init.kaiming_normal_(m.weight)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def __load_xception_pretrained(self):
+        pretrain_dict = model_zoo.load_url(
+            "http://data.lip6.fr/cadene/pretrainedmodels/xception-b5690688.pth"
+        )
+        model_dict = {}
+        state_dict = self.state_dict()
+
+        for k, v in pretrain_dict.items():
+            if k in state_dict:
+                if "pointwise" in k:
+                    v = v.unsqueeze(-1).unsqueeze(-1)
+                if k.startswith("block12"):
+                    model_dict[k.replace("block12", "block20")] = v
+                elif k.startswith("block11"):
+                    model_dict[k.replace("block11", "block12")] = v
+                    model_dict[k.replace("block11", "block13")] = v
+                    model_dict[k.replace("block11", "block14")] = v
+                    model_dict[k.replace("block11", "block15")] = v
+                    model_dict[k.replace("block11", "block16")] = v
+                    model_dict[k.replace("block11", "block17")] = v
+                    model_dict[k.replace("block11", "block18")] = v
+                    model_dict[k.replace("block11", "block19")] = v
+                elif k.startswith("conv3"):
+                    model_dict[k] = v
+                elif k.startswith("bn3"):
+                    model_dict[k] = v
+                    model_dict[k.replace("bn3", "bn4")] = v
+                elif k.startswith("conv4"):
+                    model_dict[k.replace("conv4", "conv5")] = v
+                elif k.startswith("bn4"):
+                    model_dict[k.replace("bn4", "bn5")] = v
+                else:
+                    model_dict[k] = v
+        state_dict.update(model_dict)
+        self.load_state_dict(state_dict)
+
+
+class DeepLabv3_plus(nn.Module):
+    def __init__(
+        self, nInputChannels=3, n_classes=21, os=16, pretrained=False, _print=True
+    ):
+        if _print:
+            print("Constructing DeepLabv3+ model...")
+            print("Number of classes: {}".format(n_classes))
+            print("Output stride: {}".format(os))
+            print("Number of Input Channels: {}".format(nInputChannels))
+        super(DeepLabv3_plus, self).__init__()
+
+        # Atrous Conv
+        self.xception_features = Xception(nInputChannels, os, pretrained)
+
+        # ASPP
+        if os == 16:
+            rates = [1, 6, 12, 18]
+        elif os == 8:
+            rates = [1, 12, 24, 36]
+            raise NotImplementedError
+        else:
+            raise NotImplementedError
+
+        self.aspp1 = ASPP_module_rate0(2048, 256, rate=rates[0])
+        self.aspp2 = ASPP_module(2048, 256, rate=rates[1])
+        self.aspp3 = ASPP_module(2048, 256, rate=rates[2])
+        self.aspp4 = ASPP_module(2048, 256, rate=rates[3])
+
+        self.relu = nn.ReLU()
+
+        self.global_avg_pool = nn.Sequential(
+            nn.AdaptiveAvgPool2d((1, 1)),
+            nn.Conv2d(2048, 256, 1, stride=1, bias=False),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+        )
+
+        self.concat_projection_conv1 = nn.Conv2d(1280, 256, 1, bias=False)
+        self.concat_projection_bn1 = nn.BatchNorm2d(256)
+
+        # adopt [1x1, 48] for channel reduction.
+        self.feature_projection_conv1 = nn.Conv2d(256, 48, 1, bias=False)
+        self.feature_projection_bn1 = nn.BatchNorm2d(48)
+
+        self.decoder = nn.Sequential(Decoder_module(304, 256), Decoder_module(256, 256))
+        self.semantic = nn.Conv2d(256, n_classes, kernel_size=1, stride=1)
+
+    def forward(self, input):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode="bilinear", align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+
+        x = F.upsample(
+            x, size=low_level_features.size()[2:], mode="bilinear", align_corners=True
+        )
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode="bilinear", align_corners=True)
+
+        return x
+
+    def freeze_bn(self):
+        for m in self.xception_features.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+
+    def freeze_totally_bn(self):
+        for m in self.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+
+    def freeze_aspp_bn(self):
+        for m in self.aspp1.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp2.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp3.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp4.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+
+    def learnable_parameters(self):
+        layer_features_BN = []
+        layer_features = []
+        layer_aspp = []
+        layer_projection = []
+        layer_decoder = []
+        layer_other = []
+        model_para = list(self.named_parameters())
+        for name, para in model_para:
+            if "xception" in name:
+                if (
+                    "bn" in name
+                    or "downsample.1.weight" in name
+                    or "downsample.1.bias" in name
+                ):
+                    layer_features_BN.append(para)
+                else:
+                    layer_features.append(para)
+                    # print (name)
+            elif "aspp" in name:
+                layer_aspp.append(para)
+            elif "projection" in name:
+                layer_projection.append(para)
+            elif "decode" in name:
+                layer_decoder.append(para)
+            elif "global" not in name:
+                layer_other.append(para)
+        return (
+            layer_features_BN,
+            layer_features,
+            layer_aspp,
+            layer_projection,
+            layer_decoder,
+            layer_other,
+        )
+
+    def get_backbone_para(self):
+        layer_features = []
+        other_features = []
+        model_para = list(self.named_parameters())
+        for name, para in model_para:
+            if "xception" in name:
+                layer_features.append(para)
+            else:
+                other_features.append(para)
+
+        return layer_features, other_features
+
+    def train_fixbn(self, mode=True, freeze_bn=True, freeze_bn_affine=False):
+        r"""Sets the module in training mode.
+
+        This has any effect only on certain modules. See documentations of
+        particular modules for details of their behaviors in training/evaluation
+        mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,
+        etc.
+
+        Returns:
+            Module: self
+        """
+        super(DeepLabv3_plus, self).train(mode)
+        if freeze_bn:
+            print("Freezing Mean/Var of BatchNorm2D.")
+            if freeze_bn_affine:
+                print("Freezing Weight/Bias of BatchNorm2D.")
+        if freeze_bn:
+            for m in self.xception_features.modules():
+                if isinstance(m, nn.BatchNorm2d):
+                    m.eval()
+                    if freeze_bn_affine:
+                        m.weight.requires_grad = False
+                        m.bias.requires_grad = False
+            # for m in self.aspp1.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.aspp2.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.aspp3.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.aspp4.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.global_avg_pool.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.concat_projection_bn1.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.feature_projection_bn1.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+
+    def __init_weight(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2.0 / n))
+                # torch.nn.init.kaiming_normal_(m.weight)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def load_state_dict_new(self, state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace("module.", "")
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if "num_batch" in name:
+                    continue
+                print('unexpected key "{}" in state_dict'.format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print(
+                    "While copying the parameter named {}, whose dimensions in the model are"
+                    " {} and whose dimensions in the checkpoint are {}, ...".format(
+                        name, own_state[name].size(), param.size()
+                    )
+                )
+                continue  # i add inshop_cos 2018/02/01
+                # raise
+                # print 'copying %s' %name
+                # if isinstance(param, own_state):
+                # backwards compatibility for serialized parameters
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+
+def get_1x_lr_params(model):
+    """
+    This generator returns all the parameters of the net except for
+    the last classification layer. Note that for each batchnorm layer,
+    requires_grad is set to False in deeplab_resnet.py, therefore this function does not return
+    any batchnorm parameter
+    """
+    b = [model.xception_features]
+    for i in range(len(b)):
+        for k in b[i].parameters():
+            if k.requires_grad:
+                yield k
+
+
+def get_10x_lr_params(model):
+    """
+    This generator returns all the parameters for the last layer of the net,
+    which does the classification of pixel into classes
+    """
+    b = [
+        model.aspp1,
+        model.aspp2,
+        model.aspp3,
+        model.aspp4,
+        model.conv1,
+        model.conv2,
+        model.last_conv,
+    ]
+    for j in range(len(b)):
+        for k in b[j].parameters():
+            if k.requires_grad:
+                yield k
+
+
+if __name__ == "__main__":
+    model = DeepLabv3_plus(
+        nInputChannels=3, n_classes=21, os=16, pretrained=False, _print=True
+    )
+    model.eval()
+    image = torch.randn(1, 3, 512, 512) * 255
+    with torch.no_grad():
+        output = model.forward(image)
+    print(output.size())
+    # print(output)
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/deeplab_xception_transfer.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/deeplab_xception_transfer.py
new file mode 100644
index 0000000..c4f9cfb
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/deeplab_xception_transfer.py
@@ -0,0 +1,753 @@
+import torch
+import torch.nn as nn
+from torch.nn import Parameter
+import torch.nn.functional as F
+from collections import OrderedDict
+from . import deeplab_xception, gcn
+from torch.nn.parameter import Parameter
+
+
+#######################
+# base model
+#######################
+
+
+class deeplab_xception_transfer_basemodel(deeplab_xception.DeepLabv3_plus):
+    def __init__(
+        self,
+        nInputChannels=3,
+        n_classes=7,
+        os=16,
+        input_channels=256,
+        hidden_layers=128,
+        out_channels=256,
+    ):
+        super(deeplab_xception_transfer_basemodel, self).__init__(
+            nInputChannels=nInputChannels,
+            n_classes=n_classes,
+            os=os,
+        )
+        ### source graph
+        # self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+        #                                                    nodes=n_classes)
+        # self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        #
+        # self.source_graph_2_fea = gcn.Graph_to_Featuremaps(input_channels=input_channels, output_channels=out_channels,
+        #                                             hidden_layers=hidden_layers, nodes=n_classes
+        #                                             )
+        # self.source_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+        #                                  nn.ReLU(True)])
+
+        ### target graph
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(
+            input_channels=input_channels, hidden_layers=hidden_layers, nodes=n_classes
+        )
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps(
+            input_channels=input_channels,
+            output_channels=out_channels,
+            hidden_layers=hidden_layers,
+            nodes=n_classes,
+        )
+        self.target_skip_conv = nn.Sequential(
+            *[nn.Conv2d(input_channels, input_channels, kernel_size=1), nn.ReLU(True)]
+        )
+
+    def load_source_model(self, state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace("module.", "")
+            if (
+                "graph" in name
+                and "source" not in name
+                and "target" not in name
+                and "fc_graph" not in name
+                and "transpose_graph" not in name
+            ):
+                if "featuremap_2_graph" in name:
+                    name = name.replace(
+                        "featuremap_2_graph", "source_featuremap_2_graph"
+                    )
+                else:
+                    name = name.replace("graph", "source_graph")
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if "num_batch" in name:
+                    continue
+                print('unexpected key "{}" in state_dict'.format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print(
+                    "While copying the parameter named {}, whose dimensions in the model are"
+                    " {} and whose dimensions in the checkpoint are {}, ...".format(
+                        name, own_state[name].size(), param.size()
+                    )
+                )
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if "target" in name or "semantic" in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if "semantic" in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if "source" in name:
+                l.append(k)
+        return l
+
+    def forward(self, input, adj1_target=None, adj2_source=None, adj3_transfer=None):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode="bilinear", align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(
+            x, size=low_level_features.size()[2:], mode="bilinear", align_corners=True
+        )
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode="bilinear", align_corners=True)
+
+        return x
+
+
+class deeplab_xception_transfer_basemodel_savememory(deeplab_xception.DeepLabv3_plus):
+    def __init__(
+        self,
+        nInputChannels=3,
+        n_classes=7,
+        os=16,
+        input_channels=256,
+        hidden_layers=128,
+        out_channels=256,
+    ):
+        super(deeplab_xception_transfer_basemodel_savememory, self).__init__(
+            nInputChannels=nInputChannels,
+            n_classes=n_classes,
+            os=os,
+        )
+        ### source graph
+
+        ### target graph
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(
+            input_channels=input_channels, hidden_layers=hidden_layers, nodes=n_classes
+        )
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(
+            input_channels=input_channels,
+            output_channels=out_channels,
+            hidden_layers=hidden_layers,
+            nodes=n_classes,
+        )
+        self.target_skip_conv = nn.Sequential(
+            *[nn.Conv2d(input_channels, input_channels, kernel_size=1), nn.ReLU(True)]
+        )
+
+    def load_source_model(self, state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace("module.", "")
+            if (
+                "graph" in name
+                and "source" not in name
+                and "target" not in name
+                and "fc_graph" not in name
+                and "transpose_graph" not in name
+            ):
+                if "featuremap_2_graph" in name:
+                    name = name.replace(
+                        "featuremap_2_graph", "source_featuremap_2_graph"
+                    )
+                else:
+                    name = name.replace("graph", "source_graph")
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if "num_batch" in name:
+                    continue
+                print('unexpected key "{}" in state_dict'.format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print(
+                    "While copying the parameter named {}, whose dimensions in the model are"
+                    " {} and whose dimensions in the checkpoint are {}, ...".format(
+                        name, own_state[name].size(), param.size()
+                    )
+                )
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if "target" in name or "semantic" in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if "semantic" in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if "source" in name:
+                l.append(k)
+        return l
+
+    def forward(self, input, adj1_target=None, adj2_source=None, adj3_transfer=None):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode="bilinear", align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(
+            x, size=low_level_features.size()[2:], mode="bilinear", align_corners=True
+        )
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode="bilinear", align_corners=True)
+
+        return x
+
+
+#######################
+# transfer model
+#######################
+
+
+class deeplab_xception_transfer_projection(deeplab_xception_transfer_basemodel):
+    def __init__(
+        self,
+        nInputChannels=3,
+        n_classes=7,
+        os=16,
+        input_channels=256,
+        hidden_layers=128,
+        out_channels=256,
+        transfer_graph=None,
+        source_classes=20,
+    ):
+        super(deeplab_xception_transfer_projection, self).__init__(
+            nInputChannels=nInputChannels,
+            n_classes=n_classes,
+            os=os,
+            input_channels=input_channels,
+            hidden_layers=hidden_layers,
+            out_channels=out_channels,
+        )
+        self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(
+            input_channels=input_channels,
+            hidden_layers=hidden_layers,
+            nodes=source_classes,
+        )
+        self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.transpose_graph = gcn.Graph_trans(
+            in_features=hidden_layers,
+            out_features=hidden_layers,
+            adj=transfer_graph,
+            begin_nodes=source_classes,
+            end_nodes=n_classes,
+        )
+        self.fc_graph = gcn.GraphConvolution(hidden_layers * 3, hidden_layers)
+
+    def forward(self, input, adj1_target=None, adj2_source=None, adj3_transfer=None):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode="bilinear", align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(
+            x, size=low_level_features.size()[2:], mode="bilinear", align_corners=True
+        )
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+        # source graph
+        source_graph = self.source_featuremap_2_graph(x)
+        source_graph1 = self.source_graph_conv1.forward(
+            source_graph, adj=adj2_source, relu=True
+        )
+        source_graph2 = self.source_graph_conv2.forward(
+            source_graph1, adj=adj2_source, relu=True
+        )
+        source_graph3 = self.source_graph_conv2.forward(
+            source_graph2, adj=adj2_source, relu=True
+        )
+
+        source_2_target_graph1_v5 = self.transpose_graph.forward(
+            source_graph1, adj=adj3_transfer, relu=True
+        )
+        source_2_target_graph2_v5 = self.transpose_graph.forward(
+            source_graph2, adj=adj3_transfer, relu=True
+        )
+        source_2_target_graph3_v5 = self.transpose_graph.forward(
+            source_graph3, adj=adj3_transfer, relu=True
+        )
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        source_2_target_graph1 = self.similarity_trans(source_graph1, graph)
+        # graph combine 1
+        # print(graph.size())
+        # print(source_2_target_graph1.size())
+        # print(source_2_target_graph1_v5.size())
+        graph = torch.cat(
+            (
+                graph,
+                source_2_target_graph1.squeeze(0),
+                source_2_target_graph1_v5.squeeze(0),
+            ),
+            dim=-1,
+        )
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph2 = self.similarity_trans(source_graph2, graph)
+        # graph combine 2
+        graph = torch.cat(
+            (graph, source_2_target_graph2, source_2_target_graph2_v5), dim=-1
+        )
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph3 = self.similarity_trans(source_graph3, graph)
+        # graph combine 3
+        graph = torch.cat(
+            (graph, source_2_target_graph3, source_2_target_graph3_v5), dim=-1
+        )
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+
+        # print(graph.size(),x.size())
+
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode="bilinear", align_corners=True)
+
+        return x
+
+    def similarity_trans(self, source, target):
+        sim = torch.matmul(
+            F.normalize(target, p=2, dim=-1),
+            F.normalize(source, p=2, dim=-1).transpose(-1, -2),
+        )
+        sim = F.softmax(sim, dim=-1)
+        return torch.matmul(sim, source)
+
+    def load_source_model(self, state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace("module.", "")
+
+            if (
+                "graph" in name
+                and "source" not in name
+                and "target" not in name
+                and "fc_" not in name
+                and "transpose_graph" not in name
+            ):
+                if "featuremap_2_graph" in name:
+                    name = name.replace(
+                        "featuremap_2_graph", "source_featuremap_2_graph"
+                    )
+                else:
+                    name = name.replace("graph", "source_graph")
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if "num_batch" in name:
+                    continue
+                print('unexpected key "{}" in state_dict'.format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print(
+                    "While copying the parameter named {}, whose dimensions in the model are"
+                    " {} and whose dimensions in the checkpoint are {}, ...".format(
+                        name, own_state[name].size(), param.size()
+                    )
+                )
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+
+class deeplab_xception_transfer_projection_savemem(
+    deeplab_xception_transfer_basemodel_savememory
+):
+    def __init__(
+        self,
+        nInputChannels=3,
+        n_classes=7,
+        os=16,
+        input_channels=256,
+        hidden_layers=128,
+        out_channels=256,
+        transfer_graph=None,
+        source_classes=20,
+    ):
+        super(deeplab_xception_transfer_projection_savemem, self).__init__(
+            nInputChannels=nInputChannels,
+            n_classes=n_classes,
+            os=os,
+            input_channels=input_channels,
+            hidden_layers=hidden_layers,
+            out_channels=out_channels,
+        )
+        self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(
+            input_channels=input_channels,
+            hidden_layers=hidden_layers,
+            nodes=source_classes,
+        )
+        self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.transpose_graph = gcn.Graph_trans(
+            in_features=hidden_layers,
+            out_features=hidden_layers,
+            adj=transfer_graph,
+            begin_nodes=source_classes,
+            end_nodes=n_classes,
+        )
+        self.fc_graph = gcn.GraphConvolution(hidden_layers * 3, hidden_layers)
+
+    def forward(self, input, adj1_target=None, adj2_source=None, adj3_transfer=None):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode="bilinear", align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(
+            x, size=low_level_features.size()[2:], mode="bilinear", align_corners=True
+        )
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+        # source graph
+        source_graph = self.source_featuremap_2_graph(x)
+        source_graph1 = self.source_graph_conv1.forward(
+            source_graph, adj=adj2_source, relu=True
+        )
+        source_graph2 = self.source_graph_conv2.forward(
+            source_graph1, adj=adj2_source, relu=True
+        )
+        source_graph3 = self.source_graph_conv2.forward(
+            source_graph2, adj=adj2_source, relu=True
+        )
+
+        source_2_target_graph1_v5 = self.transpose_graph.forward(
+            source_graph1, adj=adj3_transfer, relu=True
+        )
+        source_2_target_graph2_v5 = self.transpose_graph.forward(
+            source_graph2, adj=adj3_transfer, relu=True
+        )
+        source_2_target_graph3_v5 = self.transpose_graph.forward(
+            source_graph3, adj=adj3_transfer, relu=True
+        )
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        source_2_target_graph1 = self.similarity_trans(source_graph1, graph)
+        # graph combine 1
+        graph = torch.cat(
+            (
+                graph,
+                source_2_target_graph1.squeeze(0),
+                source_2_target_graph1_v5.squeeze(0),
+            ),
+            dim=-1,
+        )
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph2 = self.similarity_trans(source_graph2, graph)
+        # graph combine 2
+        graph = torch.cat(
+            (graph, source_2_target_graph2, source_2_target_graph2_v5), dim=-1
+        )
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph3 = self.similarity_trans(source_graph3, graph)
+        # graph combine 3
+        graph = torch.cat(
+            (graph, source_2_target_graph3, source_2_target_graph3_v5), dim=-1
+        )
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+
+        # print(graph.size(),x.size())
+
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode="bilinear", align_corners=True)
+
+        return x
+
+    def similarity_trans(self, source, target):
+        sim = torch.matmul(
+            F.normalize(target, p=2, dim=-1),
+            F.normalize(source, p=2, dim=-1).transpose(-1, -2),
+        )
+        sim = F.softmax(sim, dim=-1)
+        return torch.matmul(sim, source)
+
+    def load_source_model(self, state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace("module.", "")
+
+            if (
+                "graph" in name
+                and "source" not in name
+                and "target" not in name
+                and "fc_" not in name
+                and "transpose_graph" not in name
+            ):
+                if "featuremap_2_graph" in name:
+                    name = name.replace(
+                        "featuremap_2_graph", "source_featuremap_2_graph"
+                    )
+                else:
+                    name = name.replace("graph", "source_graph")
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if "num_batch" in name:
+                    continue
+                print('unexpected key "{}" in state_dict'.format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print(
+                    "While copying the parameter named {}, whose dimensions in the model are"
+                    " {} and whose dimensions in the checkpoint are {}, ...".format(
+                        name, own_state[name].size(), param.size()
+                    )
+                )
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+
+# if __name__ == '__main__':
+# net = deeplab_xception_transfer_projection_v3v5_more_savemem()
+# img = torch.rand((2,3,128,128))
+# net.eval()
+# a = torch.rand((1,1,7,7))
+# net.forward(img, adj1_target=a)
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/gcn.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/gcn.py
new file mode 100644
index 0000000..e5eb066
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/gcn.py
@@ -0,0 +1,304 @@
+import torch
+from . import graph
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn.parameter import Parameter
+
+class GraphConvolution(nn.Module):
+    def __init__(self, in_features, out_features, bias=False):
+        super(GraphConvolution, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = Parameter(torch.FloatTensor(in_features, out_features))
+        if bias:
+            self.bias = Parameter(torch.FloatTensor(out_features))
+        else:
+            self.register_parameter("bias", None)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        # stdv = 1./math.sqrt(self.weight(1))
+        # self.weight.data.uniform_(-stdv,stdv)
+        torch.nn.init.xavier_uniform_(self.weight)
+        # if self.bias is not None:
+        #     self.bias.data.uniform_(-stdv,stdv)
+
+    def forward(self, input, adj=None, relu=False):
+        support = torch.matmul(input, self.weight)
+        # print(support.size(),adj.size())
+        if adj is not None:
+            output = torch.matmul(adj, support)
+        else:
+            output = support
+        # print(output.size())
+        if self.bias is not None:
+            return output + self.bias
+        else:
+            if relu:
+                return F.relu(output)
+            else:
+                return output
+
+    def __repr__(self):
+        return (
+            self.__class__.__name__
+            + " ("
+            + str(self.in_features)
+            + " -> "
+            + str(self.out_features)
+            + ")"
+        )
+
+
+class Featuremaps_to_Graph(nn.Module):
+    def __init__(self, input_channels, hidden_layers, nodes=7):
+        super(Featuremaps_to_Graph, self).__init__()
+        self.pre_fea = Parameter(torch.FloatTensor(input_channels, nodes))
+        self.weight = Parameter(torch.FloatTensor(input_channels, hidden_layers))
+        self.reset_parameters()
+
+    def forward(self, input):
+        n, c, h, w = input.size()
+        # print('fea input',input.size())
+        input1 = input.view(n, c, h * w)
+        input1 = input1.transpose(1, 2)  # n x hw x c
+        # print('fea input1', input1.size())
+        ############## Feature maps to node ################
+        fea_node = torch.matmul(input1, self.pre_fea)  # n x hw x n_classes
+        weight_node = torch.matmul(input1, self.weight)  # n x hw x hidden_layer
+        # softmax fea_node
+        fea_node = F.softmax(fea_node, dim=-1)
+        # print(fea_node.size(),weight_node.size())
+        graph_node = F.relu(torch.matmul(fea_node.transpose(1, 2), weight_node))
+        return graph_node  # n x n_class x hidden_layer
+
+    def reset_parameters(self):
+        for ww in self.parameters():
+            torch.nn.init.xavier_uniform_(ww)
+        # if self.bias is not None:
+        #     self.bias.data.uniform_(-stdv,stdv)
+
+
+class Featuremaps_to_Graph_transfer(nn.Module):
+    def __init__(self, input_channels, hidden_layers, nodes=7, source_nodes=20):
+        super(Featuremaps_to_Graph_transfer, self).__init__()
+        self.pre_fea = Parameter(torch.FloatTensor(input_channels, nodes))
+        self.weight = Parameter(torch.FloatTensor(input_channels, hidden_layers))
+        self.pre_fea_transfer = nn.Sequential(
+            *[
+                nn.Linear(source_nodes, source_nodes),
+                nn.LeakyReLU(True),
+                nn.Linear(source_nodes, nodes),
+                nn.LeakyReLU(True),
+            ]
+        )
+        self.reset_parameters()
+
+    def forward(self, input, source_pre_fea):
+        self.pre_fea.data = self.pre_fea_learn(source_pre_fea)
+        n, c, h, w = input.size()
+        # print('fea input',input.size())
+        input1 = input.view(n, c, h * w)
+        input1 = input1.transpose(1, 2)  # n x hw x c
+        # print('fea input1', input1.size())
+        ############## Feature maps to node ################
+        fea_node = torch.matmul(input1, self.pre_fea)  # n x hw x n_classes
+        weight_node = torch.matmul(input1, self.weight)  # n x hw x hidden_layer
+        # softmax fea_node
+        fea_node = F.softmax(fea_node, dim=1)
+        # print(fea_node.size(),weight_node.size())
+        graph_node = F.relu(torch.matmul(fea_node.transpose(1, 2), weight_node))
+        return graph_node  # n x n_class x hidden_layer
+
+    def pre_fea_learn(self, input):
+        pre_fea = self.pre_fea_transfer.forward(input.unsqueeze(0)).squeeze(0)
+        return self.pre_fea.data + pre_fea
+
+
+class Graph_to_Featuremaps(nn.Module):
+    # this is a special version
+    def __init__(self, input_channels, output_channels, hidden_layers, nodes=7):
+        super(Graph_to_Featuremaps, self).__init__()
+        self.node_fea = Parameter(torch.FloatTensor(input_channels + hidden_layers, 1))
+        self.weight = Parameter(torch.FloatTensor(hidden_layers, output_channels))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for ww in self.parameters():
+            torch.nn.init.xavier_uniform_(ww)
+
+    def forward(self, input, res_feature):
+        """
+
+        :param input: 1 x batch x nodes x hidden_layer
+        :param res_feature: batch x channels x h x w
+        :return:
+        """
+        batchi, channeli, hi, wi = res_feature.size()
+        # print(res_feature.size())
+        # print(input.size())
+        try:
+            _, batch, nodes, hidden = input.size()
+        except:
+            # print(input.size())
+            input = input.unsqueeze(0)
+            _, batch, nodes, hidden = input.size()
+
+        assert batch == batchi
+        input1 = input.transpose(0, 1).expand(batch, hi * wi, nodes, hidden)
+        res_feature_after_view = res_feature.view(batch, channeli, hi * wi).transpose(
+            1, 2
+        )
+        res_feature_after_view1 = res_feature_after_view.unsqueeze(2).expand(
+            batch, hi * wi, nodes, channeli
+        )
+        new_fea = torch.cat((res_feature_after_view1, input1), dim=3)
+
+        # print(self.node_fea.size(),new_fea.size())
+        new_node = torch.matmul(new_fea, self.node_fea)  # batch x hw x nodes x 1
+        new_weight = torch.matmul(input, self.weight)  # batch x node x channel
+        new_node = new_node.view(batch, hi * wi, nodes)
+        # 0721
+        new_node = F.softmax(new_node, dim=-1)
+        #
+        feature_out = torch.matmul(new_node, new_weight)
+        # print(feature_out.size())
+        feature_out = feature_out.transpose(2, 3).contiguous().view(res_feature.size())
+        return F.relu(feature_out)
+
+
+class Graph_to_Featuremaps_savemem(nn.Module):
+    # this is a special version for saving gpu memory. The process is same as Graph_to_Featuremaps.
+    def __init__(self, input_channels, output_channels, hidden_layers, nodes=7):
+        super(Graph_to_Featuremaps_savemem, self).__init__()
+        self.node_fea_for_res = Parameter(torch.FloatTensor(input_channels, 1))
+        self.node_fea_for_hidden = Parameter(torch.FloatTensor(hidden_layers, 1))
+        self.weight = Parameter(torch.FloatTensor(hidden_layers, output_channels))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for ww in self.parameters():
+            torch.nn.init.xavier_uniform_(ww)
+
+    def forward(self, input, res_feature):
+        """
+
+        :param input: 1 x batch x nodes x hidden_layer
+        :param res_feature: batch x channels x h x w
+        :return:
+        """
+        batchi, channeli, hi, wi = res_feature.size()
+        # print(res_feature.size())
+        # print(input.size())
+        try:
+            _, batch, nodes, hidden = input.size()
+        except:
+            # print(input.size())
+            input = input.unsqueeze(0)
+            _, batch, nodes, hidden = input.size()
+
+        assert batch == batchi
+        input1 = input.transpose(0, 1).expand(batch, hi * wi, nodes, hidden)
+        res_feature_after_view = res_feature.view(batch, channeli, hi * wi).transpose(
+            1, 2
+        )
+        res_feature_after_view1 = res_feature_after_view.unsqueeze(2).expand(
+            batch, hi * wi, nodes, channeli
+        )
+        # new_fea = torch.cat((res_feature_after_view1,input1),dim=3)
+        ## sim
+        new_node1 = torch.matmul(res_feature_after_view1, self.node_fea_for_res)
+        new_node2 = torch.matmul(input1, self.node_fea_for_hidden)
+        new_node = new_node1 + new_node2
+        ## sim end
+        # print(self.node_fea.size(),new_fea.size())
+        # new_node = torch.matmul(new_fea, self.node_fea) # batch x hw x nodes x 1
+        new_weight = torch.matmul(input, self.weight)  # batch x node x channel
+        new_node = new_node.view(batch, hi * wi, nodes)
+        # 0721
+        new_node = F.softmax(new_node, dim=-1)
+        #
+        feature_out = torch.matmul(new_node, new_weight)
+        # print(feature_out.size())
+        feature_out = feature_out.transpose(2, 3).contiguous().view(res_feature.size())
+        return F.relu(feature_out)
+
+
+class Graph_trans(nn.Module):
+    def __init__(
+        self,
+        in_features,
+        out_features,
+        begin_nodes=7,
+        end_nodes=2,
+        bias=False,
+        adj=None,
+    ):
+        super(Graph_trans, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = Parameter(torch.FloatTensor(in_features, out_features))
+        if adj is not None:
+            h, w = adj.size()
+            assert (h == end_nodes) and (w == begin_nodes)
+            self.adj = torch.autograd.Variable(adj, requires_grad=False)
+        else:
+            self.adj = Parameter(torch.FloatTensor(end_nodes, begin_nodes))
+        if bias:
+            self.bias = Parameter(torch.FloatTensor(out_features))
+        else:
+            self.register_parameter("bias", None)
+        # self.reset_parameters()
+
+    def reset_parameters(self):
+        # stdv = 1./math.sqrt(self.weight(1))
+        # self.weight.data.uniform_(-stdv,stdv)
+        torch.nn.init.xavier_uniform_(self.weight)
+        # if self.bias is not None:
+        #     self.bias.data.uniform_(-stdv,stdv)
+
+    def forward(self, input, relu=False, adj_return=False, adj=None):
+        support = torch.matmul(input, self.weight)
+        # print(support.size(),self.adj.size())
+        if adj is None:
+            adj = self.adj
+        adj1 = self.norm_trans_adj(adj)
+        output = torch.matmul(adj1, support)
+        if adj_return:
+            output1 = F.normalize(output, p=2, dim=-1)
+            self.adj_mat = torch.matmul(output1, output1.transpose(-2, -1))
+        if self.bias is not None:
+            return output + self.bias
+        else:
+            if relu:
+                return F.relu(output)
+            else:
+                return output
+
+    def get_adj_mat(self):
+        adj = graph.normalize_adj_torch(F.relu(self.adj_mat))
+        return adj
+
+    def get_encode_adj(self):
+        return self.adj
+
+    def norm_trans_adj(self, adj):  # maybe can use softmax
+        adj = F.relu(adj)
+        r = F.softmax(adj, dim=-1)
+        # print(adj.size())
+        # row_sum = adj.sum(-1).unsqueeze(-1)
+        # d_mat = row_sum.expand(adj.size())
+        # r = torch.div(row_sum,d_mat)
+        # r[torch.isnan(r)] = 0
+
+        return r
+
+
+if __name__ == "__main__":
+
+    graph = torch.randn((7, 128))
+    en = GraphConvolution(128, 128)
+    a = en.forward(graph)
+    print(a)
+    # a = en.forward(graph,pred)
+    # print(a.size())
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/graph.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/graph.py
new file mode 100644
index 0000000..06c04e5
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/graph.py
@@ -0,0 +1,839 @@
+import torch
+import numpy as np
+import networkx as nx
+import scipy.sparse as sp
+
+pascal_graph = {
+    0: [0],
+    1: [1, 2],
+    2: [1, 2, 3, 5],
+    3: [2, 3, 4],
+    4: [3, 4],
+    5: [2, 5, 6],
+    6: [5, 6],
+}
+
+cihp_graph = {
+    0: [],
+    1: [2, 13],
+    2: [1, 13],
+    3: [14, 15],
+    4: [13],
+    5: [6, 7, 9, 10, 11, 12, 14, 15],
+    6: [5, 7, 10, 11, 14, 15, 16, 17],
+    7: [5, 6, 9, 10, 11, 12, 14, 15],
+    8: [16, 17, 18, 19],
+    9: [5, 7, 10, 16, 17, 18, 19],
+    10: [5, 6, 7, 9, 11, 12, 13, 14, 15, 16, 17],
+    11: [5, 6, 7, 10, 13],
+    12: [5, 7, 10, 16, 17],
+    13: [1, 2, 4, 10, 11],
+    14: [3, 5, 6, 7, 10],
+    15: [3, 5, 6, 7, 10],
+    16: [6, 8, 9, 10, 12, 18],
+    17: [6, 8, 9, 10, 12, 19],
+    18: [8, 9, 16],
+    19: [8, 9, 17],
+}
+
+atr_graph = {
+    0: [],
+    1: [2, 11],
+    2: [1, 11],
+    3: [11],
+    4: [5, 6, 7, 11, 14, 15, 17],
+    5: [4, 6, 7, 8, 12, 13],
+    6: [4, 5, 7, 8, 9, 10, 12, 13],
+    7: [4, 11, 12, 13, 14, 15],
+    8: [5, 6],
+    9: [6, 12],
+    10: [6, 13],
+    11: [1, 2, 3, 4, 7, 14, 15, 17],
+    12: [5, 6, 7, 9],
+    13: [5, 6, 7, 10],
+    14: [4, 7, 11, 16],
+    15: [4, 7, 11, 16],
+    16: [14, 15],
+    17: [4, 11],
+}
+
+cihp2pascal_adj = np.array(
+    [
+        [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+        [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1],
+    ]
+)
+
+cihp2pascal_nlp_adj = np.array(
+    [
+        [
+            1.0,
+            0.35333052,
+            0.32727194,
+            0.17418084,
+            0.18757584,
+            0.40608522,
+            0.37503981,
+            0.35448462,
+            0.22598555,
+            0.23893579,
+            0.33064262,
+            0.28923404,
+            0.27986573,
+            0.4211553,
+            0.36915778,
+            0.41377746,
+            0.32485771,
+            0.37248222,
+            0.36865639,
+            0.41500332,
+        ],
+        [
+            0.39615879,
+            0.46201529,
+            0.52321467,
+            0.30826114,
+            0.25669527,
+            0.54747773,
+            0.3670523,
+            0.3901983,
+            0.27519473,
+            0.3433325,
+            0.52728509,
+            0.32771333,
+            0.34819325,
+            0.63882953,
+            0.68042925,
+            0.69368576,
+            0.63395791,
+            0.65344337,
+            0.59538781,
+            0.6071375,
+        ],
+        [
+            0.16373166,
+            0.21663339,
+            0.3053872,
+            0.28377612,
+            0.1372435,
+            0.4448808,
+            0.29479995,
+            0.31092595,
+            0.22703953,
+            0.33983576,
+            0.75778818,
+            0.2619818,
+            0.37069392,
+            0.35184867,
+            0.49877512,
+            0.49979437,
+            0.51853277,
+            0.52517541,
+            0.32517741,
+            0.32377309,
+        ],
+        [
+            0.32687232,
+            0.38482461,
+            0.37693463,
+            0.41610834,
+            0.20415749,
+            0.76749079,
+            0.35139853,
+            0.3787411,
+            0.28411737,
+            0.35155421,
+            0.58792618,
+            0.31141718,
+            0.40585111,
+            0.51189218,
+            0.82042737,
+            0.8342413,
+            0.70732188,
+            0.72752501,
+            0.60327325,
+            0.61431337,
+        ],
+        [
+            0.34069369,
+            0.34817292,
+            0.37525998,
+            0.36497069,
+            0.17841617,
+            0.69746208,
+            0.31731463,
+            0.34628951,
+            0.25167277,
+            0.32072379,
+            0.56711286,
+            0.24894776,
+            0.37000453,
+            0.52600859,
+            0.82483993,
+            0.84966274,
+            0.7033991,
+            0.73449378,
+            0.56649608,
+            0.58888791,
+        ],
+        [
+            0.28477487,
+            0.35139564,
+            0.42742352,
+            0.41664321,
+            0.20004676,
+            0.78566833,
+            0.42237487,
+            0.41048549,
+            0.37933812,
+            0.46542516,
+            0.62444759,
+            0.3274493,
+            0.49466009,
+            0.49314658,
+            0.71244233,
+            0.71497003,
+            0.8234787,
+            0.83566589,
+            0.62597135,
+            0.62626812,
+        ],
+        [
+            0.3011378,
+            0.31775977,
+            0.42922647,
+            0.36896257,
+            0.17597556,
+            0.72214655,
+            0.39162804,
+            0.38137872,
+            0.34980296,
+            0.43818419,
+            0.60879174,
+            0.26762545,
+            0.46271161,
+            0.51150476,
+            0.72318109,
+            0.73678399,
+            0.82620388,
+            0.84942166,
+            0.5943811,
+            0.60607602,
+        ],
+    ]
+)
+
+pascal2atr_nlp_adj = np.array(
+    [
+        [
+            1.0,
+            0.35333052,
+            0.32727194,
+            0.18757584,
+            0.40608522,
+            0.27986573,
+            0.23893579,
+            0.27600672,
+            0.30964391,
+            0.36865639,
+            0.41500332,
+            0.4211553,
+            0.32485771,
+            0.37248222,
+            0.36915778,
+            0.41377746,
+            0.32006291,
+            0.28923404,
+        ],
+        [
+            0.39615879,
+            0.46201529,
+            0.52321467,
+            0.25669527,
+            0.54747773,
+            0.34819325,
+            0.3433325,
+            0.26603942,
+            0.45162929,
+            0.59538781,
+            0.6071375,
+            0.63882953,
+            0.63395791,
+            0.65344337,
+            0.68042925,
+            0.69368576,
+            0.44354613,
+            0.32771333,
+        ],
+        [
+            0.16373166,
+            0.21663339,
+            0.3053872,
+            0.1372435,
+            0.4448808,
+            0.37069392,
+            0.33983576,
+            0.26563416,
+            0.35443504,
+            0.32517741,
+            0.32377309,
+            0.35184867,
+            0.51853277,
+            0.52517541,
+            0.49877512,
+            0.49979437,
+            0.21750868,
+            0.2619818,
+        ],
+        [
+            0.32687232,
+            0.38482461,
+            0.37693463,
+            0.20415749,
+            0.76749079,
+            0.40585111,
+            0.35155421,
+            0.28271333,
+            0.52684576,
+            0.60327325,
+            0.61431337,
+            0.51189218,
+            0.70732188,
+            0.72752501,
+            0.82042737,
+            0.8342413,
+            0.40137029,
+            0.31141718,
+        ],
+        [
+            0.34069369,
+            0.34817292,
+            0.37525998,
+            0.17841617,
+            0.69746208,
+            0.37000453,
+            0.32072379,
+            0.27268885,
+            0.47426719,
+            0.56649608,
+            0.58888791,
+            0.52600859,
+            0.7033991,
+            0.73449378,
+            0.82483993,
+            0.84966274,
+            0.37830796,
+            0.24894776,
+        ],
+        [
+            0.28477487,
+            0.35139564,
+            0.42742352,
+            0.20004676,
+            0.78566833,
+            0.49466009,
+            0.46542516,
+            0.32662614,
+            0.55780359,
+            0.62597135,
+            0.62626812,
+            0.49314658,
+            0.8234787,
+            0.83566589,
+            0.71244233,
+            0.71497003,
+            0.41223219,
+            0.3274493,
+        ],
+        [
+            0.3011378,
+            0.31775977,
+            0.42922647,
+            0.17597556,
+            0.72214655,
+            0.46271161,
+            0.43818419,
+            0.3192333,
+            0.50979216,
+            0.5943811,
+            0.60607602,
+            0.51150476,
+            0.82620388,
+            0.84942166,
+            0.72318109,
+            0.73678399,
+            0.39259827,
+            0.26762545,
+        ],
+    ]
+)
+
+cihp2atr_nlp_adj = np.array(
+    [
+        [
+            1.0,
+            0.35333052,
+            0.32727194,
+            0.18757584,
+            0.40608522,
+            0.27986573,
+            0.23893579,
+            0.27600672,
+            0.30964391,
+            0.36865639,
+            0.41500332,
+            0.4211553,
+            0.32485771,
+            0.37248222,
+            0.36915778,
+            0.41377746,
+            0.32006291,
+            0.28923404,
+        ],
+        [
+            0.35333052,
+            1.0,
+            0.39206695,
+            0.42143438,
+            0.4736689,
+            0.47139544,
+            0.51999208,
+            0.38354847,
+            0.45628529,
+            0.46514124,
+            0.50083501,
+            0.4310595,
+            0.39371443,
+            0.4319752,
+            0.42938598,
+            0.46384034,
+            0.44833757,
+            0.6153155,
+        ],
+        [
+            0.32727194,
+            0.39206695,
+            1.0,
+            0.32836702,
+            0.52603065,
+            0.39543695,
+            0.3622627,
+            0.43575346,
+            0.33866223,
+            0.45202552,
+            0.48421,
+            0.53669903,
+            0.47266611,
+            0.50925436,
+            0.42286557,
+            0.45403656,
+            0.37221304,
+            0.40999322,
+        ],
+        [
+            0.17418084,
+            0.46892601,
+            0.25774838,
+            0.31816231,
+            0.39330317,
+            0.34218382,
+            0.48253904,
+            0.22084125,
+            0.41335728,
+            0.52437572,
+            0.5191713,
+            0.33576117,
+            0.44230914,
+            0.44250678,
+            0.44330833,
+            0.43887264,
+            0.50693611,
+            0.39278795,
+        ],
+        [
+            0.18757584,
+            0.42143438,
+            0.32836702,
+            1.0,
+            0.35030067,
+            0.30110947,
+            0.41055555,
+            0.34338879,
+            0.34336307,
+            0.37704433,
+            0.38810141,
+            0.34702081,
+            0.24171562,
+            0.25433078,
+            0.24696241,
+            0.2570884,
+            0.4465962,
+            0.45263213,
+        ],
+        [
+            0.40608522,
+            0.4736689,
+            0.52603065,
+            0.35030067,
+            1.0,
+            0.54372584,
+            0.58300258,
+            0.56674191,
+            0.555266,
+            0.66599594,
+            0.68567555,
+            0.55716359,
+            0.62997328,
+            0.65638548,
+            0.61219615,
+            0.63183318,
+            0.54464151,
+            0.44293752,
+        ],
+        [
+            0.37503981,
+            0.50675565,
+            0.4761106,
+            0.37561813,
+            0.60419403,
+            0.77912403,
+            0.64595517,
+            0.85939662,
+            0.46037144,
+            0.52348817,
+            0.55875094,
+            0.37741886,
+            0.455671,
+            0.49434392,
+            0.38479954,
+            0.41804074,
+            0.47285709,
+            0.57236283,
+        ],
+        [
+            0.35448462,
+            0.50576632,
+            0.51030446,
+            0.35841033,
+            0.55106903,
+            0.50257274,
+            0.52591451,
+            0.4283053,
+            0.39991808,
+            0.42327211,
+            0.42853819,
+            0.42071825,
+            0.41240559,
+            0.42259136,
+            0.38125352,
+            0.3868255,
+            0.47604934,
+            0.51811717,
+        ],
+        [
+            0.22598555,
+            0.5053299,
+            0.36301185,
+            0.38002282,
+            0.49700941,
+            0.45625243,
+            0.62876479,
+            0.4112051,
+            0.33944371,
+            0.48322639,
+            0.50318714,
+            0.29207815,
+            0.38801966,
+            0.41119094,
+            0.29199072,
+            0.31021029,
+            0.41594871,
+            0.54961962,
+        ],
+        [
+            0.23893579,
+            0.51999208,
+            0.3622627,
+            0.41055555,
+            0.58300258,
+            0.68874251,
+            1.0,
+            0.56977937,
+            0.49918447,
+            0.48484363,
+            0.51615925,
+            0.41222306,
+            0.49535971,
+            0.53134951,
+            0.3807616,
+            0.41050298,
+            0.48675801,
+            0.51112664,
+        ],
+        [
+            0.33064262,
+            0.306412,
+            0.60679935,
+            0.25592294,
+            0.58738706,
+            0.40379627,
+            0.39679161,
+            0.33618385,
+            0.39235148,
+            0.45474013,
+            0.4648476,
+            0.59306762,
+            0.58976007,
+            0.60778661,
+            0.55400397,
+            0.56551297,
+            0.3698029,
+            0.33860535,
+        ],
+        [
+            0.28923404,
+            0.6153155,
+            0.40999322,
+            0.45263213,
+            0.44293752,
+            0.60359359,
+            0.51112664,
+            0.46578181,
+            0.45656936,
+            0.38142307,
+            0.38525582,
+            0.33327223,
+            0.35360175,
+            0.36156453,
+            0.3384992,
+            0.34261229,
+            0.49297863,
+            1.0,
+        ],
+        [
+            0.27986573,
+            0.47139544,
+            0.39543695,
+            0.30110947,
+            0.54372584,
+            1.0,
+            0.68874251,
+            0.67765588,
+            0.48690078,
+            0.44010641,
+            0.44921156,
+            0.32321099,
+            0.48311542,
+            0.4982002,
+            0.39378102,
+            0.40297733,
+            0.45309735,
+            0.60359359,
+        ],
+        [
+            0.4211553,
+            0.4310595,
+            0.53669903,
+            0.34702081,
+            0.55716359,
+            0.32321099,
+            0.41222306,
+            0.25721705,
+            0.36633509,
+            0.5397475,
+            0.56429928,
+            1.0,
+            0.55796926,
+            0.58842844,
+            0.57930828,
+            0.60410597,
+            0.41615326,
+            0.33327223,
+        ],
+        [
+            0.36915778,
+            0.42938598,
+            0.42286557,
+            0.24696241,
+            0.61219615,
+            0.39378102,
+            0.3807616,
+            0.28089866,
+            0.48450394,
+            0.77400821,
+            0.68813814,
+            0.57930828,
+            0.8856886,
+            0.81673412,
+            1.0,
+            0.92279623,
+            0.46969152,
+            0.3384992,
+        ],
+        [
+            0.41377746,
+            0.46384034,
+            0.45403656,
+            0.2570884,
+            0.63183318,
+            0.40297733,
+            0.41050298,
+            0.332879,
+            0.48799542,
+            0.69231828,
+            0.77015091,
+            0.60410597,
+            0.79788484,
+            0.88232104,
+            0.92279623,
+            1.0,
+            0.45685017,
+            0.34261229,
+        ],
+        [
+            0.32485771,
+            0.39371443,
+            0.47266611,
+            0.24171562,
+            0.62997328,
+            0.48311542,
+            0.49535971,
+            0.32477932,
+            0.51486622,
+            0.79353556,
+            0.69768738,
+            0.55796926,
+            1.0,
+            0.92373745,
+            0.8856886,
+            0.79788484,
+            0.47883134,
+            0.35360175,
+        ],
+        [
+            0.37248222,
+            0.4319752,
+            0.50925436,
+            0.25433078,
+            0.65638548,
+            0.4982002,
+            0.53134951,
+            0.38057074,
+            0.52403969,
+            0.72035243,
+            0.78711147,
+            0.58842844,
+            0.92373745,
+            1.0,
+            0.81673412,
+            0.88232104,
+            0.47109935,
+            0.36156453,
+        ],
+        [
+            0.36865639,
+            0.46514124,
+            0.45202552,
+            0.37704433,
+            0.66599594,
+            0.44010641,
+            0.48484363,
+            0.39636574,
+            0.50175258,
+            1.0,
+            0.91320249,
+            0.5397475,
+            0.79353556,
+            0.72035243,
+            0.77400821,
+            0.69231828,
+            0.59087008,
+            0.38142307,
+        ],
+        [
+            0.41500332,
+            0.50083501,
+            0.48421,
+            0.38810141,
+            0.68567555,
+            0.44921156,
+            0.51615925,
+            0.45156472,
+            0.50438158,
+            0.91320249,
+            1.0,
+            0.56429928,
+            0.69768738,
+            0.78711147,
+            0.68813814,
+            0.77015091,
+            0.57698754,
+            0.38525582,
+        ],
+    ]
+)
+
+
+def normalize_adj(adj):
+    """Symmetrically normalize adjacency matrix."""
+    adj = sp.coo_matrix(adj)
+    rowsum = np.array(adj.sum(1))
+    d_inv_sqrt = np.power(rowsum, -0.5).flatten()
+    d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.0
+    d_mat_inv_sqrt = sp.diags(d_inv_sqrt)
+    return adj.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt).tocoo()
+
+
+def preprocess_adj(adj):
+    """Preprocessing of adjacency matrix for simple GCN model and conversion to tuple representation."""
+    adj = nx.adjacency_matrix(
+        nx.from_dict_of_lists(adj)
+    )  # return a adjacency matrix of adj ( type is numpy)
+    adj_normalized = normalize_adj(adj + sp.eye(adj.shape[0]))  #
+    # return sparse_to_tuple(adj_normalized)
+    return adj_normalized.todense()
+
+
+def row_norm(inputs):
+    outputs = []
+    for x in inputs:
+        xsum = x.sum()
+        x = x / xsum
+        outputs.append(x)
+    return outputs
+
+
+def normalize_adj_torch(adj):
+    # print(adj.size())
+    if len(adj.size()) == 4:
+        new_r = torch.zeros(adj.size()).type_as(adj)
+        for i in range(adj.size(1)):
+            adj_item = adj[0, i]
+            rowsum = adj_item.sum(1)
+            d_inv_sqrt = rowsum.pow_(-0.5)
+            d_inv_sqrt[torch.isnan(d_inv_sqrt)] = 0
+            d_mat_inv_sqrt = torch.diag(d_inv_sqrt)
+            r = torch.matmul(torch.matmul(d_mat_inv_sqrt, adj_item), d_mat_inv_sqrt)
+            new_r[0, i, ...] = r
+        return new_r
+    rowsum = adj.sum(1)
+    d_inv_sqrt = rowsum.pow_(-0.5)
+    d_inv_sqrt[torch.isnan(d_inv_sqrt)] = 0
+    d_mat_inv_sqrt = torch.diag(d_inv_sqrt)
+    r = torch.matmul(torch.matmul(d_mat_inv_sqrt, adj), d_mat_inv_sqrt)
+    return r
+
+
+# def row_norm(adj):
+
+
+if __name__ == "__main__":
+    a = row_norm(cihp2pascal_adj)
+    print(a)
+    print(cihp2pascal_adj)
+    # print(a.shape)
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/graphonomy_inference.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/graphonomy_inference.py
new file mode 100644
index 0000000..5e7de24
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/graphonomy_inference.py
@@ -0,0 +1,242 @@
+import cv2
+import torch
+import timeit
+import numpy as np
+from PIL import Image
+import torch.nn.functional as F
+from torch.autograd import Variable
+from torchvision import transforms
+
+
+from FaceHairMask import graph
+from FaceHairMask import graphonomy_process as tr
+
+
+
+label_colours = [(0, 0, 0) for i in range(20)]
+label_colours[2] = (255, 0, 0)
+label_colours[13] = (0, 0, 255)
+
+
+def custom_decode_labels(mask, num_images=1, num_classes=20):
+    """Decode batch of segmentation masks.
+
+    Args:
+      mask: result of inference after taking argmax.
+      num_images: number of images to decode from the batch.
+      num_classes: number of classes to predict (including background).
+
+    Returns:
+      A batch with num_images RGB images of the same size as the input.
+    """
+    n, h, w = mask.shape
+
+    # import ipdb; ipdb.set_trace()
+    assert (
+        n >= num_images
+    ), "Batch size %d should be greater or equal than number of images to save %d." % (
+        n,
+        num_images,
+    )
+
+    hair_mask = torch.where(mask == 2, torch.ones_like(mask), torch.zeros_like(mask))
+
+    face_mask = torch.where(mask == 13, torch.ones_like(mask), torch.zeros_like(mask))
+
+    return hair_mask, face_mask
+
+
+def overlay(frame, mask):
+
+    mask = np.array(mask)
+    frame = np.array(frame)
+
+    tmp = cv2.cvtColor(mask, cv2.COLOR_RGB2GRAY)
+    _, alpha = cv2.threshold(tmp, 0, 255, cv2.THRESH_BINARY)
+    b, g, r = cv2.split(mask)
+    rgba = [b, g, r, alpha]
+    dst = cv2.merge(rgba, 4)
+
+    # overlay mask on frame
+    overlaid_image = cv2.addWeighted(frame, 0.4, dst, 0.1, 0)
+    return overlaid_image
+
+
+def flip(x, dim):
+    indices = [slice(None)] * x.dim()
+    indices[dim] = torch.arange(
+        x.size(dim) - 1, -1, -1, dtype=torch.long, device=x.device
+    )
+    return x[tuple(indices)]
+
+
+def flip_cihp(tail_list):
+    """
+
+    :param tail_list: tail_list size is 1 x n_class x h x w
+    :return:
+    """
+    # tail_list = tail_list[0]
+    tail_list_rev = [None] * 20
+    for xx in range(14):
+        tail_list_rev[xx] = tail_list[xx].unsqueeze(0)
+    tail_list_rev[14] = tail_list[15].unsqueeze(0)
+    tail_list_rev[15] = tail_list[14].unsqueeze(0)
+    tail_list_rev[16] = tail_list[17].unsqueeze(0)
+    tail_list_rev[17] = tail_list[16].unsqueeze(0)
+    tail_list_rev[18] = tail_list[19].unsqueeze(0)
+    tail_list_rev[19] = tail_list[18].unsqueeze(0)
+    return torch.cat(tail_list_rev, dim=0)
+
+
+def decode_labels(mask, num_images=1, num_classes=20):
+    """Decode batch of segmentation masks.
+
+    Args:
+      mask: result of inference after taking argmax.
+      num_images: number of images to decode from the batch.
+      num_classes: number of classes to predict (including background).
+
+    Returns:
+      A batch with num_images RGB images of the same size as the input.
+    """
+    n, h, w = mask.shape
+    assert (
+        n >= num_images
+    ), "Batch size %d should be greater or equal than number of images to save %d." % (
+        n,
+        num_images,
+    )
+    outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)
+    for i in range(num_images):
+        img = Image.new("RGB", (len(mask[i, 0]), len(mask[i])))
+        pixels = img.load()
+        for j_, j in enumerate(mask[i, :, :]):
+            for k_, k in enumerate(j):
+                if k < num_classes:
+                    pixels[k_, j_] = label_colours[k]
+        outputs[i] = np.array(img)
+    return outputs
+
+
+def read_img(img_path):
+    _img = Image.open(img_path).convert("RGB")  # return is RGB pic
+    return _img
+
+
+def img_transform(img, transform=None):
+    sample = {"image": img, "label": 0}
+
+    sample = transform(sample)
+    return sample
+
+
+def inference(net, img=None, device=None):
+    """
+
+    :param net:
+    :return:
+    """
+    # adj
+    adj2_ = torch.from_numpy(graph.cihp2pascal_nlp_adj).float()
+    adj2_test = (
+        adj2_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 20).to(device).transpose(2, 3)
+    )
+
+    adj1_ = Variable(torch.from_numpy(graph.preprocess_adj(graph.pascal_graph)).float())
+    adj3_test = adj1_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 7).to(device)
+
+    cihp_adj = graph.preprocess_adj(graph.cihp_graph)
+    adj3_ = Variable(torch.from_numpy(cihp_adj).float())
+    adj1_test = adj3_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 20).to(device)
+
+    # multi-scale
+    scale_list = [1, 0.5, 0.75, 1.25, 1.5, 1.75]
+    #scale_list = [1, 0.5, 0.75, 1.25]
+    # NOTE: this part of the code assumes img is PIL image in RGB color space
+    # We provide torch tensor in range [-1, 1]
+    # Bring range to [0, 255]
+    img = torch.clamp(img, -1, 1)
+    img = (img + 1.0) / 2.0
+    img *= 255
+
+    testloader_list = []
+    testloader_flip_list = []
+    for pv in scale_list:
+        composed_transforms_ts = transforms.Compose(
+            [
+                tr.Scale_only_img(pv),
+                tr.Normalize_xception_tf_only_img(),
+                tr.ToTensor_only_img(),
+            ]
+        )
+
+        composed_transforms_ts_flip = transforms.Compose(
+            [
+                tr.Scale_only_img(pv),
+                tr.HorizontalFlip_only_img(),
+                tr.Normalize_xception_tf_only_img(),
+                tr.ToTensor_only_img(),
+            ]
+        )
+        # NOTE: img [1, 3, 256, 256], (min, max) = (0, 255)
+
+        # print("original:", img.shape, img.min(), img.max())
+        testloader_list.append(img_transform(img, composed_transforms_ts))
+        # print(img_transform(img, composed_transforms_ts))
+        testloader_flip_list.append(img_transform(img, composed_transforms_ts_flip))
+    # print(testloader_list)
+    start_time = timeit.default_timer()
+    # One testing epoch
+    # net.eval()
+    # 1 0.5 0.75 1.25 1.5 1.75 ; flip:
+
+    # NOTE: testloader_list[0]['image'].shape = 3, 420, 620
+
+    for iii, sample_batched in enumerate(zip(testloader_list, testloader_flip_list)):
+        inputs, labels = sample_batched[0]["image"], sample_batched[0]["label"]
+        inputs_f, _ = sample_batched[1]["image"], sample_batched[1]["label"]
+        inputs = inputs.unsqueeze(0)
+        inputs_f = inputs_f.unsqueeze(0)
+        inputs = torch.cat((inputs, inputs_f), dim=0)
+        if iii == 0:
+            _, _, h, w = inputs.size()
+        # assert inputs.size() == inputs_f.size()
+
+        # Forward pass of the mini-batch
+
+        # TODO: check requires grad functionality
+        # inputs = Variable(inputs, requires_grad=False)
+
+        with torch.no_grad():
+            if device is not None:
+                inputs = inputs.to(device)
+            # outputs = net.forward(inputs)
+            outputs = net.forward(
+                inputs, adj1_test.to(device), adj3_test.to(device), adj2_test.to(device)
+            )
+            outputs = (outputs[0] + flip(flip_cihp(outputs[1]), dim=-1)) / 2
+            outputs = outputs.unsqueeze(0)
+            if iii > 0:
+                outputs = F.upsample(
+                    outputs, size=(h, w), mode="bilinear", align_corners=True
+                )
+                outputs_final = outputs_final + outputs
+            else:
+                outputs_final = outputs.clone()
+    ################ plot pic
+    predictions = torch.max(outputs_final, 1)[1]
+    # results = predictions.cpu().numpy()
+    # vis_res = decode_labels(results)
+    # parsing_im = Image.fromarray(vis_res[0])
+    # return parsing_im
+
+    hair_mask, face_mask = custom_decode_labels(predictions)
+
+    return outputs_final, hair_mask, face_mask
+
+    # parsing_im.save(output_path+'/{}.png'.format(output_name))
+    # cv2.imwrite(output_path+'/{}_gray.png'.format(output_name), results[0, :, :])
+
+    # end_time = timeit.default_timer()
+    # print('time used for the multi-scale image inference' + ' is :' + str(end_time - start_time))
\ No newline at end of file
diff --git a/reconstruction/ostec/external/graphonomy/FaceHairMask/graphonomy_process.py b/reconstruction/ostec/external/graphonomy/FaceHairMask/graphonomy_process.py
new file mode 100644
index 0000000..4d47a0e
--- /dev/null
+++ b/reconstruction/ostec/external/graphonomy/FaceHairMask/graphonomy_process.py
@@ -0,0 +1,54 @@
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+from torchvision import transforms
+
+
+class Scale_only_img(object):
+    def __init__(self, scale):
+        self.scale = scale
+
+    def __call__(self, sample):
+        img = sample["image"]
+        mask = sample["label"]
+        img = F.interpolate(  # NOTE: requires 4D
+            img, scale_factor=self.scale, mode="bilinear"
+        )
+        # print("Scale:", img.shape, img.min(), img.max())
+        # import ipdb; ipdb.set_trace()
+        return {"image": img, "label": mask}
+
+
+class Normalize_xception_tf_only_img(object):
+    def __call__(self, sample):
+        img = sample["image"]
+        img = (img * 2.0) / 255.0 - 1
+        # print("Normalize:", img.shape, img.min(), img.max())
+        # import ipdb; ipdb.set_trace()
+        return {"image": img, "label": sample["label"]}
+
+
+class ToTensor_only_img(object):
+    def __init__(self):
+        self.rgb2bgr = transforms.Lambda(lambda x: x[[2, 1, 0], ...])
+
+    def __call__(self, sample):
+        # sample: N x C x H x W
+        img = sample["image"]
+        img = torch.squeeze(img, axis=0)
+        # sample: C x H x W
+        img = self.rgb2bgr(img)
+        # print("To Tensor:", img.shape, img.min(), img.max())
+        # img = torch.unsqueeze(img, axis=0)
+        # import ipdb; ipdb.set_trace()
+        return {"image": img, "label": sample["label"]}
+
+
+class HorizontalFlip_only_img(object):
+    def __call__(self, sample):
+        img = sample["image"]
+        mask = sample["label"]
+        img = torch.flip(img, [-1])
+        # print("Horizontal:", img.shape, img.min(), img.max())
+        # import ipdb; ipdb.set_trace()
+        return {"image": img, "label": mask}
diff --git a/reconstruction/ostec/run_ostec.py b/reconstruction/ostec/run_ostec.py
index 9219735..623dddc 100644
--- a/reconstruction/ostec/run_ostec.py
+++ b/reconstruction/ostec/run_ostec.py
@@ -15,19 +15,25 @@ import cv2
 import sys
 sys.path.append("external/stylegan2")
 sys.path.append("external/deep3dfacerecon")
+sys.path.append("external/graphonomy")
 from core.operator import Operator
 from core.config import get_config
 import numpy as np
 from utils.utils import im_menpo2PIL
-from external.deep3dfacerecon.ostec_api import Deep3dModel
 from external.face_detector.detect_face import Face_Detector
+from FaceHairMask.MaskExtractor import MaskExtractor
 
 def main(args):
     source_dir = args.source_dir
     save_dir = args.save_dir
+    os.makedirs(save_dir,exist_ok=True)
     operator = Operator(args)
     detector = Face_Detector()
-    deep3dmodel = Deep3dModel()
+    if not args.ganfit:
+        from external.deep3dfacerecon.ostec_api import Deep3dModel
+        deep3dmodel = Deep3dModel()
+    maskExtractor = MaskExtractor()
+
 
     # while True:
     for ext in ['.png', '.jpg']:
@@ -38,12 +44,15 @@ def main(args):
             # try: # To avoid detection errors on large datasets
             save_path = path.replace(source_dir, save_dir)
             pkl_path = path.replace(ext,'.pkl')
-            if not os.path.isfile(save_path.replace(ext, '_uv.'+ext)):
+            if not os.path.isfile(save_path.replace(ext, '.png')):
                 print('Started: ' + path)
                 start = time.time()
-                #img = mio.import_image(path)
+
                 img = menpo.image.Image(np.transpose(cv2.imread(path)[:,:,::-1],[2,0,1])/255.0)
 
+                if args.ganfit and not os.path.isfile(pkl_path):
+                    raise Exception('Reconstruction from GANfit mode is activated and no GANFit reconstruction pickle file has been found! Either Remove --ganfit flag or Run GANFit first.')
+
                 if os.path.isfile(pkl_path): # GANFit mode
                     fitting = mio.import_pickle(pkl_path)
 
@@ -52,10 +61,12 @@ def main(args):
                     fitting = deep3dmodel.recontruct(im_menpo2PIL(img), lms)
                     img = menpo.image.Image(fitting['input'])
 
-                final_uv, results_dict = operator.run(img, fitting)
-                mio.export_image(final_uv, save_path.replace(ext,'_uv'+ext))
+                _, face_mask = maskExtractor.main(img)
+
+                final_uv, results_dict = operator.run(img, fitting, face_mask)
+                mio.export_image(final_uv, save_path.replace(ext, '.png'))
                 if args.frontalize:
-                    mio.export_image(results_dict['frontal'], save_path.replace(ext,'_frontal'+ext))
+                    mio.export_image(results_dict['frontal'], save_path.replace(ext,'_frontal.png'))
                 if args.pickle:
                     mio.export_pickle(results_dict, save_path.replace(ext,'.pkl'))