upload model.pth, model.onnx, model.py

ArcFace_iResNet50_CASIA_FaceV5.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d76ca98845004f130f017a4778612ee36e3b47f5a8b86351363be12ff71252ce
+size 174398650

ArcFace_iResNet50_CASIA_FaceV5.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c15a06ee387aa4fe62fed50e71f336ce56330a5366629fece100cb8809f3709a
+size 175710586

README.md

@@ -1,3 +1,69 @@
+# FaceMind_ArcFace：针对亚洲人脸 SFT 的 ArcFace 人脸识别模型
+本模型为以iResNet50为基座的ArcFace模型，在预训练的基础上，使用数据增强的亚洲人脸数据集CASIA_FaceV5进行SFT，旨在提高ArcFace人脸识别模型针对亚洲人脸识别的精确度。
+
+## Reference
+本模型用于我个人的人脸识别系统 FaceMind：https://github.com/Justin-ljw/FaceMind
+
+SFT使用的数据集（我个人清洗并数据增强的CASIA_FaceV5）：https://modelscope.cn/datasets/JustinLeee/Cleaned_Augmented_CASIA_FaceV5
+
+预训练模型和训练代码来自GitHub大佬：https://github.com/bubbliiiing/arcface-pytorch
+
+## 仓库说明
+仓库包含了 pth 和 onnx 格式的模型文件，您可以使用pytorch进一步对pth模型文件进行微调，模型结构文件为iresnet.python、arcface.py，本模型使用iResNet50为基座。
+onnx文件可以直接用于推理，其中已经包含了模型结构，无序显示定义模型结构。
+
+## 快速开始
+模型文件和权重，可浏览“模型文件”页面获取。您可以通过如下git clone命令，或者ModelScope SDK来下载模型
+
+SDK下载
+```bash
+#安装ModelScope
+pip install modelscope
+```
+```python
+#SDK模型下载
+from modelscope import snapshot_download
+model_dir = snapshot_download('JustinLeee/FaceMind_ArcFace_iResNet50_CASIA_FaceV5')
+```
+Git下载
+```
+#Git模型下载
+git clone https://www.modelscope.cn/JustinLeee/FaceMind_ArcFace_iResNet50_CASIA_FaceV5.git
+```
+
+
 ---
-license: apache-2.0
+frameworks:
+- Pytorch
+
+license: Apache License 2.0
+
+tasks:
+- face-recognition
+
+model-type:
+- ArcFace_iResNet50
+
+domain:
+- cv
+
+language:
+  - zh
+  - en
+
+base_model_relation: finetune
+
+metrics:
+  - accuracy
+
+tags:
+  - ArcFace
+  - CASIA_FaceV5
+  - 亚洲人脸
+  - 中国人脸
+  - fine-tuned
+
+datasets:
+  - JustinLeee/Cleaned_Augmented_CASIA_FaceV5
 ---
+

arcface.py

@@ -0,0 +1,90 @@
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import Module, Parameter
+
+from nets.iresnet import (iresnet18, iresnet34, iresnet50, iresnet100,
+                          iresnet200)
+from nets.mobilefacenet import get_mbf
+from nets.mobilenet import get_mobilenet
+
+class Arcface_Head(Module):
+    def __init__(self, embedding_size=128, num_classes=10575, s=64., m=0.5):
+        super(Arcface_Head, self).__init__()
+        self.s = s
+        self.m = m
+        self.weight = Parameter(torch.FloatTensor(num_classes, embedding_size))
+        nn.init.xavier_uniform_(self.weight)
+
+        self.cos_m = math.cos(m)
+        self.sin_m = math.sin(m)
+        self.th = math.cos(math.pi - m)
+        self.mm = math.sin(math.pi - m) * m
+
+    def forward(self, input, label):
+        cosine  = F.linear(input, F.normalize(self.weight))
+        sine    = torch.sqrt((1.0 - torch.pow(cosine, 2)).clamp(0, 1))
+        phi     = cosine * self.cos_m - sine * self.sin_m
+        phi     = torch.where(cosine.float() > self.th, phi.float(), cosine.float() - self.mm)
+
+        one_hot = torch.zeros(cosine.size()).type_as(phi).long()
+        one_hot.scatter_(1, label.view(-1, 1).long(), 1)
+        output  = (one_hot * phi) + ((1.0 - one_hot) * cosine) 
+        output  *= self.s
+        return output
+
+class Arcface(nn.Module):
+    def __init__(self, num_classes=None, backbone="mobilefacenet", pretrained=False, mode="train"):
+        super(Arcface, self).__init__()
+        if backbone=="mobilefacenet":
+            embedding_size  = 128
+            s               = 32
+            self.arcface    = get_mbf(embedding_size=embedding_size, pretrained=pretrained)
+
+        elif backbone=="mobilenetv1":
+            embedding_size  = 512
+            s               = 64
+            self.arcface    = get_mobilenet(dropout_keep_prob=0.5, embedding_size=embedding_size, pretrained=pretrained)
+
+        elif backbone=="iresnet18":
+            embedding_size  = 512
+            s               = 64
+            self.arcface    = iresnet18(dropout_keep_prob=0.5, embedding_size=embedding_size, pretrained=pretrained)
+
+        elif backbone=="iresnet34":
+            embedding_size  = 512
+            s               = 64
+            self.arcface    = iresnet34(dropout_keep_prob=0.5, embedding_size=embedding_size, pretrained=pretrained)
+
+        elif backbone=="iresnet50":
+            embedding_size  = 512
+            s               = 64
+            self.arcface    = iresnet50(dropout_keep_prob=0.5, embedding_size=embedding_size, pretrained=pretrained)
+
+        elif backbone=="iresnet100":
+            embedding_size  = 512
+            s               = 64
+            self.arcface    = iresnet100(dropout_keep_prob=0.5, embedding_size=embedding_size, pretrained=pretrained)
+
+        elif backbone=="iresnet200":
+            embedding_size  = 512
+            s               = 64
+            self.arcface    = iresnet200(dropout_keep_prob=0.5, embedding_size=embedding_size, pretrained=pretrained)
+        else:
+            raise ValueError('Unsupported backbone - `{}`, Use mobilefacenet, mobilenetv1.'.format(backbone))
+
+        self.mode = mode
+        if mode == "train":
+            self.head = Arcface_Head(embedding_size=embedding_size, num_classes=num_classes, s=s)
+
+    def forward(self, x, y = None, mode = "predict"):
+        x = self.arcface(x)
+        x = x.view(x.size()[0], -1)
+        x = F.normalize(x)
+        if mode == "predict":
+            return x
+        else:
+            x = self.head(x, y)
+            return x

configuration.json

@@ -0,0 +1,22 @@
+{
+    "model_name": "ArcFace_iResNet50_CASIA_FaceV5",
+    "architecture": "iresnet50",
+    "framework": "PyTorch",
+    "task":"face-recognition",
+    "input_size": [112, 112, 3],
+    "num_classes": 512,
+    "pretrained": true,
+    "description": "ArcFace model based on iResNet50 backbone for face recognition. This model has been fine-tuned on the CASIA_FaceV5 dataset.",
+    "training_dataset": "CASIA_FaceV5",
+    "embedding_size": 512,
+    "margin": 0.5,
+    "scale": 64.0,
+    "optimizer": "Adam",
+    "learning_rate": 1e-4,
+    "lr_decay_type": "cos",
+    "weight_decay": 0,
+    "momentum": 0.9,
+    "loss_function": "ArcFaceLoss",
+    "license": "Apache License 2.0",
+    "notes": "This model is trained for face recognition tasks and outputs a 512-dimensional embedding vector. It has been fine-tuned on the CASIA_FaceV5 dataset for improved performance."
+}

iresnet.py

@@ -0,0 +1,184 @@
+   
+import torch
+from torch import nn
+
+__all__ = ['iresnet18', 'iresnet34', 'iresnet50', 'iresnet100', 'iresnet200']
+
+
+def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):
+    return nn.Conv2d(in_planes,
+                     out_planes,
+                     kernel_size=3,
+                     stride=stride,
+                     padding=dilation,
+                     groups=groups,
+                     bias=False,
+                     dilation=dilation)
+
+
+def conv1x1(in_planes, out_planes, stride=1):
+    return nn.Conv2d(in_planes,
+                     out_planes,
+                     kernel_size=1,
+                     stride=stride,
+                     bias=False)
+
+
+class IBasicBlock(nn.Module):
+    expansion = 1
+    def __init__(self, inplanes, planes, stride=1, downsample=None,
+                 groups=1, base_width=64, dilation=1):
+        super(IBasicBlock, self).__init__()
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        self.bn1    = nn.BatchNorm2d(inplanes, eps=1e-05,)
+        self.conv1  = conv3x3(inplanes, planes)
+        self.bn2    = nn.BatchNorm2d(planes, eps=1e-05,)
+        self.prelu  = nn.PReLU(planes)
+        self.conv2  = conv3x3(planes, planes, stride)
+        self.bn3    = nn.BatchNorm2d(planes, eps=1e-05,)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        identity = x
+        out = self.bn1(x)
+        out = self.conv1(out)
+        out = self.bn2(out)
+        out = self.prelu(out)
+        out = self.conv2(out)
+        out = self.bn3(out)
+        if self.downsample is not None:
+            identity = self.downsample(x)
+        out += identity
+        return out
+
+
+class IResNet(nn.Module):
+    fc_scale = 7 * 7
+    def __init__(self,
+                 block, layers, dropout_keep_prob=0, embedding_size=512, zero_init_residual=False,
+                 groups=1, width_per_group=64, replace_stride_with_dilation=None, fp16=False):
+        super(IResNet, self).__init__()
+        self.fp16       = fp16
+        self.inplanes   = 64
+        self.dilation   = 1
+        if replace_stride_with_dilation is None:
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+        self.conv1  = nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1    = nn.BatchNorm2d(self.inplanes, eps=1e-05)
+        self.prelu  = nn.PReLU(self.inplanes)
+        self.layer1 = self._make_layer(block, 64, layers[0], stride=2)
+        self.layer2 = self._make_layer(block,
+                                       128,
+                                       layers[1],
+                                       stride=2,
+                                       dilate=replace_stride_with_dilation[0])
+        self.layer3 = self._make_layer(block,
+                                       256,
+                                       layers[2],
+                                       stride=2,
+                                       dilate=replace_stride_with_dilation[1])
+        self.layer4 = self._make_layer(block,
+                                       512,
+                                       layers[3],
+                                       stride=2,
+                                       dilate=replace_stride_with_dilation[2])
+        self.bn2        = nn.BatchNorm2d(512 * block.expansion, eps=1e-05,)
+        self.dropout    = nn.Dropout(p=dropout_keep_prob, inplace=True)
+        self.fc         = nn.Linear(512 * block.expansion * self.fc_scale, embedding_size)
+        self.features   = nn.BatchNorm1d(embedding_size, eps=1e-05)
+        nn.init.constant_(self.features.weight, 1.0)
+        self.features.weight.requires_grad = False
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.normal_(m.weight, 0, 0.1)
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, IBasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride),
+                nn.BatchNorm2d(planes * block.expansion, eps=1e-05, ),
+            )
+        layers = []
+        layers.append(
+            block(self.inplanes, planes, stride, downsample, self.groups,
+                  self.base_width, previous_dilation))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(
+                block(self.inplanes,
+                      planes,
+                      groups=self.groups,
+                      base_width=self.base_width,
+                      dilation=self.dilation))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.prelu(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.bn2(x)
+        x = torch.flatten(x, 1)
+        x = self.dropout(x)
+        x = self.fc(x)
+        x = self.features(x)
+        return x
+
+
+def _iresnet(arch, block, layers, pretrained, progress, **kwargs):
+    model = IResNet(block, layers, **kwargs)
+    if pretrained:
+        raise ValueError("No pretrained model for iresnet")
+    return model
+
+
+def iresnet18(pretrained=False, progress=True, **kwargs):
+    return _iresnet('iresnet18', IBasicBlock, [2, 2, 2, 2], pretrained,
+                    progress, **kwargs)
+
+
+def iresnet34(pretrained=False, progress=True, **kwargs):
+    return _iresnet('iresnet34', IBasicBlock, [3, 4, 6, 3], pretrained,
+                    progress, **kwargs)
+
+
+def iresnet50(pretrained=False, progress=True, **kwargs):
+    return _iresnet('iresnet50', IBasicBlock, [3, 4, 14, 3], pretrained,
+                    progress, **kwargs)
+
+
+def iresnet100(pretrained=False, progress=True, **kwargs):
+    return _iresnet('iresnet100', IBasicBlock, [3, 13, 30, 3], pretrained,
+                    progress, **kwargs)
+
+
+def iresnet200(pretrained=False, progress=True, **kwargs):
+    return _iresnet('iresnet200', IBasicBlock, [6, 26, 60, 6], pretrained,
+                    progress, **kwargs)