Как установить face recognition на windows - Windowsa.top - ваш верный помощник с OS Windows

Last Updated :
26 Oct, 2021

In this article, we will learn how to install Face Recognition in Python on Windows. Recognize and manipulate faces from Python or from the command line with the world’s simplest face recognition library. Built using dlib’s state-of-the-art face recognition built with deep learning.

Installing Face Recognition on Windows :

Prerequisites:

Face Recognition module can only be installed for Python version 3.7 and 3.8.

Step 1: Install git for Windows

Step 2: Clone this repository and go inside the folder using the following commands

git clone https://github.com/RvTechiNNovate/face_recog_dlib_file.git
cd face_recog_dlib_file

Step 3: Enter the following command to install dlib and cmake using pip

Python 3.7:
pip install dlib-19.19.0-cp37-cp37m-win_amd64.whl

Python 3.8:
pip install dlib-19.19.0-cp38-cp38-win_amd64.whl

pip install cmake

Method 1: Using pip to install Face Recognition Package

Follow the below steps to install the Face Recognition package on Windows using pip:

Step 1: Install the latest Python3 in Windows

Step 2: Check if pip and python are correctly installed.

python --version
pip --version

checking python and pip version in Windows

Step 3: Upgrade your pip to avoid errors during installation.

pip install --upgrade pip

Step 4: Enter the following command to install Face Recognition using pip3.

pip install face-recognition

Method 2: Using setup.py to install Face Recognition

Follow the below steps to install the Face Recognition on Windows using the setup.py file:

Step 1: Download the latest source package of Face Recognition for python3 from here.

curl https://files.pythonhosted.org/packages/6c/49/75dda409b94841f01cbbc34114c9b67ec618265084e4d12d37ab838f4fd3/face_recognition-1.3.0.tar.gz > face_recognition-1.3.0.tar.gz

downloading the source package for Face Recognition in Windows

Step 2: Extract the downloaded package using the following command.

tar -xzvf face_recognition-1.3.0.tar.gz

extracting the face_recognition-1.3.0.tar.gz file in Windows

Step 3: Go inside the folder and Enter the following command to install the package.

cd face_recognition-1.3.0
python setup.py install

installing Face Recognition on Windows using the setup.py file

Verifying Face Recognition installation on Windows :

Make the following import in your python terminal to verify if the installation has been done properly:

import face_recognition

Verifying Face Recognition installation on Windows

If there is any error while importing the module then is not installed properly.

Источник

Step-by-Step Guide: Install Face Recognition on Windows 11

Table of Contents

Introduction
Installing Python on Windows 11
What is Facial Recognition?
Setting Up a Virtual Environment
Installing CMake for DLib
Installing Face Recognition
testing Face Recognition
Troubleshooting and Compatibility Issues
Using Git for Cloning Repositories
Conclusion

Introduction

In this article, we will guide you through the process of installing facial recognition for Python on Windows 11. Facial recognition technology is becoming increasingly popular and is used in various applications such as security systems and social media filters. By following the step-by-step instructions provided, even beginners can install and use facial recognition on their Windows 11 machines.

Installing Python on Windows 11

Before we can proceed with the installation of facial recognition, we need to ensure that Python is installed on our machine. We will begin by checking if Python is already installed and if not, we will download and install the latest version from python.org. Python is essential for running facial recognition algorithms, so it is important to have it set up correctly.

What is Facial Recognition?

Facial recognition is a technology that uses biometrics to identify and verify individuals by analyzing their facial features. It compares specific facial landmarks and Patterns captured from an image or video with a database of known faces. This technology has seen widespread adoption in various industries, including law enforcement, access control systems, and social media applications.

Setting Up a Virtual Environment

To ensure a clean and isolated environment for installing facial recognition, we will set up a virtual environment using Python’s built-in venv module. A virtual environment allows us to create separate environments with their own Python packages and dependencies, avoiding conflicts between different projects. This step is crucial for beginners as it helps maintain a clean and organized development environment.

Installing CMake for DLib

In order to install facial recognition, we need to install the DLib library, which is a popular open-source library used for various computer vision tasks. However, before we can install DLib, we need to install CMake, a cross-platform build system, as it is required for compiling DLib from source. We will guide you through the process of downloading and installing CMake to ensure a smooth installation of facial recognition.

Installing Face Recognition

With Python, the virtual environment, and CMake set up correctly, we can now proceed to install the face recognition library. Face recognition is a Python Package that provides a simple interface for facial recognition tasks, including face detection, face landmarks, and face recognition. We will use the pip package manager to install face recognition and ensure that it is successfully added to our virtual environment.

Testing Face Recognition

Once face recognition is installed, we can test its functionality by running a simple script that demonstrates face detection and landmark detection. We will provide you with the code to load an image, detect faces in the image, and Visualize the facial landmarks. This will help you verify if the installation was successful and if face recognition is working as expected on your Windows 11 machine.

Troubleshooting and Compatibility Issues

During the installation process, you may encounter some errors or compatibility issues. We will address common troubleshooting steps and provide solutions to resolve potential problems. This includes issues related to version compatibility, installation of dependencies, and error messages encountered during the installation process.

Using Git for Cloning Repositories

Many developers use Git for version control and collaboration. If you are having trouble cloning repositories or understanding the basic concepts of Git, we will guide you through the process of installing Git on Windows 11 and provide an overview of basic Git commands. Git is an essential tool for managing code repositories and collaborating with other developers.

Conclusion

In conclusion, installing facial recognition for Python on Windows 11 is not a complicated task, even for beginners. By following our step-by-step instructions and troubleshooting tips, you can successfully set up and use facial recognition technology on your Windows 11 machine. Facial recognition has various applications and can be a valuable tool in the field of computer vision and biometrics. With this installation guide, you will be ready to explore the possibilities of facial recognition technology and integrate it into your own projects.

🔍 Highlights:

Install facial recognition for Python on Windows 11
Set up a virtual environment for clean and isolated development
Install CMake and DLib for facial recognition dependencies
Use the face recognition library for face detection and recognition
Troubleshoot installation and compatibility issues
Use Git for version control and collaboration

FAQ:

Q: Can I install facial recognition on operating systems other than Windows 11?
A: While this article specifically focuses on installing facial recognition on Windows 11, the steps for installation may be similar for other operating systems such as Mac or Ubuntu. However, it is recommended to refer to the official documentation for specific instructions related to your operating system.

Q: Can I use facial recognition without installing Python?
A: No, Python is required to run facial recognition algorithms. It is essential to have Python installed on your machine before proceeding with the installation of facial recognition.

Q: Are there any compatibility issues with the latest version of Python (3.11)?
A: Compatibility issues may arise when installing facial recognition on the latest version of Python. It is recommended to refer to the documentation or seek community support for updated installation instructions for Python 3.11. Alternatively, you can consider using Python 3.8, which is known to work well with facial recognition.

Q: What are the potential applications of facial recognition technology?
A: Facial recognition technology has a wide range of applications, including but not limited to security systems, access control, surveillance, identity verification, and social media filters. It is constantly evolving and finding new applications in various industries.

Q: Is facial recognition technology secure?
A: Facial recognition technology can be secure when implemented correctly and with proper privacy measures. However, it is important to address privacy concerns and ensure compliance with legal and ethical requirements when using facial recognition technology.

Источник

How to install face recognition on windows

This guide is inaccurate, out of date, and will likely not work.

This guide will help you install @ageitgey’s python face_recognition module on windows.

Prerequisities

You will need python 3.6 or older. (At the time of writing — will update when required)
dlib, one of face_recognition‘s dependencies doesn’t support 3.7 yet.

You will also need visual studio with cmake compilation tools.

Installing

Step one

Install cmake.
To do this, download a graphical installer from cmake.org/downloads.

When installing, make sure to tick the box add cmake to path for all users, or this guide won’t work.

Step two — installing dlib and face_recogntion modules

There are multiple ways to do this.

Way one (recommended if you have more than one version of python installed)

Create a new virtual enviroment running 3.6 or older — if you don’t know how, there are plenty of tutorials avialable online.

Run path\to\venv\python.exe -m pip install dlib and wait for this to run — it took ten minutes on my intel i7 core, and made the fan go crazy, so be prepared to wait

If it completes without any errors, you’re all set. Run path\to\venv\python.exe -m pip install face_recognition to install face_recognition.

Way two (recommended if you have only one version of python installed (3.6 or older))

Run pip install dlib and wait for this to run — it took ten minutes on my intel i7 core, and made the fan go crazy, so be prepared to wait

If it completes without any errors, you’re all set. Run pip install face_recognition to install face_recognition.

Done!

I hope this guide helps you install dlib and face_recognntion on your windows machine.
If you have any problems, please let me know in the comments below.

Источник

Recognize and manipulate faces from Python or from the command line
with

the world’s simplest face recognition library.

Built using dlib’s state-of-the-art face
recognition

built with deep learning. The model has an accuracy of 99.38% on the

This also provides a simple face_recognition command line tool
that lets

you do face recognition on a folder of images from the command line!

Features

Find faces in pictures

Find all the faces that appear in a picture:

import face_recognition
image = face_recognition.load_image_file("your_file.jpg")
face_locations = face_recognition.face_locations(image)

Find and manipulate facial features in pictures

Get the locations and outlines of each person’s eyes, nose, mouth and
chin.

import face_recognition
image = face_recognition.load_image_file("your_file.jpg")
face_landmarks_list = face_recognition.face_landmarks(image)

Finding facial features is super useful for lots of important stuff.
But you can also use for really stupid stuff

Identify faces in pictures

Recognize who appears in each photo.

import face_recognition
known_image = face_recognition.load_image_file("biden.jpg")
unknown_image = face_recognition.load_image_file("unknown.jpg")

biden_encoding = face_recognition.face_encodings(known_image)[0]
unknown_encoding = face_recognition.face_encodings(unknown_image)[0]

results = face_recognition.compare_faces([biden_encoding], unknown_encoding)

You can even use this library with other Python libraries to do
real-time face recognition:

See this
example
for the code.

Installation

Requirements

Python 3.3+ or Python 2.7
macOS or Linux (Windows not officially supported, but might work)

Installing on Mac or Linux

First, make sure you have dlib already installed with Python bindings:

How to install dlib from source on macOS or
Ubuntu

Then, install this module from pypi using pip3 (or pip2 for
Python 2):

pip3 install face_recognition

If you are having trouble with installation, you can also try out a

Installing on Raspberry Pi 2+

Raspberry Pi 2+ installation
instructions

Installing on Windows

While Windows isn’t officially supported, helpful users have posted
instructions on how to install this library:

@masoudr’s Windows 10 installation guide (dlib +
face_recognition)

Installing a pre-configured Virtual Machine image

Download the pre-configured VM
image
(for VMware Player or VirtualBox).

Usage

Command-Line Interface

When you install face_recognition, you get a simple command-line
program

called face_recognition that you can use to recognize faces in a

photograph or folder full for photographs.

First, you need to provide a folder with one picture of each person
you

already know. There should be one image file for each person with the

files named according to who is in the picture:

Next, you need a second folder with the files you want to identify:

Then in you simply run the command face_recognition, passing in

the folder of known people and the folder (or single image) with
unknown

people and it tells you who is in each image:

$ face_recognition ./pictures_of_people_i_know/ ./unknown_pictures/

/unknown_pictures/unknown.jpg,Barack Obama
/face_recognition_test/unknown_pictures/unknown.jpg,unknown_person

There’s one line in the output for each face. The data is
comma-separated

with the filename and the name of the person found.

An unknown_person is a face in the image that didn’t match anyone
in

your folder of known people.

Adjusting Tolerance / Sensitivity

If you are getting multiple matches for the same person, it might be
that

the people in your photos look very similar and a lower tolerance
value

is needed to make face comparisons more strict.

You can do that with the —tolerance parameter. The default
tolerance

value is 0.6 and lower numbers make face comparisons more strict:

$ face_recognition --tolerance 0.54 ./pictures_of_people_i_know/ ./unknown_pictures/

/unknown_pictures/unknown.jpg,Barack Obama
/face_recognition_test/unknown_pictures/unknown.jpg,unknown_person

If you want to see the face distance calculated for each match in
order

to adjust the tolerance setting, you can use —show-distance true:

$ face_recognition --show-distance true ./pictures_of_people_i_know/ ./unknown_pictures/

/unknown_pictures/unknown.jpg,Barack Obama,0.378542298956785
/face_recognition_test/unknown_pictures/unknown.jpg,unknown_person,None

More Examples

If you simply want to know the names of the people in each photograph
but don’t

care about file names, you could do this:

$ face_recognition ./pictures_of_people_i_know/ ./unknown_pictures/ | cut -d ',' -f2

Barack Obama
unknown_person

Speeding up Face Recognition

Face recognition can be done in parallel if you have a computer with

multiple CPU cores. For example if your system has 4 CPU cores, you
can

process about 4 times as many images in the same amount of time by
using

all your CPU cores in parallel.

If you are using Python 3.4 or newer, pass in a
—cpus <number_of_cpu_cores_to_use> parameter:

$ face_recognition --cpus 4 ./pictures_of_people_i_know/ ./unknown_pictures/

You can also pass in —cpus -1 to use all CPU cores in your system.

Python Module

You can import the face_recognition module and then easily
manipulate

faces with just a couple of lines of code. It’s super easy!

API Docs:
https://face-recognition.readthedocs.io.

Automatically find all the faces in an image

import face_recognition

image = face_recognition.load_image_file("my_picture.jpg")
face_locations = face_recognition.face_locations(image)

# face_locations is now an array listing the co-ordinates of each face!

You can also opt-in to a somewhat more accurate deep-learning-based face
detection model.

Note: GPU acceleration (via nvidia’s CUDA library) is required for
good

performance with this model. You’ll also want to enable CUDA support

when compliling dlib.

import face_recognition

image = face_recognition.load_image_file("my_picture.jpg")
face_locations = face_recognition.face_locations(image, model="cnn")

# face_locations is now an array listing the co-ordinates of each face!

If you have a lot of images and a GPU, you can also

Automatically locate the facial features of a person in an image

import face_recognition

image = face_recognition.load_image_file("my_picture.jpg")
face_landmarks_list = face_recognition.face_landmarks(image)

# face_landmarks_list is now an array with the locations of each facial feature in each face.
# face_landmarks_list[0]['left_eye'] would be the location and outline of the first person's left eye.

Recognize faces in images and identify who they are

import face_recognition

picture_of_me = face_recognition.load_image_file("me.jpg")
my_face_encoding = face_recognition.face_encodings(picture_of_me)[0]

# my_face_encoding now contains a universal 'encoding' of my facial features that can be compared to any other picture of a face!

unknown_picture = face_recognition.load_image_file("unknown.jpg")
unknown_face_encoding = face_recognition.face_encodings(unknown_picture)[0]

# Now we can see the two face encodings are of the same person with `compare_faces`!

results = face_recognition.compare_faces([my_face_encoding], unknown_face_encoding)

if results[0] == True:
    print("It's a picture of me!")
else:
    print("It's not a picture of me!")

Python Code Examples

All the examples are available
here.

Face Detection

Find faces in a
photograph
Find faces in a photograph (using deep
learning)
Find faces in batches of images w/ GPU (using deep
learning)

Facial Features

Identify specific facial features in a
photograph
Apply (horribly ugly) digital
make-up

Facial Recognition

Find and recognize unknown faces in a photograph based on
photographs of known
people
Compare faces by numeric face distance instead of only True/False
matches
Recognize faces in live video using your webcam — Simple / Slower
Version (Requires OpenCV to be
installed)
Recognize faces in live video using your webcam — Faster Version
(Requires OpenCV to be
installed)
Recognize faces in a video file and write out new video file
(Requires OpenCV to be
installed)
Recognize faces on a Raspberry Pi w/
camera
Run a web service to recognize faces via HTTP (Requires Flask to be
installed)
Recognize faces with a K-nearest neighbors
classifier

How Face Recognition Works

If you want to learn how face location and recognition work instead of

Caveats

The face recognition model is trained on adults and does not work
very well on children. It tends to mix
up children quite easy using the default comparison threshold of 0.6.

Deployment to Cloud Hosts (Heroku, AWS, etc)

Since face_recognition depends on dlib which is written in
C++, it can be tricky to deploy an app

using it to a cloud hosting provider like Heroku or AWS.

To make things easier, there’s an example Dockerfile in this repo that
shows how to run an app built with

face_recognition in a Docker
container. With that, you should be able to deploy

to any service that supports Docker images.

Common Issues

Issue: Illegal instruction (core dumped) when using
face_recognition or running examples.

Solution: dlib is compiled with SSE4 or AVX support, but your CPU
is too old and doesn’t support that.

Issue:
RuntimeError: Unsupported image type, must be 8bit gray or RGB image.
when running the webcam examples.

Solution: Your webcam probably isn’t set up correctly with OpenCV. Look
here for
more.

Issue: MemoryError when running pip2 install face_recognition

Solution: The face_recognition_models file is too big for your
available pip cache memory. Instead,

try pip2 —no-cache-dir install face_recognition to avoid the
issue.

Issue:
AttributeError: ‘module’ object has no attribute ‘face_recognition_model_v1’

Solution: The version of dlib you have installed is too old. You
need version 19.7 or newer. Upgrade dlib.

Issue:
Attribute Error: ‘Module’ object has no attribute ‘cnn_face_detection_model_v1’

Solution: The version of dlib you have installed is too old. You
need version 19.7 or newer. Upgrade dlib.

Issue: TypeError: imread() got an unexpected keyword argument ‘mode’

Solution: The version of scipy you have installed is too old. You
need version 0.17 or newer. Upgrade scipy.

Thanks

Many, many thanks to Davis King
(@nulhom)
for creating dlib and for providing the trained facial feature
detection and face encoding models
used in this library. For more information on the ResNet that powers
the face encodings, check out
his blog
post.
Thanks to everyone who works on all the awesome Python data science
libraries like numpy, scipy, scikit-image,
pillow, etc, etc that makes this kind of stuff so easy and fun in
Python.
Thanks to Cookiecutter
and the
audreyr/cookiecutter-pypackage
project template
for making Python project packaging way more tolerable.

History

1.2.3 (2018-08-21)

You can now pass model=”small” to face_landmarks() to use the 5-point face model instead of the 68-point model.
Now officially supporting Python 3.7
New example of using this library in a Jupyter Notebook

1.2.2 (2018-04-02)

Added the face_detection CLI command
Removed dependencies on scipy to make installation easier
Cleaned up KNN example and fixed a bug with drawing fonts to label detected faces in the demo

1.2.1 (2018-02-01)

Fixed version numbering inside of module code.

1.2.0 (2018-02-01)

Fixed a bug where batch size parameter didn’t work correctly when doing batch face detections on GPU.
Updated OpenCV examples to do proper BGR -> RGB conversion
Updated webcam examples to avoid common mistakes and reduce support questions
Added a KNN classification example
Added an example of automatically blurring faces in images or videos
Updated Dockerfile example to use dlib v19.9 which removes the boost dependency.

1.1.0 (2017-09-23)

Will use dlib’s 5-point face pose estimator when possible for speed (instead of 68-point face pose esimator)
dlib v19.7 is now the minimum required version
face_recognition_models v0.3.0 is now the minimum required version

1.0.0 (2017-08-29)

Added support for dlib’s CNN face detection model via model=”cnn” parameter on face detecion call
Added support for GPU batched face detections using dlib’s CNN face detector model
Added find_faces_in_picture_cnn.py to examples
Added find_faces_in_batches.py to examples
Added face_rec_from_video_file.py to examples
dlib v19.5 is now the minimum required version
face_recognition_models v0.2.0 is now the minimum required version

0.2.2 (2017-07-07)

Added –show-distance to cli
Fixed a bug where –tolerance was ignored in cli if testing a single image
Added benchmark.py to examples

0.2.1 (2017-07-03)

Added –tolerance to cli

0.2.0 (2017-06-03)

The CLI can now take advantage of multiple CPUs. Just pass in the -cpus X parameter where X is the number of CPUs to use.
Added face_distance.py example
Improved CLI tests to actually test the CLI functionality
Updated facerec_on_raspberry_pi.py to capture in rgb (not bgr) format.

0.1.14 (2017-04-22)

Fixed a ValueError crash when using the CLI on Python 2.7

0.1.13 (2017-04-20)

Raspberry Pi support.

0.1.12 (2017-04-13)

Fixed: Face landmarks wasn’t returning all chin points.

0.1.11 (2017-03-30)

Fixed a minor bug in the command-line interface.

0.1.10 (2017-03-21)

Minor pref improvements with face comparisons.
Test updates.

0.1.9 (2017-03-16)

Fix minimum scipy version required.

0.1.8 (2017-03-16)

Fix missing Pillow dependency.

0.1.7 (2017-03-13)

First working release.

Источник

Рамис, ошибка:

Microsoft Windows [Version 10.0.17763.2114]
(c) Корпорация Майкрософт (Microsoft Corporation), 2018. Все права защищены.

C:\Users\Дом>pip install face-recognition
Collecting face-recognition
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/1e/95/f6c9330f54ab07bfa032bf3715c12455a381083125d8880c43cbe76bb3d0/face_recognition-1.3.0-py2.py3-none-any.whl
Collecting Pillow (from face-recognition)
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/ea/93/23b8524c64790729ba443b49462012a817c0152f2b78105331140f9da1b9/Pillow-8.3.2-cp36-cp36m-win_amd64.whl (3.2MB)
    100% |████████████████████████████████| 3.2MB 361kB/s
Collecting dlib>=19.7 (from face-recognition)
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/f0/a2/ba6163c09fb427990180afd8d625bcecc5555af699c253193c35ffd48c4f/dlib-19.22.1.tar.gz (7.4MB)
    100% |████████████████████████████████| 7.4MB 156kB/s
Collecting face-recognition-models>=0.3.0 (from face-recognition)
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/cf/3b/4fd8c534f6c0d1b80ce0973d01331525538045084c73c153ee6df20224cf/face_recognition_models-0.3.0.tar.gz (100.1MB)
    100% |████████████████████████████████| 100.2MB 10.0kB/s
Collecting Click>=6.0 (from face-recognition)
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/76/0a/b6c5f311e32aeb3b406e03c079ade51e905ea630fc19d1262a46249c1c86/click-8.0.1-py3-none-any.whl (97kB)
    100% |████████████████████████████████| 102kB 4.7MB/s
Collecting numpy (from face-recognition)
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/ea/bc/da526221bc111857c7ef39c3af670bbcf5e69c247b0d22e51986f6d0c5c2/numpy-1.19.5-cp36-cp36m-win_amd64.whl (13.2MB)
    100% |████████████████████████████████| 13.2MB 88kB/s
Collecting importlib-metadata; python_version < "3.8" (from Click>=6.0->face-recognition)
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/71/c2/cb1855f0b2a0ae9ccc9b69f150a7aebd4a8d815bd951e74621c4154c52a8/importlib_metadata-4.8.1-py3-none-any.whl
Collecting colorama; platform_system == "Windows" (from Click>=6.0->face-recognition)
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/44/98/5b86278fbbf250d239ae0ecb724f8572af1c91f4a11edf4d36a206189440/colorama-0.4.4-py2.py3-none-any.whl
Collecting zipp>=0.5 (from importlib-metadata; python_version < "3.8"->Click>=6.0->face-recognition)
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/92/d9/89f433969fb8dc5b9cbdd4b4deb587720ec1aeb59a020cf15002b9593eef/zipp-3.5.0-py3-none-any.whl
Collecting typing-extensions>=3.6.4; python_version < "3.8" (from importlib-metadata; python_version < "3.8"->Click>=6.0->face-recognition)
  Cache entry deserialization failed, entry ignored
  Cache entry deserialization failed, entry ignored
  Downloading https://files.pythonhosted.org/packages/74/60/18783336cc7fcdd95dae91d73477830aa53f5d3181ae4fe20491d7fc3199/typing_extensions-3.10.0.2-py3-none-any.whl
Installing collected packages: Pillow, dlib, face-recognition-models, zipp, typing-extensions, importlib-metadata, colorama, Click, numpy, face-recognition
  Running setup.py install for dlib ... error
Exception:
Traceback (most recent call last):
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\compat\__init__.py", line 73, in console_to_str
    return s.decode(sys.__stdout__.encoding)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe4 in position 246: invalid continuation byte

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\commands\install.py", line 342, in run
    prefix=options.prefix_path,
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\req\req_set.py", line 784, in install
    **kwargs
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\req\req_install.py", line 878, in install
    spinner=spinner,
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\utils\__init__.py", line 676, in call_subprocess
    line = console_to_str(proc.stdout.readline())
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\compat\__init__.py", line 75, in console_to_str
    return s.decode('utf_8')
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe4 in position 246: invalid continuation byte

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\basecommand.py", line 215, in main
    status = self.run(options, args)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\commands\install.py", line 385, in run
    requirement_set.cleanup_files()
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\req\req_set.py", line 729, in cleanup_files
    req.remove_temporary_source()
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\req\req_install.py", line 977, in remove_temporary_source
    rmtree(self.source_dir)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\_vendor\retrying.py", line 49, in wrapped_f
    return Retrying(*dargs, **dkw).call(f, *args, **kw)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\_vendor\retrying.py", line 212, in call
    raise attempt.get()
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\_vendor\retrying.py", line 247, in get
    six.reraise(self.value[0], self.value[1], self.value[2])
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\_vendor\six.py", line 686, in reraise
    raise value
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\_vendor\retrying.py", line 200, in call
    attempt = Attempt(fn(*args, **kwargs), attempt_number, False)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\utils\__init__.py", line 102, in rmtree
    onerror=rmtree_errorhandler)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\shutil.py", line 488, in rmtree
    return _rmtree_unsafe(path, onerror)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\shutil.py", line 378, in _rmtree_unsafe
    _rmtree_unsafe(fullname, onerror)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\shutil.py", line 378, in _rmtree_unsafe
    _rmtree_unsafe(fullname, onerror)
  File "c:\users\дом\appdata\local\programs\python\python36\lib\shutil.py", line 378, in _rmtree_unsafe
    _rmtree_unsafe(fullname, onerror)
  [Previous line repeated 2 more times]
  File "c:\users\дом\appdata\local\programs\python\python36\lib\shutil.py", line 387, in _rmtree_unsafe
    onerror(os.rmdir, path, sys.exc_info())
  File "c:\users\дом\appdata\local\programs\python\python36\lib\site-packages\pip\utils\__init__.py", line 114, in rmtree_errorhandler
    func(path)
PermissionError: [WinError 32] Процесс не может получить доступ к файлу, так как этот файл занят другим процессом: 'C:\\Users\\E786~1\\AppData\\Local\\Temp\\pip-build-ey04e_8p\\dlib\\build\\temp.win-amd64-3.6\\Release\\CMakeFiles\\3.21.1\\CompilerIdC'
You are using pip version 9.0.1, however version 21.2.4 is available.
You should consider upgrading via the 'python -m pip install --upgrade pip' command.

Источник