blinklinmult 1.0.0__py3-none-any.whl

blinklinmult/__init__.py

@@ -0,0 +1,12 @@
+import toml
+from os import PathLike
+from pathlib import Path
+
+# Module level constants
+PROJECT_ROOT = Path(__file__).parents[1]
+WEIGHTS_DIR = Path().home() / '.cache' / 'torch' / 'hub' / 'checkpoints' / 'blink'
+
+__version__ = toml.load(PROJECT_ROOT / 'pyproject.toml')['project']['version']
+
+# Type aliases
+PathType = str | PathLike

blinklinmult/models/BlinkLinMulT.py

@@ -0,0 +1,164 @@
+from abc import abstractmethod
+from pathlib import Path
+import logging
+import torch
+import torch.nn as nn
+from torchvision import models, transforms
+from linmult import LinMulT, LinT
+from exordium.utils.ckpt import download_file
+from blinklinmult import PathType, WEIGHTS_DIR
+
+
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s %(levelname)s %(message)s",
+                    datefmt="%Y-%m-%d %H:%M:%S")
+
+
+PRETRAINED_WEIGHTS = {
+    'densenet121-union': 'https://github.com/fodorad/LinMulT/releases/download/v1.0.0/densenet121-union-64.pt',
+    'blinklint-union': 'https://github.com/fodorad/LinMulT/releases/download/v1.0.0/densenetlint-union-64.pt',
+    'blinklinmult-union': 'https://github.com/fodorad/LinMulT/releases/download/v1.0.0/blinklinmult-union.pt'
+}
+
+
+preprocess_eye_fcn = transforms.Compose([
+        transforms.ToPILImage(),
+        transforms.Resize((64, 64), transforms.InterpolationMode.BICUBIC),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
+
+
+class AbstractModule(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        self.features = nn.Identity()
+        self.classifier = nn.Identity()
+
+    @staticmethod
+    def _init_weights(modules):
+        for m in modules:
+            if isinstance(m, (nn.Linear, nn.LazyLinear)):
+                nn.init.kaiming_uniform_(m.weight, mode="fan_in", nonlinearity="relu")
+                nn.init.zeros_(m.bias)
+
+    def freeze_feature_extractor(self):
+        for layer in self.features.parameters():
+            layer.requires_grad = False
+
+    def unfreeze_feature_extractor(self):
+        for layer in self.features.parameters():
+            layer.requires_grad = True
+
+    def forward(self, x):
+        x = self.features(x)
+        x = self.classifier(x)
+        return x
+
+    def load_weights(self, weights_path: PathType) -> None:
+        local_path = Path(weights_path)
+
+        if local_path.name in PRETRAINED_WEIGHTS.keys():
+            remote_path = PRETRAINED_WEIGHTS[local_path.name]
+            local_path = WEIGHTS_DIR / Path(remote_path).name
+            download_file(remote_path, local_path)
+
+        state_dict = torch.load(str(local_path), map_location="cpu")
+        self.load_state_dict(state_dict)
+        logging.info(f'Weights are loaded from {local_path}')
+
+
+class DenseNet121(AbstractModule):
+
+    def __init__(self, output_dim: int = 1,
+                       weights: PathType | None = 'densenet121-union',
+                       freeze: bool = False):
+        super().__init__()
+        densenet121 = models.densenet121(weights=models.DenseNet121_Weights.DEFAULT)
+        features = [module for module in densenet121.features]
+        features.append(nn.ReLU(inplace=True))
+        features.append(nn.AdaptiveAvgPool2d(output_size=(1, 1)))
+        features.append(nn.Flatten())
+        self.features = nn.Sequential(*features)
+
+        self.classifier = nn.Sequential(
+            nn.LazyLinear(512),
+            nn.BatchNorm1d(512, momentum=0.999, eps=1e-3),
+            nn.GELU(),
+            nn.Dropout(p=0.6),
+            nn.Linear(512, output_dim),
+        )
+
+        if freeze:
+            self.freeze_feature_extractor()
+
+        if weights is not None:
+            self.load_weights(weights)
+
+
+class BlinkLinMulT(AbstractModule):
+
+    def __init__(self, input_dim: int = 160,
+                       output_dim: int = 1,
+                       weights: PathType | None = 'blinklinmult-union',
+                       weights_backbone: PathType | None = 'densenet121-union',
+                       **kwargs):
+        super().__init__()
+        self.img_backbone = DenseNet121(output_dim=output_dim, weights=weights_backbone)
+        self.img_backbone = self.img_backbone.features
+        logging.info(self.img_backbone)
+
+        self.rnn_backbone = LinMulT(
+            input_modality_channels=[1024, input_dim],
+            output_dim=output_dim,
+            projected_modality_dim=32,
+            number_of_layers=5,
+            add_projection_fusion=False,
+            aggregation='meanpooling',
+            **kwargs,
+        )
+        logging.info(self.rnn_backbone)
+
+        if weights is not None:
+            self.load_weights(weights)
+
+    def forward(self, x):
+        time_dim = x[0].size(1)
+        rgb_texture = x[0] # (B, L, C, H, W)
+        high_level_features = x[1] # (B, L, C)
+
+        eyes_x = []
+        for t in range(time_dim):
+            eyes_x.append(torch.flatten(self.img_backbone(rgb_texture[:, t, :, :, :]), 1))
+
+        x0 = torch.stack(eyes_x, dim=1)
+        x_seq = self.rnn_backbone([x0, high_level_features])
+        return x_seq
+
+
+class BlinkLinT(AbstractModule):
+
+    def __init__(self, output_dim: int = 1,
+                       weights: str | Path | None = 'blinklint-union'):
+        super().__init__()
+        self.img_backbone = DenseNet121(output_dim=output_dim, weights='densenet121-union')
+        self.img_backbone = self.img_backbone.features
+        self.rnn_backbone = LinT(1024, projected_modality_dim=32, number_of_layers=5, output_dim=output_dim)
+
+        logging.info(self.img_backbone)
+        logging.info(self.rnn_backbone)
+
+        if weights is not None:
+            self.load_weights(weights)
+
+    def forward(self, rgb_texture):
+        time_dim = rgb_texture.size(1) # (B, L, C, H, W)
+
+        eyes_x = []
+        for t in range(time_dim):
+            eyes_x.append(torch.flatten(self.img_backbone(rgb_texture[:, t, :, :, :]), 1))
+
+        x0 = torch.stack(eyes_x, dim=1)
+        x_seq = self.rnn_backbone(x0)
+        return x_seq

blinklinmult/models/__init__.py

@@ -0,0 +1,23 @@
+from .BlinkLinMulT import (AbstractModule,
+                           DenseNet121,
+                           BlinkLinT,
+                           LinT,
+                           BlinkLinMulT,
+                           preprocess_eye_fcn)
+
+from .backbone import (EyeNet,
+                       ResNet50,
+                       Dense)
+
+SEQUENCE_MODELS = {
+    "lint": LinT,
+    "blinklint": BlinkLinT,
+    "blinklinmult": BlinkLinMulT,
+}
+
+BACKBONE_MODELS = {
+    "dense": Dense,
+    "eyenet": EyeNet,
+    "resnet50": ResNet50,
+    "densenet121": DenseNet121
+}

blinklinmult/models/backbone.py

@@ -0,0 +1,94 @@
+import torch.nn as nn
+from torchvision import models
+from blinklinmult.models import AbstractModule
+
+
+class Dense(AbstractModule):
+
+    def __init__(self, input_dim: int, output_dim: int = 1):
+        super().__init__()
+        self.features = nn.Identity()
+        self.classifier = nn.Sequential(
+            nn.Linear(input_dim, 128),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.6),
+            nn.Linear(128, output_dim),
+        )
+
+
+class EyeNet(AbstractModule):
+    """EyeNet: An Improved Eye States Classification System using Convolutional Neural Network (2020)
+
+    Paper: https://www.researchgate.net/publication/340757067
+    """
+    def __init__(self, output_dim: int = 1, freeze: bool = False):
+        super().__init__()
+
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 32, 5, bias=False),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.Conv2d(32, 64, 5, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.Conv2d(64, 128, 3, bias=False),
+            nn.BatchNorm2d(128),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(128, 256, 3, bias=False),
+            nn.BatchNorm2d(256),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(256, 384, 3, bias=False),
+            nn.BatchNorm2d(384),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+            nn.Conv2d(384, 512, 3, bias=False),
+            nn.BatchNorm2d(512),
+            nn.ReLU(),
+            nn.AdaptiveAvgPool2d((1, 1)),
+            nn.Flatten(),
+        )
+
+        self.classifier = nn.Sequential(
+            nn.LazyLinear(84),
+            nn.ReLU(),
+            nn.Dropout(0.25),
+            nn.Linear(84, 32),
+            nn.ReLU(),
+            nn.Linear(32, output_dim),
+        )
+
+        if freeze:
+            self.freeze_feature_extractor()
+
+
+class ResNet50(AbstractModule):
+
+    def __init__(self, output_dim: int = 1, freeze: bool = False):
+        super().__init__()
+
+        resnet50 = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
+        self.features = nn.Sequential(
+            resnet50.conv1,
+            resnet50.bn1,
+            resnet50.relu,
+            resnet50.maxpool,
+            resnet50.layer1,
+            resnet50.layer2,
+            resnet50.layer3,
+            resnet50.layer4,
+            resnet50.avgpool,
+            nn.Flatten(),
+        )
+
+        self.classifier = nn.Sequential(
+            nn.LazyLinear(512),
+            nn.BatchNorm1d(512, momentum=0.999, eps=1e-3),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.6),
+            nn.Linear(512, output_dim),
+        )
+
+        if freeze:
+            self.freeze_feature_extractor()

blinklinmult/models/clip_wrapper.py

@@ -0,0 +1,37 @@
+import torch
+from torch import nn
+import clip
+from blinklinmult.models.backbone import AbstractModule
+
+
+class CLIP(AbstractModule):
+
+    def __init__(self, backbone: str = "ViT-B/32",
+                       output_dim: int = 1,
+                       freeze: bool = False):
+        super().__init__()
+
+        model, preprocess = clip.load(backbone, jit=False, device=torch.device("cpu"))
+
+        self.preprocess = preprocess
+        self.features = model.visual
+
+        self.classifier = nn.Sequential(
+            nn.LazyLinear(512),
+            nn.BatchNorm1d(512, momentum=0.999, eps=1e-3),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.6),
+            nn.Linear(512, output_dim),
+        )
+
+        if freeze:
+            self.freeze_feature_extractor()
+
+
+if __name__ == '__main__':
+
+    x = torch.zeros((32, 3, 224, 224)).to("cuda:0")
+    for backbone in ["RN50", "ViT-B/32", "ViT-L/14"]:
+        model = CLIP(backbone=backbone).to("cuda:0")
+        y_pred = model(x)
+        assert y_pred.shape == (32, 1)

blinklinmult/models/efficientnetv2.py

@@ -0,0 +1,27 @@
+from torch import nn
+from torchvision import models
+from blinklinmult.models.backbone import AbstractModule
+
+
+class EfficientNetV2(AbstractModule):
+
+    def __init__(self, output_dim: int = 1, freeze: bool = False):
+        super().__init__()
+        self.model = models.efficientnet_v2_m(weights=models.EfficientNet_V2_M_Weights.DEFAULT)
+
+        self.features = nn.Sequential(
+            self.model.features,
+            nn.AdaptiveAvgPool2d(output_size=(1, 1)),
+            nn.Flatten()
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Linear(1280, 512),
+            nn.BatchNorm1d(512, momentum=0.999, eps=1e-3),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.6),
+            nn.Linear(512, output_dim),
+        )
+
+        if freeze:
+            self.freeze_feature_extractor()

blinklinmult/models/gru.py

@@ -0,0 +1,40 @@
+import torch
+from torch import nn
+
+
+class GRU(nn.Module):
+
+    def __init__(self, input_dim,
+                       hidden_dim: int = 256,
+                       layer_dim: int = 3,
+                       dropout_prob: float = 0.2,
+                       return_sequences: bool = True):
+        super().__init__()
+        self.layer_dim = layer_dim
+        self.hidden_dim = hidden_dim
+        self.return_sequences = return_sequences
+        self.gru = nn.GRU(
+            input_dim, hidden_dim, layer_dim, batch_first=True, dropout=dropout_prob
+        )
+        # self.fc = nn.Linear(hidden_dim, output_dim)
+
+    def forward(self, x):
+
+        # Initializing hidden state for first input with zeros
+        h0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).requires_grad_()
+
+        h0 = h0.to(x.device)
+        self.gru = self.gru.to(x.device)
+
+        # Forward propagation by passing in the input and hidden state into the model
+        out, _ = self.gru(x, h0)
+
+        # Reshaping the outputs in the shape of (batch_size, seq_length, hidden_size)
+        # so that it can fit into the fully connected layer
+        if not self.return_sequences:
+            out = out[:, -1, :]
+
+        # Convert the final state to our desired output shape (batch_size, output_dim)
+        # out = self.fc(out)
+
+        return out

blinklinmult/preprocess/cew.py

@@ -0,0 +1,84 @@
+import pickle
+from pathlib import Path
+import cv2
+import numpy as np
+from tqdm import tqdm
+from exordium.video.iris import IrisWrapper
+from exordium.video.tddfa_v2 import TDDFA_V2
+from exordium.utils.decorator import timer
+from blinklinmult import PathType
+
+
+DB_DIR = Path('data/db/CEW')
+DB_DIR_OUT = Path('data/db_processed/cew')
+
+
+@timer
+def save_eye_crops(output_path: PathType, bb_size: int = 40) -> None:
+    # read closed eye filenames and eye coordinates
+    with open(DB_DIR / 'dataset_B_FacialImages' / 'EyeCoordinatesInfo_ClosedFace.txt', 'r') as f:
+        lines = f.readlines()
+        lines = [line.replace('\n', '').split(' ') for line in lines]
+        closed_file_coords = {
+            elem[0]: (1, np.array(elem[1:]).astype(int))
+            for elem in lines
+        }
+
+    # read open eye filenames and eye coordinates
+    with open(DB_DIR / 'dataset_B_FacialImages' / 'EyeCoordinatesInfo_OpenFace.txt', 'r') as f:
+        lines = f.readlines()
+        lines = [line.replace('\n', '').split(' ') for line in lines]
+        open_file_coords = {
+            elem[0]: (0, np.array(elem[1:]).astype(int))
+            for elem in lines
+        }
+
+    file_coords = open_file_coords | closed_file_coords
+
+    face_model = TDDFA_V2()
+    eye_model = IrisWrapper()
+
+    closed_face_dir = DB_DIR / 'dataset_B_FacialImages' / 'ClosedFace'
+    open_face_dir = DB_DIR / 'dataset_B_FacialImages' / 'OpenFace'
+    eye_dir = DB_DIR_OUT / 'eyes'
+    eye_dir.mkdir(parents=True, exist_ok=True)
+    (eye_dir / 'left').mkdir(parents=True, exist_ok=True)
+    (eye_dir / 'right').mkdir(parents=True, exist_ok=True)
+
+    samples = []
+    for id, (name, (label, coords)) in enumerate(tqdm(file_coords.items(), total=len(file_coords), desc='[CEW] eye crops')):
+        face_dir = closed_face_dir if label else open_face_dir
+        face_path = str(face_dir / name)
+        face = cv2.imread(face_path)
+
+        sample = {'id': id, 'name': name, 'path': face_path, 'label': label, 'headpose': face_model(face)['headpose']}
+        left_eye_path = str(eye_dir / 'left' / f'{id:06d}.png')
+        right_eye_path = str(eye_dir / 'right' / f'{id:06d}.png')
+
+        # eye crop rgb
+        y_min = max(coords[1] - bb_size // 2, 0)
+        y_max = min(100, coords[1] + bb_size // 2)
+        x_min = max(coords[0] - bb_size // 2, 0)
+        x_max = min(100, coords[0] + bb_size // 2)
+        left_eye = face[y_min:y_max, x_min:x_max, :]
+        y_min = max(coords[3] - bb_size // 2, 0)
+        y_max = min(100, coords[3] + bb_size // 2)
+        x_min = max(coords[2] - bb_size // 2, 0)
+        x_max = min(100, coords[2] + bb_size // 2)
+        right_eye = face[y_min:y_max, x_min:x_max, :]
+        cv2.imwrite(left_eye_path, left_eye)
+        cv2.imwrite(right_eye_path, right_eye)
+
+        left_eye_features = eye_model.eye_to_features(left_eye_path)
+        right_eye_features = eye_model.eye_to_features(right_eye_path)
+        sample |= {'left_eye': left_eye_features, 'right_eye': right_eye_features}
+        samples.append(sample)
+
+    with open(str(output_path), 'wb') as f:
+        pickle.dump(samples, f)
+
+    print(f'[CEW] feature extraction is done: {str(output_path)}')
+
+
+if __name__ == '__main__':
+    save_eye_crops(output_path=DB_DIR_OUT / '0_data.pkl')

blinklinmult/preprocess/eyeblink8.py

@@ -0,0 +1,117 @@
+import os
+import pickle
+from pathlib import Path
+from tqdm import tqdm
+from exordium.video.io import video2frames
+from exordium.utils.decorator import timer
+from exordium.video.tddfa_v2 import TDDFA_V2
+from exordium.video.iris import IrisWrapper
+from blinklinmult.preprocess.reader import Tag
+
+
+DB_DIR = Path('data/db/eyeblink8')
+DB_DIR_OUT = Path('data/db_processed/eyeblink8')
+IDS = os.listdir(DB_DIR)
+
+
+def extract_frames():
+    videos = sorted(list(DB_DIR.rglob('*/*.avi')))
+
+    for video in videos:
+        id = video.parent.name
+        output_dir = DB_DIR_OUT / 'frames' / id
+        video2frames(video, output_dir, fps=30)
+
+
+def save_samples():
+    tag_paths = list(Path(DB_DIR).glob('*/*.tag'))
+    samples = []
+
+    for tag_path in tqdm(tag_paths, desc='Save mp4'):
+        id = tag_path.parent.name
+        frames_dir = DB_DIR_OUT / 'frames' / id
+        output_dir = DB_DIR_OUT / 'visualize'
+        tag = Tag(tag_path=tag_path, frames_dir=frames_dir)
+        samples += tag.generate_positive_samples(output_dir=output_dir, fps=30)
+
+    return samples
+
+
+def save_face_crops():
+    tag_paths = list(Path(DB_DIR).glob('*/*.tag'))
+    for tag_path in tqdm(tag_paths, desc='Save faces'):
+        id = tag_path.parent.name
+        frames_dir = DB_DIR_OUT / 'frames' / id
+        faces_dir = DB_DIR_OUT / 'faces' / id
+        tag = Tag(tag_path=tag_path, frames_dir=frames_dir)
+        tag.save_annotated_face_crops(faces_dir)
+
+
+def save_eye_crops():
+    tag_paths = list(Path(DB_DIR).glob('*/*.tag'))
+    for tag_path in tqdm(tag_paths, desc='Save faces'):
+        id = tag_path.parent.name
+        frames_dir = DB_DIR_OUT / 'frames' / id
+        eyes_dir = DB_DIR_OUT / 'eyes' / id
+        tag = Tag(tag_path=tag_path, frames_dir=frames_dir)
+        tag.save_annotated_eye_crops(eyes_dir)
+
+
+@timer
+def extract_features(tag_path: str | Path,
+                     face_dir: str | Path,
+                     left_eye_dir: str | Path,
+                     right_eye_dir: str | Path,
+                     output_path: str | Path):
+
+    face_paths = [str(Path(face_dir) / elem) for elem in sorted(os.listdir(face_dir))]
+    left_eye_paths = [str(Path(left_eye_dir) / elem) for elem in sorted(os.listdir(left_eye_dir))]
+    right_eye_paths = [str(Path(right_eye_dir) / elem) for elem in sorted(os.listdir(right_eye_dir))]
+
+    face_model = TDDFA_V2()
+    eye_model = IrisWrapper()
+
+    headposes = []
+    for face_path in tqdm(face_paths, desc='Extract headpose feature'):
+        headposes.append({'id': int(Path(face_path).stem), 'headpose': face_model.inference(face_path)['headpose']})
+
+    eyes = []
+    for left_eye_path, right_eye_path in tqdm(zip(left_eye_paths, right_eye_paths), total=len(left_eye_paths), desc='Extract eye features'):
+        eyes.append({'id': int(Path(left_eye_path).stem),
+                     'left_eye': eye_model.eye_to_features(left_eye_path),
+                     'right_eye': eye_model.eye_to_features(right_eye_path)})
+
+    tag_path = Path(tag_path)
+    tag = Tag(tag_path=tag_path, frames_dir=DB_DIR_OUT / 'frames' / tag_path.parent.name)
+    ids = sorted([elem['id'] for elem in headposes])
+
+    features = []
+    for id in tqdm(ids, total=len(ids), desc='Merge headpose and eye features, then save to pickle'):
+        label = tag.blink_label(id)
+        headpose = next((elem for elem in headposes if elem['id'] == id))
+        eye = next((elem for elem in eyes if elem['id'] == id))
+        features.append({'label': label} | headpose | eye)
+
+    with open(output_path, 'wb') as f:
+        pickle.dump(features, f)
+
+    print(f'Feature extraction is done: {output_path}')
+
+
+if __name__ == '__main__':
+    extract_frames()
+    save_samples()
+    save_face_crops()
+    save_eye_crops()
+
+    tag_paths = list(Path(DB_DIR).glob('*/*.tag'))
+
+    for id in IDS:
+        print(f'Started id {id}')
+        tag_path = next((elem for elem in tag_paths if elem.parent.name == id))
+        extract_features(tag_path=tag_path,
+                         face_dir=DB_DIR_OUT / 'faces' / id,
+                         left_eye_dir=DB_DIR_OUT / 'eyes'/ id / 'left',
+                         right_eye_dir=DB_DIR_OUT / 'eyes'/ id / 'right',
+                         output_path=DB_DIR_OUT / f'{id}_data.pkl')
+        print('EyeBlink8 is done.')

blinklinmult/preprocess/mrl.py

@@ -0,0 +1,53 @@
+import os
+from tqdm import tqdm
+from pathlib import Path
+import pickle
+from exordium.video.iris import IrisWrapper
+from exordium.utils.decorator import timer
+
+
+DB_DIR = Path('data/db/mrl_eye')
+DB_DIR_OUT = Path('data/db_processed/mrl')
+IDS = [elem for elem in os.listdir('data/db/mrl_eye/mrlEyes_2018_01')
+       if len(elem) == 5 and elem[0] == 's']
+
+
+@timer
+def save_features(input_path: str | Path, output_path: str | Path):
+    paths = [Path(input_path) / elem for elem in os.listdir(str(input_path))]
+    eye_model = IrisWrapper()
+
+    samples = []
+    for path in tqdm(paths, total=len(paths), desc=f'[MRL] {Path(input_path).name} features'):
+
+        data = Path(path).stem.split('_')
+        participant_id = int(data[0][1:])  # participant id
+        sample = {
+            'participant_id': participant_id,
+            'id': int(data[1]),  # image number
+            'name': Path(path).stem,  # image name
+            'gender': int(data[2]),  # 0=male, 1=female
+            'glasses': int(data[3]),  # 0=no, 1=yes
+            'label': int(not bool(int(data[4]))),  # switch original blink label from 0=close, 1=open to 1=close, 0=open
+            'reflection': int(data[5]),  # 0=none, 1=low, 2=high
+            'lightning': int(data[6]),  # 0=bad, 1=good
+            'sensor': int(data[7]),  # 1=RealSense SR300 640x480, 2=IDS Imaging, 1280x1024, 3=Aptina Imagin 752x480
+        }
+
+        eye_features = eye_model.eye_to_features(path)
+        sample |= eye_features
+        samples.append(sample)
+
+    output_path = str(output_path)
+
+    with open(output_path, 'wb') as f:
+        pickle.dump(samples, f)
+
+    print(f'[MRL] feature extraction is done: {output_path}')
+
+
+if __name__ == '__main__':
+
+    for id in IDS:
+        save_features(input_path=DB_DIR / 'mrlEyes_2018_01' / id,
+                      output_path=DB_DIR_OUT / f'{int(id[1:])}_data.pkl')