Upload 18 files

Dockerfile.nvidia.txt

@@ -0,0 +1,20 @@
+FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04
+
+# Always use UTC on a server
+RUN ln -snf /usr/share/zoneinfo/UTC /etc/localtime && echo UTC > /etc/timezone
+
+RUN DEBIAN_FRONTEND=noninteractive apt update && apt install -y python3 python3-pip python3-tk git ffmpeg nvidia-cuda-toolkit nvidia-container-runtime libnvidia-decode-525-server wget unzip
+RUN wget https://github.com/deepinsight/insightface/releases/download/v0.7/buffalo_l.zip -O /tmp/buffalo_l.zip && \
+        mkdir -p /root/.insightface/models/buffalo_l && \
+        cd /root/.insightface/models/buffalo_l && \
+        unzip /tmp/buffalo_l.zip && \
+        rm -f /tmp/buffalo_l.zip
+
+RUN pip install nvidia-tensorrt
+RUN git clone https://github.com/xaviviro/refacer && cd refacer && pip install -r requirements-GPU.txt
+
+WORKDIR /refacer
+
+# Test following commands in container to make sure GPU stuff works
+# nvidia-smi
+# python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 xaviviro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md.txt

@@ -0,0 +1,126 @@
+---
+license: mit
+title: Refacerr
+sdk: gradio
+emoji: 🚀
+colorFrom: blue
+colorTo: yellow
+---
+# Refacer: One-Click Deepfake Multi-Face Swap Tool
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/xaviviro/refacer/blob/master/notebooks/Refacer_colab.ipynb)
+
+👉 [Watch demo on Youtube](https://youtu.be/mXk1Ox7B244)
+
+Refacer, a simple tool that allows you to create deepfakes with multiple faces with just one click! This project was inspired by [Roop](https://github.com/s0md3v/roop) and is powered by the excellent [Insightface](https://github.com/deepinsight/insightface). Refacer requires no training - just one photo and you're ready to go.
+
+:warning: Please, before using the code from this repository, make sure to read the [disclaimer](https://github.com/xaviviro/refacer/tree/main#disclaimer).
+
+## Demonstration
+
+![demonstration](demo.gif)
+
+[![Watch the video](https://img.youtube.com/vi/mXk1Ox7B244/maxresdefault.jpg)](https://youtu.be/mXk1Ox7B244)
+
+
+## System Compatibility
+
+Refacer has been thoroughly tested on the following operating systems:
+
+| Operating System | CPU Support | GPU Support |
+| ---------------- | ----------- | ----------- |
+| MacOSX           | ✅         | :warning:         |
+| Windows          | ✅         | ✅         |
+| Linux            | ✅         | ✅         |
+
+The application is compatible with both CPU and GPU (Nvidia CUDA) environments, and MacOSX(CoreML) 
+
+:warning: Please note, we do not recommend using `onnxruntime-silicon` on MacOSX due to an apparent issue with memory management. If you manage to compile `onnxruntime` for Silicon, the program is prepared to use CoreML.
+
+## Prerequisites
+
+Ensure that you have `ffmpeg` installed and correctly configured. There are many guides available on the internet to help with this. Here are a few (note: I did not create these guides):
+
+- [How to Install FFmpeg](https://www.hostinger.com/tutorials/how-to-install-ffmpeg)
+
+
+## Installation
+
+Refacer has been tested and is known to work with Python 3.10.9, but it is likely to work with other Python versions as well. It is recommended to use a virtual environment for setting up and running the project to avoid potential conflicts with other Python packages you may have installed.
+
+Follow these steps to install Refacer:
+
+1. Clone the repository:
+    ```bash
+    git clone https://github.com/xaviviro/refacer.git
+    cd refacer
+    ```
+
+2. Download the Insightface model:
+   You can manually download the model created by Insightface from this [link](https://huggingface.co/deepinsight/inswapper/resolve/main/inswapper_128.onnx) and add it to the project folder. Alternatively, if you have `wget` installed, you can use the following command:
+    ```bash
+    wget --content-disposition https://huggingface.co/deepinsight/inswapper/resolve/main/inswapper_128.onnx
+    ```
+
+3. Install dependencies:
+
+    * For CPU (compatible with Windows, MacOSX, and Linux):
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+    * For GPU (compatible with Windows and Linux only, requires a NVIDIA GPU with CUDA and its libraries):
+    ```bash
+    pip install -r requirements-GPU.txt
+    ```
+
+     * For CoreML (compatible with MacOSX, requires Silicon architecture):
+    ```bash
+    pip install -r requirements-COREML.txt
+    ```
+
+    For more information on installing the CUDA necessary to use `onnxruntime-gpu`, please refer directly to the official [ONNX Runtime repository](https://github.com/microsoft/onnxruntime/).
+
+For more details on using the Insightface model, you can refer to their [example](https://github.com/deepinsight/insightface/tree/master/examples/in_swapper).
+
+
+## Usage
+
+Once you have successfully installed Refacer and its dependencies, you can run the application using the following command:
+
+```bash
+python app.py
+```
+
+Then, open your web browser and navigate to the following address:
+
+```
+http://127.0.0.1:7680
+```
+
+
+## Questions?
+
+If you have any questions or issues, feel free to [open an issue](https://github.com/xaviviro/refacer/issues/new) or submit a pull request.
+
+
+## Recognition Module
+
+The `recognition` folder in this repository is derived from Insightface's GitHub repository. You can find the original source code here: [Insightface Recognition Source Code](https://github.com/deepinsight/insightface/tree/master/web-demos/src_recognition)
+
+This module is used for recognizing and handling face data within the Refacer application, enabling its powerful deepfake capabilities. We are grateful to Insightface for their work and for making their code available.
+
+
+## Disclaimer
+
+> :warning: This software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
+
+> :warning: This software is intended for educational and research purposes only. It is not intended for use in any malicious activities. The author of this software does not condone or support the use of this software for any harmful actions, including but not limited to identity theft, invasion of privacy, or defamation. Any use of this software for such purposes is strictly prohibited.
+
+> :warning: You may only use this software with images for which you have the right to use and the necessary permissions. Any use of images without the proper rights and permissions is strictly prohibited.
+
+> :warning: The author of this software is not responsible for any misuse of the software or for any violation of rights and privacy resulting from such misuse.
+
+> :warning: To prevent misuse, the software contains an integrated protective mechanism that prevents it from working with illegal or similar types of media.
+
+> :warning: By using this software, you agree to abide by all applicable laws, to respect the rights and privacy of others, and to use the software responsibly and ethically.

app.py.txt

@@ -0,0 +1,117 @@
+import gradio as gr
+import cv2
+import multiprocessing
+import os
+import requests
+from refacer import Refacer
+
+# Hugging Face URL to download the model
+model_url = "https://huggingface.co/ofter/4x-UltraSharp/resolve/main/inswapper_128.onnx"
+model_path = "./inswapper_128.onnx"
+
+# Function to download the model
+def download_model():
+    if not os.path.exists(model_path):
+        print("Downloading inswapper_128.onnx...")
+        response = requests.get(model_url)
+        if response.status_code == 200:
+            with open(model_path, 'wb') as f:
+                f.write(response.content)
+            print("Model downloaded successfully!")
+        else:
+            raise Exception(f"Failed to download the model. Status code: {response.status_code}")
+    else:
+        print("Model already exists.")
+
+# Download the model when the script runs
+download_model()
+
+# Initialize Refacer class (force CPU mode)
+refacer = Refacer(force_cpu=True)
+
+# Dummy function to simulate frame-level processing
+def process_frame(frame, origin_face, destination_face, threshold):
+    # Simulate face swapping or any processing needed
+    result_frame = refacer.reface(frame, [{
+        'origin': origin_face,
+        'destination': destination_face,
+        'threshold': threshold
+    }])
+    return result_frame
+
+# Function to process the video in parallel using multiprocessing
+def process_video(video_path, origins, destinations, thresholds, max_processes=2):
+    cap = cv2.VideoCapture(video_path)
+    frames = []
+
+    # Read all frames from the video
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frames.append(frame)
+
+    cap.release()
+
+    # Parallel processing of frames with limited processes (for CPU optimization)
+    with multiprocessing.Pool(processes=max_processes) as pool:
+        processed_frames = pool.starmap(process_frame, [
+            (frame, origins[min(i, len(origins) - 1)], destinations[min(i, len(destinations) - 1)], thresholds[min(i, len(thresholds) - 1)])
+            for i, frame in enumerate(frames)
+        ])
+
+    # Saving the processed frames back into a video
+    output_video_path = "processed_video.mp4"
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # Compression using mp4 codec
+    out = cv2.VideoWriter(output_video_path, fourcc, 30.0, (640, 360))  # Reduce resolution to speed up processing
+
+    for frame in processed_frames:
+        out.write(frame)
+
+    out.release()
+    return output_video_path
+
+# Gradio Interface function
+def run(video_path, *vars):
+    # Split the inputs into origins, destinations, and thresholds based on num_faces
+    num_faces = 5  # You can adjust this based on your UI
+    origins = vars[:num_faces]
+    destinations = vars[num_faces:2*num_faces]
+    thresholds = vars[2*num_faces:]
+
+    # Ensure there are no index errors by limiting the number of inputs
+    if len(origins) != num_faces or len(destinations) != num_faces or len(thresholds) != num_faces:
+        return "Please provide input for all faces."
+
+    refaced_video_path = process_video(video_path, origins, destinations, thresholds)
+    print(f"Refaced video can be found at {refaced_video_path}")
+
+    return refaced_video_path
+
+# Prepare Gradio components
+origin = []
+destination = []
+thresholds = []
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        gr.Markdown("# Refacer")
+    with gr.Row():
+        video_input = gr.Video(label="Original video", format="mp4")
+        video_output = gr.Video(label="Refaced video", interactive=False, format="mp4")
+
+    for i in range(5):  # Set max faces to 5
+        with gr.Tab(f"Face #{i+1}"):
+            with gr.Row():
+                origin.append(gr.Image(label="Face to replace"))
+                destination.append(gr.Image(label="Destination face"))
+            with gr.Row():
+                thresholds.append(gr.Slider(label="Threshold", minimum=0.0, maximum=1.0, value=0.2))
+    
+    with gr.Row():
+        button = gr.Button("Reface", variant="primary")
+
+    button.click(fn=run, inputs=[video_input] + origin + destination + thresholds, outputs=[video_output])
+
+# Launch the Gradio app
+demo.launch(show_error=True, server_name="0.0.0.0", server_port=7860)

arcface_onnx.py.txt

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+# @Organization  : insightface.ai
+# @Author        : Jia Guo
+# @Time          : 2021-05-04
+# @Function      : 
+
+import numpy as np
+import cv2
+import onnx
+import onnxruntime
+import face_align
+
+__all__ = [
+    'ArcFaceONNX',
+]
+
+
+class ArcFaceONNX:
+    def __init__(self, model_file=None, session=None):
+        assert model_file is not None
+        self.model_file = model_file
+        self.session = session
+        self.taskname = 'recognition'
+        find_sub = False
+        find_mul = False
+        model = onnx.load(self.model_file)
+        graph = model.graph
+        for nid, node in enumerate(graph.node[:8]):
+            #print(nid, node.name)
+            if node.name.startswith('Sub') or node.name.startswith('_minus'):
+                find_sub = True
+            if node.name.startswith('Mul') or node.name.startswith('_mul'):
+                find_mul = True
+        if find_sub and find_mul:
+            #mxnet arcface model
+            input_mean = 0.0
+            input_std = 1.0
+        else:
+            input_mean = 127.5
+            input_std = 127.5
+        self.input_mean = input_mean
+        self.input_std = input_std
+        #print('input mean and std:', self.input_mean, self.input_std)
+        if self.session is None:
+            self.session = onnxruntime.InferenceSession(self.model_file, providers=['CoreMLExecutionProvider','CUDAExecutionProvider'])
+        input_cfg = self.session.get_inputs()[0]
+        input_shape = input_cfg.shape
+        input_name = input_cfg.name
+        self.input_size = tuple(input_shape[2:4][::-1])
+        self.input_shape = input_shape
+        outputs = self.session.get_outputs()
+        output_names = []
+        for out in outputs:
+            output_names.append(out.name)
+        self.input_name = input_name
+        self.output_names = output_names
+        assert len(self.output_names)==1
+        self.output_shape = outputs[0].shape
+
+    def prepare(self, ctx_id, **kwargs):
+        if ctx_id<0:
+            self.session.set_providers(['CPUExecutionProvider'])
+
+    def get(self, img, kps):
+        aimg = face_align.norm_crop(img, landmark=kps, image_size=self.input_size[0])
+        embedding = self.get_feat(aimg).flatten()
+        return embedding
+
+    def compute_sim(self, feat1, feat2):
+        from numpy.linalg import norm
+        feat1 = feat1.ravel()
+        feat2 = feat2.ravel()
+        sim = np.dot(feat1, feat2) / (norm(feat1) * norm(feat2))
+        return sim
+
+    def get_feat(self, imgs):
+        if not isinstance(imgs, list):
+            imgs = [imgs]
+        input_size = self.input_size
+        
+        blob = cv2.dnn.blobFromImages(imgs, 1.0 / self.input_std, input_size,
+                                      (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
+        net_out = self.session.run(self.output_names, {self.input_name: blob})[0]
+        return net_out
+
+    def forward(self, batch_data):
+        blob = (batch_data - self.input_mean) / self.input_std
+        net_out = self.session.run(self.output_names, {self.input_name: blob})[0]
+        return net_out
+
+

dockerfile.txt

@@ -0,0 +1,33 @@
+FROM python:3.10
+
+# Install dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    git-lfs \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    cmake \
+    rsync \
+    libgl1-mesa-glx \
+    curl \
+    nodejs \
+    && rm -rf /var/lib/apt/lists/* \
+    && git lfs install
+
+# Clone the insightface repository and install scrfd manually
+RUN git clone https://github.com/deepinsight/insightface.git /opt/insightface && \
+    cd /opt/insightface && \
+    pip install .
+
+# Set working directory
+WORKDIR /home/user/app
+
+# Copy the application files
+COPY --chown=1000:1000 . /home/user/app
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Command to run the application
+CMD ["python", "app.py"]

face_align.py.txt

@@ -0,0 +1,141 @@
+import cv2
+import numpy as np
+from skimage import transform as trans
+
+src1 = np.array([[51.642, 50.115], [57.617, 49.990], [35.740, 69.007],
+                 [51.157, 89.050], [57.025, 89.702]],
+                dtype=np.float32)
+#<--left
+src2 = np.array([[45.031, 50.118], [65.568, 50.872], [39.677, 68.111],
+                 [45.177, 86.190], [64.246, 86.758]],
+                dtype=np.float32)
+
+#---frontal
+src3 = np.array([[39.730, 51.138], [72.270, 51.138], [56.000, 68.493],
+                 [42.463, 87.010], [69.537, 87.010]],
+                dtype=np.float32)
+
+#-->right
+src4 = np.array([[46.845, 50.872], [67.382, 50.118], [72.737, 68.111],
+                 [48.167, 86.758], [67.236, 86.190]],
+                dtype=np.float32)
+
+#-->right profile
+src5 = np.array([[54.796, 49.990], [60.771, 50.115], [76.673, 69.007],
+                 [55.388, 89.702], [61.257, 89.050]],
+                dtype=np.float32)
+
+src = np.array([src1, src2, src3, src4, src5])
+src_map = {112: src, 224: src * 2}
+
+arcface_src = np.array(
+    [[38.2946, 51.6963], [73.5318, 51.5014], [56.0252, 71.7366],
+     [41.5493, 92.3655], [70.7299, 92.2041]],
+    dtype=np.float32)
+
+arcface_src = np.expand_dims(arcface_src, axis=0)
+
+# In[66]:
+
+
+# lmk is prediction; src is template
+def estimate_norm(lmk, image_size=112, mode='arcface'):
+    assert lmk.shape == (5, 2)
+    tform = trans.SimilarityTransform()
+    lmk_tran = np.insert(lmk, 2, values=np.ones(5), axis=1)
+    min_M = []
+    min_index = []
+    min_error = float('inf')
+    if mode == 'arcface':
+        if image_size == 112:
+            src = arcface_src
+        else:
+            src = float(image_size) / 112 * arcface_src
+    else:
+        src = src_map[image_size]
+    for i in np.arange(src.shape[0]):
+        tform.estimate(lmk, src[i])
+        M = tform.params[0:2, :]
+        results = np.dot(M, lmk_tran.T)
+        results = results.T
+        error = np.sum(np.sqrt(np.sum((results - src[i])**2, axis=1)))
+        #         print(error)
+        if error < min_error:
+            min_error = error
+            min_M = M
+            min_index = i
+    return min_M, min_index
+
+
+def norm_crop(img, landmark, image_size=112, mode='arcface'):
+    M, pose_index = estimate_norm(landmark, image_size, mode)
+    warped = cv2.warpAffine(img, M, (image_size, image_size), borderValue=0.0)
+    return warped
+
+def square_crop(im, S):
+    if im.shape[0] > im.shape[1]:
+        height = S
+        width = int(float(im.shape[1]) / im.shape[0] * S)
+        scale = float(S) / im.shape[0]
+    else:
+        width = S
+        height = int(float(im.shape[0]) / im.shape[1] * S)
+        scale = float(S) / im.shape[1]
+    resized_im = cv2.resize(im, (width, height))
+    det_im = np.zeros((S, S, 3), dtype=np.uint8)
+    det_im[:resized_im.shape[0], :resized_im.shape[1], :] = resized_im
+    return det_im, scale
+
+
+def transform(data, center, output_size, scale, rotation):
+    scale_ratio = scale
+    rot = float(rotation) * np.pi / 180.0
+    #translation = (output_size/2-center[0]*scale_ratio, output_size/2-center[1]*scale_ratio)
+    t1 = trans.SimilarityTransform(scale=scale_ratio)
+    cx = center[0] * scale_ratio
+    cy = center[1] * scale_ratio
+    t2 = trans.SimilarityTransform(translation=(-1 * cx, -1 * cy))
+    t3 = trans.SimilarityTransform(rotation=rot)
+    t4 = trans.SimilarityTransform(translation=(output_size / 2,
+                                                output_size / 2))
+    t = t1 + t2 + t3 + t4
+    M = t.params[0:2]
+    cropped = cv2.warpAffine(data,
+                             M, (output_size, output_size),
+                             borderValue=0.0)
+    return cropped, M
+
+
+def trans_points2d(pts, M):
+    new_pts = np.zeros(shape=pts.shape, dtype=np.float32)
+    for i in range(pts.shape[0]):
+        pt = pts[i]
+        new_pt = np.array([pt[0], pt[1], 1.], dtype=np.float32)
+        new_pt = np.dot(M, new_pt)
+        #print('new_pt', new_pt.shape, new_pt)
+        new_pts[i] = new_pt[0:2]
+
+    return new_pts
+
+
+def trans_points3d(pts, M):
+    scale = np.sqrt(M[0][0] * M[0][0] + M[0][1] * M[0][1])
+    #print(scale)
+    new_pts = np.zeros(shape=pts.shape, dtype=np.float32)
+    for i in range(pts.shape[0]):
+        pt = pts[i]
+        new_pt = np.array([pt[0], pt[1], 1.], dtype=np.float32)
+        new_pt = np.dot(M, new_pt)
+        #print('new_pt', new_pt.shape, new_pt)
+        new_pts[i][0:2] = new_pt[0:2]
+        new_pts[i][2] = pts[i][2] * scale
+
+    return new_pts
+
+
+def trans_points(pts, M):
+    if pts.shape[1] == 2:
+        return trans_points2d(pts, M)
+    else:
+        return trans_points3d(pts, M)
+

gitattributes.txt

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+demo.gif filter=lfs diff=lfs merge=lfs -text
+out filter=lfs diff=lfs merge=lfs -text

gitignore.txt

@@ -0,0 +1,173 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+out/*
+!out/.gitkeep
+media
+tests
+*.onnx
+
+aaa.md
+
+*_test.py
+img.jpg
+test_data
+testsrc.mp4

main.py.txt

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+import os
+import os.path as osp
+import argparse
+import cv2
+import numpy as np
+import onnxruntime
+from scrfd import SCRFD
+from arcface_onnx import ArcFaceONNX
+
+onnxruntime.set_default_logger_severity(5)
+
+assets_dir = osp.expanduser('~/.insightface/models/buffalo_l')
+
+detector = SCRFD(os.path.join(assets_dir, 'det_10g.onnx'))
+detector.prepare(0)
+model_path = os.path.join(assets_dir, 'w600k_r50.onnx')
+rec = ArcFaceONNX(model_path)
+rec.prepare(0)
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('img1', type=str)
+    parser.add_argument('img2', type=str)
+    return parser.parse_args()
+
+
+def func(args):
+    image1 = cv2.imread(args.img1)
+    image2 = cv2.imread(args.img2)
+    bboxes1, kpss1 = detector.autodetect(image1, max_num=1)
+    if bboxes1.shape[0]==0:
+        return -1.0, "Face not found in Image-1"
+    bboxes2, kpss2 = detector.autodetect(image2, max_num=1)
+    if bboxes2.shape[0]==0:
+        return -1.0, "Face not found in Image-2"
+    kps1 = kpss1[0]
+    kps2 = kpss2[0]
+    feat1 = rec.get(image1, kps1)
+    feat2 = rec.get(image2, kps2)
+    sim = rec.compute_sim(feat1, feat2)
+    if sim<0.2:
+        conclu = 'They are NOT the same person'
+    elif sim>=0.2 and sim<0.28:
+        conclu = 'They are LIKELY TO be the same person'
+    else:
+        conclu = 'They ARE the same person'
+    return sim, conclu
+
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    output = func(args)
+    print('sim: %.4f, message: %s'%(output[0], output[1]))
+

refacer.py.txt

@@ -0,0 +1,262 @@
+import cv2
+import onnxruntime as rt
+import sys
+from insightface.app import FaceAnalysis
+sys.path.insert(1, './recognition')
+from scrfd import SCRFD
+from arcface_onnx import ArcFaceONNX
+import os.path as osp
+import os
+from pathlib import Path
+from tqdm import tqdm
+import ffmpeg
+import random
+import multiprocessing as mp
+from concurrent.futures import ThreadPoolExecutor
+from insightface.model_zoo.inswapper import INSwapper
+import psutil
+from enum import Enum
+from insightface.app.common import Face
+from insightface.utils.storage import ensure_available
+import re
+import subprocess
+
+class RefacerMode(Enum):
+     CPU, CUDA, COREML, TENSORRT = range(1, 5)
+
+class Refacer:
+    def __init__(self,force_cpu=False,colab_performance=False):
+        self.first_face = False
+        self.force_cpu = force_cpu
+        self.colab_performance = colab_performance
+        self.__check_encoders()
+        self.__check_providers()
+        self.total_mem = psutil.virtual_memory().total
+        self.__init_apps()
+
+    def __check_providers(self):
+        if self.force_cpu :
+            self.providers = ['CPUExecutionProvider']
+        else:
+            self.providers = rt.get_available_providers()
+        rt.set_default_logger_severity(4)
+        self.sess_options = rt.SessionOptions()
+        self.sess_options.execution_mode = rt.ExecutionMode.ORT_SEQUENTIAL
+        self.sess_options.graph_optimization_level = rt.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+        if len(self.providers) == 1 and 'CPUExecutionProvider' in self.providers:
+            self.mode = RefacerMode.CPU
+            self.use_num_cpus = mp.cpu_count()-1
+            self.sess_options.intra_op_num_threads = int(self.use_num_cpus/3)
+            print(f"CPU mode with providers {self.providers}")
+        elif self.colab_performance:
+            self.mode = RefacerMode.TENSORRT
+            self.use_num_cpus = mp.cpu_count()-1
+            self.sess_options.intra_op_num_threads = int(self.use_num_cpus/3)
+            print(f"TENSORRT mode with providers {self.providers}")
+        elif 'CoreMLExecutionProvider' in self.providers:
+            self.mode = RefacerMode.COREML
+            self.use_num_cpus = mp.cpu_count()-1
+            self.sess_options.intra_op_num_threads = int(self.use_num_cpus/3)
+            print(f"CoreML mode with providers {self.providers}")
+        elif 'CUDAExecutionProvider' in self.providers:
+            self.mode = RefacerMode.CUDA
+            self.use_num_cpus = 2
+            self.sess_options.intra_op_num_threads = 1
+            if 'TensorrtExecutionProvider' in self.providers:
+                self.providers.remove('TensorrtExecutionProvider')
+            print(f"CUDA mode with providers {self.providers}")
+        """
+        elif 'TensorrtExecutionProvider' in self.providers:
+            self.mode = RefacerMode.TENSORRT
+            #self.use_num_cpus = 1
+            #self.sess_options.intra_op_num_threads = 1
+            self.use_num_cpus = mp.cpu_count()-1
+            self.sess_options.intra_op_num_threads = int(self.use_num_cpus/3)
+            print(f"TENSORRT mode with providers {self.providers}")
+        """
+        
+
+    def __init_apps(self):
+        assets_dir = ensure_available('models', 'buffalo_l', root='~/.insightface')
+
+        model_path = os.path.join(assets_dir, 'det_10g.onnx')
+        sess_face = rt.InferenceSession(model_path, self.sess_options, providers=self.providers)
+        self.face_detector = SCRFD(model_path,sess_face)
+        self.face_detector.prepare(0,input_size=(640, 640))
+
+        model_path = os.path.join(assets_dir , 'w600k_r50.onnx')
+        sess_rec = rt.InferenceSession(model_path, self.sess_options, providers=self.providers)
+        self.rec_app = ArcFaceONNX(model_path,sess_rec)
+        self.rec_app.prepare(0)
+
+        model_path = 'inswapper_128.onnx'
+        sess_swap = rt.InferenceSession(model_path, self.sess_options, providers=self.providers)
+        self.face_swapper = INSwapper(model_path,sess_swap)
+
+    def prepare_faces(self, faces):
+        self.replacement_faces=[]
+        for face in faces:
+            #image1 = cv2.imread(face.origin)
+            if "origin" in face:
+                face_threshold = face['threshold']
+                bboxes1, kpss1 = self.face_detector.autodetect(face['origin'], max_num=1)  
+                if len(kpss1)<1:
+                    raise Exception('No face detected on "Face to replace" image')
+                feat_original = self.rec_app.get(face['origin'], kpss1[0])
+            else:
+                face_threshold = 0
+                self.first_face = True
+                feat_original = None
+                print('No origin image: First face change')
+            #image2 = cv2.imread(face.destination)
+            _faces = self.__get_faces(face['destination'],max_num=1)
+            if len(_faces)<1:
+                raise Exception('No face detected on "Destination face" image')
+            self.replacement_faces.append((feat_original,_faces[0],face_threshold))
+
+    def __convert_video(self,video_path,output_video_path):
+        if self.video_has_audio:
+            print("Merging audio with the refaced video...")
+            new_path = output_video_path + str(random.randint(0,999)) + "_c.mp4"
+            #stream = ffmpeg.input(output_video_path)
+            in1 = ffmpeg.input(output_video_path)
+            in2 = ffmpeg.input(video_path)
+            out = ffmpeg.output(in1.video, in2.audio, new_path,video_bitrate=self.ffmpeg_video_bitrate,vcodec=self.ffmpeg_video_encoder)
+            out.run(overwrite_output=True,quiet=True)
+        else:
+            new_path = output_video_path
+            print("The video doesn't have audio, so post-processing is not necessary")
+        
+        print(f"The process has finished.\nThe refaced video can be found at {os.path.abspath(new_path)}")
+        return new_path
+
+    def __get_faces(self,frame,max_num=0):
+
+        bboxes, kpss = self.face_detector.detect(frame,max_num=max_num,metric='default')
+
+        if bboxes.shape[0] == 0:
+            return []
+        ret = []
+        for i in range(bboxes.shape[0]):
+            bbox = bboxes[i, 0:4]
+            det_score = bboxes[i, 4]
+            kps = None
+            if kpss is not None:
+                kps = kpss[i]
+            face = Face(bbox=bbox, kps=kps, det_score=det_score)
+            face.embedding = self.rec_app.get(frame, kps)
+            ret.append(face)
+        return ret
+
+    def process_first_face(self,frame):
+        faces = self.__get_faces(frame,max_num=1)
+        if len(faces) != 0:
+            frame = self.face_swapper.get(frame, faces[0], self.replacement_faces[0][1], paste_back=True)
+        return frame
+
+    def process_faces(self,frame):
+        faces = self.__get_faces(frame,max_num=0)
+        for rep_face in self.replacement_faces:
+            for i in range(len(faces) - 1, -1, -1):
+                sim = self.rec_app.compute_sim(rep_face[0], faces[i].embedding)
+                if sim>=rep_face[2]:
+                    frame = self.face_swapper.get(frame, faces[i], rep_face[1], paste_back=True)
+                    del faces[i]
+                    break
+        return frame
+
+    def __check_video_has_audio(self,video_path):
+        self.video_has_audio = False
+        probe = ffmpeg.probe(video_path)
+        audio_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'audio'), None)
+        if audio_stream is not None:
+            self.video_has_audio = True
+        
+    def reface_group(self, faces, frames, output):
+        with ThreadPoolExecutor(max_workers = self.use_num_cpus) as executor:
+            if self.first_face:
+                results = list(tqdm(executor.map(self.process_first_face, frames), total=len(frames),desc="Processing frames"))
+            else:
+                results = list(tqdm(executor.map(self.process_faces, frames), total=len(frames),desc="Processing frames"))
+            for result in results:
+                output.write(result)
+
+    def reface(self, video_path, faces):
+        self.__check_video_has_audio(video_path)
+        output_video_path = os.path.join('out',Path(video_path).name)
+        self.prepare_faces(faces)
+
+        cap = cv2.VideoCapture(video_path)
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        print(f"Total frames: {total_frames}")
+        
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        output = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))
+        
+        frames=[]
+        self.k = 1
+        with tqdm(total=total_frames,desc="Extracting frames") as pbar:
+            while cap.isOpened():
+                flag, frame = cap.read()
+                if flag and len(frame)>0:
+                    frames.append(frame.copy())
+                    pbar.update()
+                else:
+                    break
+                if (len(frames) > 1000):
+                    self.reface_group(faces,frames,output)
+                    frames=[]
+
+            cap.release()
+            pbar.close()
+
+        self.reface_group(faces,frames,output)
+        frames=[]
+        output.release()
+        
+        return self.__convert_video(video_path,output_video_path)
+    
+    def __try_ffmpeg_encoder(self, vcodec):
+        print(f"Trying FFMPEG {vcodec} encoder")
+        command = ['ffmpeg', '-y', '-f','lavfi','-i','testsrc=duration=1:size=1280x720:rate=30','-vcodec',vcodec,'testsrc.mp4']
+        try:
+            subprocess.run(command, check=True, capture_output=True).stderr
+        except subprocess.CalledProcessError as e:
+            print(f"FFMPEG {vcodec} encoder doesn't work -> Disabled.")
+            return False
+        print(f"FFMPEG {vcodec} encoder works")
+        return True
+        
+    def __check_encoders(self):
+        self.ffmpeg_video_encoder='libx264'
+        self.ffmpeg_video_bitrate='0'
+
+        pattern = r"encoders: ([a-zA-Z0-9_]+(?: [a-zA-Z0-9_]+)*)"
+        command = ['ffmpeg', '-codecs', '--list-encoders']
+        commandout = subprocess.run(command, check=True, capture_output=True).stdout
+        result = commandout.decode('utf-8').split('\n')
+        for r in result:
+            if "264" in r: 
+                encoders = re.search(pattern, r).group(1).split(' ')
+                for v_c in Refacer.VIDEO_CODECS:
+                    for v_k in encoders:
+                        if v_c == v_k:
+                            if self.__try_ffmpeg_encoder(v_k):
+                                self.ffmpeg_video_encoder=v_k
+                                self.ffmpeg_video_bitrate=Refacer.VIDEO_CODECS[v_k]
+                                print(f"Video codec for FFMPEG: {self.ffmpeg_video_encoder}")
+                                return
+
+    VIDEO_CODECS = {
+         'h264_videotoolbox':'0', #osx HW acceleration
+         'h264_nvenc':'0', #NVIDIA HW acceleration
+         #'h264_qsv', #Intel HW acceleration
+         #'h264_vaapi', #Intel HW acceleration
+         #'h264_omx', #HW acceleration
+         'libx264':'0' #No HW acceleration
+    }

requirements-COREML.txt

@@ -0,0 +1,12 @@
+ffmpeg_python==0.2.0
+gradio==3.33.1
+insightface==0.7.3
+numpy==1.24.3
+onnx==1.14.0
+onnxruntime-silicon
+opencv_python==4.7.0.72
+opencv_python_headless==4.7.0.72
+scikit-image==0.20.0
+tqdm
+psutil
+ngrok

run.sh.txt

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Refacer Docker setup script
+# Run this script from within the refacer/docker folder.
+
+# --------------------------------------------
+# Step 1: Download the Model if not available
+# --------------------------------------------
+MODEL_URL="https://huggingface.co/ofter/4x-UltraSharp/resolve/main/inswapper_128.onnx"
+MODEL_PATH="../inswapper_128.onnx"
+if [ ! -f "$MODEL_PATH" ]; then
+    echo "Downloading inswapper_128.onnx model..."
+    wget -O "$MODEL_PATH" "$MODEL_URL"
+    if [ $? -ne 0 ]; then
+        echo "Error: Failed to download the model. Please check your internet connection."
+        exit 1
+    fi
+    echo "Model downloaded successfully!"
+else
+    echo "Model already exists at $MODEL_PATH."
+fi
+
+# --------------------------------------------
+# Step 2: Stop Existing Docker Containers
+# --------------------------------------------
+echo "Stopping any running 'refacer' containers..."
+docker stop -t 0 refacer 2>/dev/null || echo "No running container found."
+
+# --------------------------------------------
+# Step 3: Build the Docker Image
+# --------------------------------------------
+echo "Building the Docker image 'refacer' using Dockerfile.nvidia..."
+docker build -t refacer -f Dockerfile.nvidia .
+if [ $? -ne 0 ]; then
+    echo "Error: Docker image build failed."
+    exit 1
+fi
+echo "Docker image built successfully."
+
+# --------------------------------------------
+# Step 4: Run the Docker Container
+# --------------------------------------------
+echo "Starting the Docker container with NVIDIA GPU support..."
+docker run --rm --name refacer \
+    -v $(pwd)/..:/refacer \
+    -p 7860:7860 \
+    --gpus all \
+    refacer python3 app.py --server_name 0.0.0.0 &
+
+# Wait for the server to start
+echo "Waiting for the Refacer server to start..."
+sleep 5
+
+# --------------------------------------------
+# Step 5: Open Browser Automatically
+# --------------------------------------------
+echo "Opening Refacer UI in your browser..."
+if command -v google-chrome >/dev/null 2>&1; then
+    google-chrome --new-window "http://127.0.0.1:7860" &
+elif command -v xdg-open >/dev/null 2>&1; then
+    xdg-open "http://127.0.0.1:7860" &
+elif command -v open >/dev/null 2>&1; then
+    open "http://127.0.0.1:7860" &
+else
+    echo "Please open your browser and navigate to: http://127.0.0.1:7860"
+fi

scrfd.py.txt

@@ -0,0 +1,329 @@
+
+from __future__ import division
+import datetime
+import numpy as np
+#import onnx
+import onnxruntime
+import os
+import os.path as osp
+import cv2
+import sys
+
+def softmax(z):
+    assert len(z.shape) == 2
+    s = np.max(z, axis=1)
+    s = s[:, np.newaxis] # necessary step to do broadcasting
+    e_x = np.exp(z - s)
+    div = np.sum(e_x, axis=1)
+    div = div[:, np.newaxis] # dito
+    return e_x / div
+
+def distance2bbox(points, distance, max_shape=None):
+    """Decode distance prediction to bounding box.
+
+    Args:
+        points (Tensor): Shape (n, 2), [x, y].
+        distance (Tensor): Distance from the given point to 4
+            boundaries (left, top, right, bottom).
+        max_shape (tuple): Shape of the image.
+
+    Returns:
+        Tensor: Decoded bboxes.
+    """
+    x1 = points[:, 0] - distance[:, 0]
+    y1 = points[:, 1] - distance[:, 1]
+    x2 = points[:, 0] + distance[:, 2]
+    y2 = points[:, 1] + distance[:, 3]
+    if max_shape is not None:
+        x1 = x1.clamp(min=0, max=max_shape[1])
+        y1 = y1.clamp(min=0, max=max_shape[0])
+        x2 = x2.clamp(min=0, max=max_shape[1])
+        y2 = y2.clamp(min=0, max=max_shape[0])
+    return np.stack([x1, y1, x2, y2], axis=-1)
+
+def distance2kps(points, distance, max_shape=None):
+    """Decode distance prediction to bounding box.
+
+    Args:
+        points (Tensor): Shape (n, 2), [x, y].
+        distance (Tensor): Distance from the given point to 4
+            boundaries (left, top, right, bottom).
+        max_shape (tuple): Shape of the image.
+
+    Returns:
+        Tensor: Decoded bboxes.
+    """
+    preds = []
+    for i in range(0, distance.shape[1], 2):
+        px = points[:, i%2] + distance[:, i]
+        py = points[:, i%2+1] + distance[:, i+1]
+        if max_shape is not None:
+            px = px.clamp(min=0, max=max_shape[1])
+            py = py.clamp(min=0, max=max_shape[0])
+        preds.append(px)
+        preds.append(py)
+    return np.stack(preds, axis=-1)
+
+class SCRFD:
+    def __init__(self, model_file=None, session=None):
+        import onnxruntime
+        self.model_file = model_file
+        self.session = session
+        self.taskname = 'detection'
+        self.batched = False
+        if self.session is None:
+            assert self.model_file is not None
+            assert osp.exists(self.model_file)
+            self.session = onnxruntime.InferenceSession(self.model_file, providers=['CoreMLExecutionProvider','CUDAExecutionProvider'])
+        self.center_cache = {}
+        self.nms_thresh = 0.4
+        self.det_thresh = 0.5
+        self._init_vars()
+
+    def _init_vars(self):
+        input_cfg = self.session.get_inputs()[0]
+        input_shape = input_cfg.shape
+        #print(input_shape)
+        if isinstance(input_shape[2], str):
+            self.input_size = None
+        else:
+            self.input_size = tuple(input_shape[2:4][::-1])
+        #print('image_size:', self.image_size)
+        input_name = input_cfg.name
+        self.input_shape = input_shape
+        outputs = self.session.get_outputs()
+        if len(outputs[0].shape) == 3:
+            self.batched = True
+        output_names = []
+        for o in outputs:
+            output_names.append(o.name)
+        self.input_name = input_name
+        self.output_names = output_names
+        self.input_mean = 127.5
+        self.input_std = 128.0
+        #print(self.output_names)
+        #assert len(outputs)==10 or len(outputs)==15
+        self.use_kps = False
+        self._anchor_ratio = 1.0
+        self._num_anchors = 1
+        if len(outputs)==6:
+            self.fmc = 3
+            self._feat_stride_fpn = [8, 16, 32]
+            self._num_anchors = 2
+        elif len(outputs)==9:
+            self.fmc = 3
+            self._feat_stride_fpn = [8, 16, 32]
+            self._num_anchors = 2
+            self.use_kps = True
+        elif len(outputs)==10:
+            self.fmc = 5
+            self._feat_stride_fpn = [8, 16, 32, 64, 128]
+            self._num_anchors = 1
+        elif len(outputs)==15:
+            self.fmc = 5
+            self._feat_stride_fpn = [8, 16, 32, 64, 128]
+            self._num_anchors = 1
+            self.use_kps = True
+
+    def prepare(self, ctx_id, **kwargs):
+        if ctx_id<0:
+            self.session.set_providers(['CPUExecutionProvider'])
+        nms_thresh = kwargs.get('nms_thresh', None)
+        if nms_thresh is not None:
+            self.nms_thresh = nms_thresh
+        det_thresh = kwargs.get('det_thresh', None)
+        if det_thresh is not None:
+            self.det_thresh = det_thresh
+        input_size = kwargs.get('input_size', None)
+        if input_size is not None:
+            if self.input_size is not None:
+                print('warning: det_size is already set in scrfd model, ignore')
+            else:
+                self.input_size = input_size
+
+    def forward(self, img, threshold):
+        scores_list = []
+        bboxes_list = []
+        kpss_list = []
+        input_size = tuple(img.shape[0:2][::-1])
+        blob = cv2.dnn.blobFromImage(img, 1.0/self.input_std, input_size, (self.input_mean, self.input_mean, self.input_mean), swapRB=True)
+        net_outs = self.session.run(self.output_names, {self.input_name : blob})
+
+        input_height = blob.shape[2]
+        input_width = blob.shape[3]
+        fmc = self.fmc
+        for idx, stride in enumerate(self._feat_stride_fpn):
+            # If model support batch dim, take first output
+            if self.batched:
+                scores = net_outs[idx][0]
+                bbox_preds = net_outs[idx + fmc][0]
+                bbox_preds = bbox_preds * stride
+                if self.use_kps:
+                    kps_preds = net_outs[idx + fmc * 2][0] * stride
+            # If model doesn't support batching take output as is
+            else:
+                scores = net_outs[idx]
+                bbox_preds = net_outs[idx + fmc]
+                bbox_preds = bbox_preds * stride
+                if self.use_kps:
+                    kps_preds = net_outs[idx + fmc * 2] * stride
+
+            height = input_height // stride
+            width = input_width // stride
+            K = height * width
+            key = (height, width, stride)
+            if key in self.center_cache:
+                anchor_centers = self.center_cache[key]
+            else:
+                #solution-1, c style:
+                #anchor_centers = np.zeros( (height, width, 2), dtype=np.float32 )
+                #for i in range(height):
+                #    anchor_centers[i, :, 1] = i
+                #for i in range(width):
+                #    anchor_centers[:, i, 0] = i
+
+                #solution-2:
+                #ax = np.arange(width, dtype=np.float32)
+                #ay = np.arange(height, dtype=np.float32)
+                #xv, yv = np.meshgrid(np.arange(width), np.arange(height))
+                #anchor_centers = np.stack([xv, yv], axis=-1).astype(np.float32)
+
+                #solution-3:
+                anchor_centers = np.stack(np.mgrid[:height, :width][::-1], axis=-1).astype(np.float32)
+                #print(anchor_centers.shape)
+
+                anchor_centers = (anchor_centers * stride).reshape( (-1, 2) )
+                if self._num_anchors>1:
+                    anchor_centers = np.stack([anchor_centers]*self._num_anchors, axis=1).reshape( (-1,2) )
+                if len(self.center_cache)<100:
+                    self.center_cache[key] = anchor_centers
+
+            pos_inds = np.where(scores>=threshold)[0]
+            bboxes = distance2bbox(anchor_centers, bbox_preds)
+            pos_scores = scores[pos_inds]
+            pos_bboxes = bboxes[pos_inds]
+            scores_list.append(pos_scores)
+            bboxes_list.append(pos_bboxes)
+            if self.use_kps:
+                kpss = distance2kps(anchor_centers, kps_preds)
+                #kpss = kps_preds
+                kpss = kpss.reshape( (kpss.shape[0], -1, 2) )
+                pos_kpss = kpss[pos_inds]
+                kpss_list.append(pos_kpss)
+        return scores_list, bboxes_list, kpss_list
+
+    def detect(self, img, input_size = None, thresh=None, max_num=0, metric='default'):
+        assert input_size is not None or self.input_size is not None
+        input_size = self.input_size if input_size is None else input_size
+            
+        im_ratio = float(img.shape[0]) / img.shape[1]
+        model_ratio = float(input_size[1]) / input_size[0]
+        if im_ratio>model_ratio:
+            new_height = input_size[1]
+            new_width = int(new_height / im_ratio)
+        else:
+            new_width = input_size[0]
+            new_height = int(new_width * im_ratio)
+        det_scale = float(new_height) / img.shape[0]
+        resized_img = cv2.resize(img, (new_width, new_height))
+        det_img = np.zeros( (input_size[1], input_size[0], 3), dtype=np.uint8 )
+        det_img[:new_height, :new_width, :] = resized_img
+        det_thresh = thresh if thresh is not None else self.det_thresh
+
+        scores_list, bboxes_list, kpss_list = self.forward(det_img, det_thresh)
+
+        scores = np.vstack(scores_list)
+        scores_ravel = scores.ravel()
+        order = scores_ravel.argsort()[::-1]
+        bboxes = np.vstack(bboxes_list) / det_scale
+        if self.use_kps:
+            kpss = np.vstack(kpss_list) / det_scale
+        pre_det = np.hstack((bboxes, scores)).astype(np.float32, copy=False)
+        pre_det = pre_det[order, :]
+        keep = self.nms(pre_det)
+        det = pre_det[keep, :]
+        if self.use_kps:
+            kpss = kpss[order,:,:]
+            kpss = kpss[keep,:,:]
+        else:
+            kpss = None
+        if max_num > 0 and det.shape[0] > max_num:
+            area = (det[:, 2] - det[:, 0]) * (det[:, 3] -
+                                                    det[:, 1])
+            img_center = img.shape[0] // 2, img.shape[1] // 2
+            offsets = np.vstack([
+                (det[:, 0] + det[:, 2]) / 2 - img_center[1],
+                (det[:, 1] + det[:, 3]) / 2 - img_center[0]
+            ])
+            offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
+            if metric=='max':
+                values = area
+            else:
+                values = area - offset_dist_squared * 2.0  # some extra weight on the centering
+            bindex = np.argsort(
+                values)[::-1]  # some extra weight on the centering
+            bindex = bindex[0:max_num]
+            det = det[bindex, :]
+            if kpss is not None:
+                kpss = kpss[bindex, :]
+        return det, kpss
+
+    def autodetect(self, img, max_num=0, metric='max'):
+        bboxes, kpss = self.detect(img, input_size=(640, 640), thresh=0.5)
+        bboxes2, kpss2 = self.detect(img, input_size=(128, 128), thresh=0.5)
+        bboxes_all = np.concatenate([bboxes, bboxes2], axis=0)
+        kpss_all = np.concatenate([kpss, kpss2], axis=0)
+        keep = self.nms(bboxes_all)
+        det = bboxes_all[keep,:]
+        kpss = kpss_all[keep,:]
+        if max_num > 0 and det.shape[0] > max_num:
+            area = (det[:, 2] - det[:, 0]) * (det[:, 3] -
+                                                    det[:, 1])
+            img_center = img.shape[0] // 2, img.shape[1] // 2
+            offsets = np.vstack([
+                (det[:, 0] + det[:, 2]) / 2 - img_center[1],
+                (det[:, 1] + det[:, 3]) / 2 - img_center[0]
+            ])
+            offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
+            if metric=='max':
+                values = area
+            else:
+                values = area - offset_dist_squared * 2.0  # some extra weight on the centering
+            bindex = np.argsort(
+                values)[::-1]  # some extra weight on the centering
+            bindex = bindex[0:max_num]
+            det = det[bindex, :]
+            if kpss is not None:
+                kpss = kpss[bindex, :]
+        return det, kpss
+
+    def nms(self, dets):
+        thresh = self.nms_thresh
+        x1 = dets[:, 0]
+        y1 = dets[:, 1]
+        x2 = dets[:, 2]
+        y2 = dets[:, 3]
+        scores = dets[:, 4]
+
+        areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+        order = scores.argsort()[::-1]
+
+        keep = []
+        while order.size > 0:
+            i = order[0]
+            keep.append(i)
+            xx1 = np.maximum(x1[i], x1[order[1:]])
+            yy1 = np.maximum(y1[i], y1[order[1:]])
+            xx2 = np.minimum(x2[i], x2[order[1:]])
+            yy2 = np.minimum(y2[i], y2[order[1:]])
+
+            w = np.maximum(0.0, xx2 - xx1 + 1)
+            h = np.maximum(0.0, yy2 - yy1 + 1)
+            inter = w * h
+            ovr = inter / (areas[i] + areas[order[1:]] - inter)
+
+            inds = np.where(ovr <= thresh)[0]
+            order = order[inds + 1]
+
+        return keep
+

script.py.txt

@@ -0,0 +1,41 @@
+from refacer import Refacer
+from os.path import exists
+import argparse
+import cv2
+
+parser = argparse.ArgumentParser(description='Refacer')
+parser.add_argument("--force_cpu", help="Force CPU mode", default=False, action="store_true")
+parser.add_argument("--colab_performance", help="Use in colab for better performance", default=False,action="store_true")
+parser.add_argument("--face", help="Face to replace (ex: <src>,<dst>,<thresh=0.2>)", nargs='+', action="append", required=True)
+parser.add_argument("--video", help="Video to parse", required=True)
+args = parser.parse_args()
+
+refacer = Refacer(force_cpu=args.force_cpu,colab_performance=args.colab_performance)
+
+def run(video_path,faces):
+    video_path_exists = exists(video_path)
+    if video_path_exists == False:
+        print ("Can't find " + video_path)
+        return
+
+    faces_out = []
+    for face in faces:
+        face_str = face[0].split(",")
+        origin = exists(face_str[0])
+        if origin == False:
+            print ("Can't find " + face_str[0])
+            return
+        destination = exists(face_str[1])
+        if destination == False:
+            print ("Can't find " + face_str[1])
+            return
+        
+        faces_out.append({
+                'origin':cv2.imread(face_str[0]),
+                'destination':cv2.imread(face_str[1]),
+                'threshold':float(face_str[2])
+            })
+
+    return refacer.reface(video_path,faces_out)
+
+run(args.video, args.face)