
A prevenção é tudo para nós. A proteção competente contra vazamentos de dados ajudará a evitar consequências negativas que podem levar a perdas de milhões de dólares. No mundo moderno, cada uma das organizações processa e armazena informações confidenciais. Quando se trata de grandes organizações, os volumes de informações confidenciais são enormes. O estado de "segurança" de um computador é um ideal conceitual alcançado quando cada usuário observa todas as regras de segurança da informação.
Estando no escritório, qualquer funcionário de vez em quando deixa seu computador, e então o computador ligado fica sem supervisão, muitas vezes com arquivos e pastas abertos para acesso, já que muitos funcionários simplesmente se esquecem de travar o PC, ou não o fazem de propósito, guiados por uma frase semelhante - "Eu recuei cinco metros, porque bloquear!?" Infelizmente, esses momentos podem ser aproveitados por outros funcionários interessados nos materiais.

Como você pode garantir a segurança dos dados em tais situações? Uma das formas poderia ser o uso de tecnologias de autenticação biométrica que permitem reconhecer os usuários pelo rosto.
O reconhecimento facial não é um conceito novo e, atualmente, existem muitas ferramentas para realizar essa tarefa. Se você não é particularmente versado em métodos e ferramentas para reconhecimento facial, usar a biblioteca de visão por computador de código aberto (biblioteca de visão por computador de código aberto) e a linguagem de programação Python será uma excelente solução que permitirá que você alcance seu objetivo o mais rápido possível.

Decidimos o software, precisamos de mais um hardware - uma câmera web. Como você configura o reconhecimento de rosto agora? Primeiro, você precisa detectar o rosto no quadro. Um dos métodos de detecção de faces é o método de Viola-Jones, já descrito em 2001. Como estamos mais interessados na prática, não entraremos em detalhes teóricos, apenas mencionaremos que o método se baseia em princípios básicos como a transformação de uma imagem em uma representação integral, o método da janela de varredura e o uso de recursos de Haar. Você pode ler a descrição do método e ver informações sobre a instalação do OpenCV no site oficial . Abaixo está o código Python que nos permitirá detectar rostos no fluxo de vídeo da webcam:
import cv2 as cv
import numpy as np
face_cascade = 'haarcascade_frontalface_default.xml'
cam = 1
classifier = cv.CascadeClassifier(face_cascade)
video_stream = cv.VideoCapture(cam)
while True:
retval, frame = video_stream.read()
gray_frame = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
found_faces = classifier.detectMultiScale(gray_frame, 1.2, 5, minSize=(197, 197))
for x, y, w, h in found_faces:
cv.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
cv.namedWindow('Stream', cv.WINDOW_NORMAL)
cv.imshow('Stream', frame)
k = cv.waitKey(30) & 0xFF
if k == 27:
break
video_stream.release()
cv.destroyAllWindows()
No código acima, primeiro importamos os dois módulos necessários para funcionar: cv2 (visão computacional) e numpy (trabalhando com matrizes). Na variável face_cascade, salve o caminho para o arquivo xml com cascatas Haar. Este arquivo, bem como outros, por exemplo para detecção de olhos, podem ser encontrados na página do github.
Na variável cam, escrevemos o número da web-camera, se várias estiverem conectadas, o número da única câmera conectada por padrão é 0. Em seguida, um objeto classificador é criado usando o método CascadeClassifier e a conexão com a câmera é cv.VideoCapture (cam). Então, em um loop, lemos as imagens quadro a quadro na variável de quadro usando o método read (). O classificador processa uma imagem em tons de cinza, portanto, usando o método cvtColor, transformamos a imagem na forma desejada. O método detectMultiScale retorna uma lista com parâmetros de todas as faces detectadas, que é um retângulo - a coordenada do vértice (x, y) e a largura e altura do retângulo (w, h). As linhas a seguir são opcionais para o programa funcionar, mas úteis para depuração - o método retângulo adiciona um quadro ao quadro de origem no local do rosto detectado e imshow - exibe uma janela com um fluxo de vídeo.
Tudo é bastante simples aqui, mas mais interessante ainda. Agora precisamos reconhecer o rosto. Como fazer isso? O OpenCV contém vários métodos de reconhecimento facial, entre os quais está o método LBPH (Local Binary Patterns Histogramas). Aqui iremos nos deter em mais detalhes e entender um pouco como funciona.
Em geral, os valores de brilho do pixel da imagem e mais oito pixels ao redor do original são obtidos. Acontece uma tabela 3x3 com valores de brilho de pixel. Então, 0 ou 1 são escritos na mesma tabela. Se o valor de brilho do pixel mais externo exceder o valor de brilho do pixel central, 1 é definido, caso contrário - 0. Então o código resultante é lido no sentido horário a partir da célula superior esquerda, convertido em um número decimal, e este número é escrito em uma matriz de tamanho de imagem na posição apropriada. E assim, para cada pixel.

A matriz é dividida em um determinado número de segmentos (por padrão, é uma grade 8 × 8), um histograma é construído para cada segmento e, ao final, concatenando os histogramas, obtém-se uma resultante caracterizando toda a imagem. Durante o reconhecimento, o mesmo histograma é traçado para a imagem estudada, que é então comparado com os dados de treinamento.

Usaremos este método, mas primeiro você precisa realizar mais uma etapa importante - criar uma base com faces. Em geral, a estrutura do banco de dados é assim:
--Storage\\
--Person_1\\
--img_1.jpg
--img_2.jpg
…
--img_n.jpg
…
--Person_m\\
--img_1.jpg
--img_2.jpg
…
--img_n.jpg
Ok, temos uma base com imagens de rostos. Agora você precisa processar de alguma forma a base para treinar ou treinar o algoritmo. O processamento se resume a gerar uma lista de todas as imagens e uma lista de id ou tags para cada pessoa. O código mais simples para essa ação pode ser assim:
storage = 'storage'
images = []
labels = []
names = {}
id = 0
for subdir in os.scandir(storage):
names[id] = subdir.name
subdir_path = os.path.join(storage, subdir.name)
for file in os.scandir(subdir_path):
if file.name.split('.')[-1].lower() not in ['png', 'bmp', 'jpeg', 'gif']:
continue
file_path = os.path.join(subdir_path, file.name)
image = cv.imread(file_path, 0)
label = id
images.append(image)
labels.append(label)
id += 1
Também aqui tudo é muito simples. A variável de armazenamento armazena o caminho para a pasta que contém as pastas com imagens de rostos de pessoas, em seguida, uma lista de imagens, uma lista de tags e um dicionário com nomes. Como funciona: todas as imagens da pasta de uma determinada pessoa são adicionadas à lista de imagens, por exemplo, são 15 delas. Se esta for a primeira pasta do armazenamento, o rótulo será igual a 0, portanto, de 0 a 15 vezes são adicionadas à lista de rótulos, ao mesmo tempo No dicionário de nomes, é criado um registro em que a chave é o rótulo, e o valor é o nome da pessoa (o nome da pasta com as imagens de uma determinada pessoa). E assim, para todo o armazenamento. No código acima, preste atenção à linha com o método imread - aqui a imagem é lida e representada como uma matriz de brilho de pixel e gravada na variável da imagem.
Agora, a parte divertida é treinar o algoritmo:
recognizer = cv.face.LBPHFaceRecognizer_create(1, 8, 8, 8, 130)
recognizer.train(images, np.array(labels))
Na primeira linha do código, inicializamos o algoritmo usando o método LBPHFaceRecognizer_create. Lembra da descrição do algoritmo LBPH? Os parâmetros da função mencionada contêm apenas o que falamos: o raio ao longo da borda do qual os pixels serão tirados em torno do desejado, o número de pixels do "círculo" formado pelo raio, o número de segmentos horizontal e verticalmente e o limite que afeta a decisão de reconhecimento pessoas, isto é, quanto mais rígidos os requisitos, menor o limite. Em seguida, chamamos o método train para treinamento, passando listas de imagens e rótulos como argumentos. Agora, o algoritmo memorizou os rostos do banco de dados e será capaz de reconhecê-los. A questão é pequena, resta adicionar algumas linhas ao primeiro trecho de código no loop (para x, y, w, h em found_faces): após detectar um rosto, precisamos reconhecê-lo, e se o rosto não for reconhecido,ou outra pessoa for reconhecida e, em seguida, bloqueie o computador imediatamente!
roi = gray_frame[y:y+h, x:x+w]
name, dist = recognizer.predict(roi)
cv.putText(frame, '%s - %.0f' % (names[name], dist), (x, y), cv.FONT_HERSHEY_DUPLEX, 1, (0, 255, 0), 3)
if names[name] != "Ivan Petrov":
ctypes.windll.user32.LockWorkStation()
Na primeira linha, roi (da região de interesse) é uma variável na qual escrevemos um fragmento da imagem contendo a face detectada. A próxima linha reconhece diretamente o rosto ao chamar o método de previsão. Este método retorna um rótulo correspondente ao rosto que foi reconhecido e um valor que caracteriza o grau de discrepância entre o rosto detectado e o reconhecido (quanto menor, maior o grau de confiança de que o rosto correto foi reconhecido). Em seguida, novamente para fins de depuração, adicione texto ao quadro com o nome da pessoa reconhecida usando o método putText. E, por último, verificamos a condição mais simples: se um não-proprietário do PC foi reconhecido (é aqui que um dicionário com nomes era necessário), então bloqueie o computador. A linha ctypes.windll.user32.LockWorkStation () é responsável pelo bloqueio, como você pode ver. Para fazer funcionarprecisará importar o módulo ctypes além de cv2 e numpy.
Como resultado, o PC é bloqueado assim que o rosto de outra pessoa é reconhecido ou, em princípio, não foi reconhecido. Depois de desbloquear o PC, o programa continua em execução. Você também pode adicionar um bloqueio de PC no caso de um funcionário deixar seu local de trabalho. Você não precisa pensar muito para entender que existem algumas nuances aqui. Por exemplo, e se outro rosto for reconhecido no fundo? Nesta situação, você pode definir o tamanho mínimo de um objeto que se parece com um rosto, então os rostos no fundo serão ignorados (para isso, há um parâmetro minSize no método detectMultiScale). Em outras situações, boas soluções também podem ser encontradas, se desejado.
Um dos fatores mais importantes para que o bloqueio funcione corretamente é a qualidade das imagens no banco de dados de fotos. Em primeiro lugar, é desejável que existam muitos deles para uma determinada pessoa, com diferentes ângulos e expressões faciais. Em segundo lugar, a iluminação faz seus próprios ajustes, por isso vale a pena considerar este ponto e usar imagens tiradas em diferentes condições de iluminação. E em terceiro lugar, você deve gravar imagens da webcam que está no local de trabalho do funcionário, também existe um método para salvar imagens no OpenCV. Quanto ao código, com certeza ele será expandido, serão adicionadas funcionalidades adicionais, para que possa ser “empacotado” em funções, utilizando classes. Não há limite para a perfeição! O principal é lembrar a ordem das ações do programa: processamento do banco de dados com fotografias, treinamento, detecção, reconhecimento.
No webinar 03.09.2020 10-00, horário de Moscou, os palestrantes apresentarão um método prático de treinamento de uma rede neural para detecção de objetos com o código-fonte e as tecnologias utilizadas, além de responder às suas perguntas. Você pode se registrar no link: newtechaudit.ru/vebinar-computer-vision
