Transcrições
1. Apresentação: Bem-vindo à aula de
detecção de força com aprendizado profundo, onde criaremos um
aplicativo de ponta a ponta que pode detectar minas em
imagens e vídeos. Meu nome é arsine e eu serei seu instrutor
nesta aula. Eu programo
desde 2019. E eu sou o autor do blog, don't
repeat yourself.org, onde tenho mais de 5
mil desenvolvedores cada mês para aprender
mais sobre Python, aprendizado
de máquina e visão
computacional. A classificação de imagens é uma tarefa muito comum
em visão computacional. É uma tarefa em que você
tem um conjunto de imagens e a unidade para classificá-las
em um conjunto de categorias. Neste curso, especificamente, classificaremos as imagens
em duas categorias. Sorrindo e balançando a cabeça, sorrindo. Que usaremos o aprendizado profundo
e começaremos treinando uma rede neural convolucional neste
conjunto de dados negativo, que contém rostos de pessoas
sorrindo e não sorrindo. Quando a rede estiver secando, seguiremos
as etapas a seguir para detectar sorrisos em
imagens e vídeos. Usaremos as cascatas duras
para detectar um rosto, uma imagem. Em seguida, extrairemos a região do
rosto da imagem. Em seguida, passaremos
a região facial para a rede para classificação. E, finalmente,
anotaremos a imagem com o rótulo sorrindo
ou não sorrindo, dependendo da
saída da rede. Se isso parece empolgante, então vamos entrar na aula e começar
a criar nosso aplicativo de
detecção de odores.
2. Instalação: Neste primeiro vídeo, veremos como instalar os pacotes necessários
para este projeto. Você pode pegar o
arquivo
requirements.txt do código-fonte
e instalar o que está nele. Ou se você estiver
acompanhando comigo, você pode criar um novo arquivo
no diretório do projeto. Vamos chamá-lo de
dxdy do requisito e inserimos as bibliotecas
necessárias para este projeto. Então, precisamos de num pi. Fizemos como
os ciclistas aprendem o OpenCV. Também precisamos de coágulos de lama. Então, finalmente, precisamos, agora salvamos o arquivo. E com a terminologia que
aprendemos começou com o texto
de pontos de
requisitos de energia. No meu caso, os pacotes já
estão instalados. Então, aqui podemos ver que o
requisito já satisfez todas essas bibliotecas. Mas no seu caso, você verá que os pacotes
estão sendo instalados. E pode levar algum tempo
para instalar todos eles.
3. Como carregar os dados: Neste vídeo,
vamos carregar esses mouses. O conjunto de dados de ratos contém mais de 13 mil imagens em
tons
de cinza de 64 por 64 pixels em crise. Sorrindo, e eles
não estão sorrindo. Para os rostos que não sorriem, temos mais de
9 mil imagens. E para os rostos sorridentes, temos 3.690 imagens. Portanto, o conjunto doctype
está desequilibrado, o que significa que há uma distribuição uniforme
das imagens. Uma técnica comum
para lidar com um conjunto de dados desequilibrado é
aplicar a espera de classe. Veremos como fazer isso
quando construirmos nosso modelo. Então, primeiro faremos o
download do conjunto de dados. Você pode navegar até esse
URL para fazer o download. Então, clicaremos
no botão Gravar e
faremos o download
em formato zip. Quando o arquivo é
baixado, nós o descompactamos. Excluímos esse arquivo. E nosso conjunto de dados está contido nesta pasta de fórmula
you smiles. Então, aqui temos duas subpastas,
positivos e negativos. Este contém imagens
de rostos com sorrisos, como você pode ver aqui. E o conteúdo da
pasta de negativos, imagens de não sorrindo. Então, como você pode ver, as imagens estão em escala de
cinza e são um
pouco mais 64 por 64. Então, normalmente podemos treinar nosso
modelo com problema de duto. Não deve consumir
muitos recursos. Não se esqueça de copiar a pasta
para o diretório do projeto. Agora estamos prontos para carregar
nosso conjunto de dados a partir disso. Então, vamos começar importando
os pacotes necessários. Primeiro, criaremos um novo arquivo
Python, ponto de treinamento p-y. Começaremos
importando a função de
divisão de teste de trem da seleção scikit-learn
got errante. Hoje e nesta divisão, vamos usá-lo para dividir nosso
conjunto de dados em conjunto de treinamento, conjunto de
validação
e um conjunto de testes. Em seguida, temos a função de matriz de
imagens. Portanto, não há pulsos na minha imagem ou imagem para organizar. E então temos do TensorFlow keras dot load in range, que usaremos para
carregar uma imagem a partir disso. Em seguida, temos o modelo
sequencial. Então, de servir Flow Keras, Sequential. E então precisamos de alguns advogados. Então, teremos o TensorFlow. Keras, camadas chegam ao ano. Depois temos a piscina dos monges, depois temos a camada achatada
e, finalmente, a camada densa. Também precisamos do módulo pyplot, numpy e do pacote OS. Então, vamos importá-los também. E agora estamos prontos
para carregar nosso conjunto de dados. Então, vamos criar uma função
chamada partes da imagem, que levará o bot ao
conjunto de dados como argumento. E ele retornará a lista de caminhos para as imagens
no conjunto de dados. Então, podemos primeiro criar uma
lista de extensões válidas. Então, diremos que
formatos válidos são iguais a. Gpg incluirá P e G. Então, basicamente, usaremos essa lista para verificar se a extensão do
arquivo é uma imagem. E a seguir, vamos criar uma lista vazia
chamada partes da imagem. É igual a uma
lista vazia, que conterá, conterá as partes
das imagens no conjunto de dados. Em seguida, examinaremos
a árvore do diretório raiz. Digamos que os nomes dos
seus
casulos na parede. E aqui o caminho é o caminho para o
diretório atual na árvore. E seus nomes são
dos subdiretórios
do diretório atual
nos três, e os cinco nomes são os arquivos no diretório
atual. Então, vamos começar imprimindo. Aqui está meu Harris e
veremos o que vou dizer aqui. Você tem muitas plantas. Aqui vamos nós direto
desse axônio leve. Vamos rodar nosso roteiro. Portanto, a saída aqui são todos os subdiretórios
do diretório smiles. Como você pode ver, temos
os negativos, positivos, que estão aqui, e
depois menos sete, positivos, sete, que
estão aqui. E aqui. Agora vamos fazer um loop
sobre a íris final. Então, escreveremos
para o nome em nomes. Vamos também imprimir o tubo e a parte final para
ver o que está acontecendo. Assim, podemos escrever que você está em seu próprio roteiro de cores. Então, aqui, como você pode ver, temos esse pote de diretório
e, em seguida, esse grão fino. E então essa camada realmente
comprou esse nome de arquivo, que é uma imagem, e assim por diante. Então, o que podemos fazer agora é
extrair a extensão do arquivo, que é This, this, e compará-la com a nossa, a esta lista para verificar se
o nome do arquivo é uma imagem. Então, vamos escrever aqui extensão. Quer dividir o texto. Nós fornecemos um bom nome. Noah. Em seguida, escreveremos que nossa extensão está na lista de formatos
válidos. Construiremos o
caminho completo para nossa imagem. Então, diremos que a parte da
imagem é igual ao ponto do sistema operacional, ponto, junção de pontos. E aqui nos juntaremos
à parte do diretório, que é esta. Nós definimos o nome aqui parte. Com o financiamento para
essa imagem em particular. O nome completo da
imagem será esse aqui. E também precisamos acrescentar
nossa imagem dois, nossa lista. Acabamos com essa função. Apenas partes escritas da imagem. Então, agora, quando essa
função, temos o caminho completo para cada imagem no conjunto de dados
armazenado em uma lista. Portanto, o próximo passo é usar
essas partes da imagem e carregar
o conjunto de dados mais inteligente. Então, podemos dizer que vamos criar uma nova função. Dê o nome de célula de carga. E aqui
forneceremos dois argumentos. A primeira são
as partes da imagem e a segunda é o tamanho
alvo das imagens. Vamos defini-lo aqui. Digamos que o tamanho da imagem
seja igual a 3232. Caminhos da imagem corporal da imagem. Agora podemos criar
duas listas vazias. Primeiro, vamos
chamá-la de cidade, que
conterá as imagens. E então nós o lemos. mesmo acontece com o nome de rótulos, que conterá o rótulo de cada imagem sorrindo
ou não sorrindo. Então, a seguir,
começaremos obtendo as imagens. Assim, podemos fazer um loop sobre
as partes da imagem. Diremos para pods de parte de imagem. Aqui vamos escrever
imagem é igual a, vamos carregar nossa imagem usando
a função de carregamento de imagem. Aqui, o primeiro argumento
é o caminho para nossa imagem. E então temos o
modo de cor, que é em tons de cinza. E então o último argumento
é o tamanho do alvo, que podemos usar
nosso tamanho alvo. Em seguida, precisamos converter
nossa imagem em uma matriz NumPy. Simplesmente escreveremos a imagem dois. E, finalmente, acrescentamos
nossa imagem aos dados. Então, aqui acabamos
com as imagens. Agora podemos obter os rótulos. Agora, para obter o rótulo, podemos extraí-lo
da imagem. Mas, por exemplo, aqui imprimiremos
as partes da imagem. E diremos Veja o que obtemos. Os dados. Forneça caixa de imagem. Então, aqui, como você pode ver, temos o bot para cada
imagem em nosso conjunto de dados. Por exemplo, aqui está o caminho completo para essa imagem
específica. Então, se
pegarmos a parte completa, podemos extrair o
rótulo dessa parte, que aqui é positiva. Então, para essa imagem em particular, a pessoa está sorrindo. Temos um
rosto sorridente nessa imagem. Então, para obter o rótulo, encontraremos aqui esta linha. E escreveremos que o rótulo é igual ao vínculo da imagem e
formaremos a imagem, mas vamos dividi-lo com
base no separador de diretório, que é esse separador aqui. E vamos pegar o
terceiro a partir do final. Então este é o primeiro, menos um, menos dois
e menos três. Então, aqui vamos obter o rótulo
é igual a dois positivos. Agora diremos que se nosso rótulo
for igual a dois positivos, nós o codificaremos como um. Então, vamos escrever um. Se num for igual a positivos, caso contrário,
codificaremos que tem 0. Finalmente, acrescentamos nosso
rótulo à nossa lista. O último passo é simplesmente
retornar os dados, a lista e a lista. Nós nos certificamos de
convertê-los em um array NumPy. Vamos dizer return num pi dot, reescrever os rótulos superior e
não pi dot. Também ouvimos
a necessidade de dimensionar os dados para o intervalo 01
dividindo por 255. Aqui até aqui, podemos obter nossas tabelas de dados
usando nossa função.
4. Como treinar o detector de sorriso: Nesta parte,
vamos construir nosso modelo e começar a treinar. O modelo que vamos
construir consiste em uma
folga para curvar para a marca mais que
aparece nos blogs, seguida por uma camada totalmente
conectada. Então, como você pode ver
nesta imagem, teremos essa camada fina do que o pool máximo para a camada. E então a mesma coisa aqui, C mais camadas máximas de pool. E então teremos o bloco
totalmente conectado, que consiste em camada
achatada, e então uma camada densa e outra camada que vai
esperar para fora como. Então, vamos criar uma função. Vamos chamá-lo de modelo. E isso tomará a boa forma de um
argumento, que será igual
à ciência média. Brilho um para uma dimensão
de canal. Mas não precisaríamos mudar. Neste tópico. Usaremos esses modelos de
equação para que
possamos escrever murmúrios,
querer sequencial. Teremos todos os filtros aceitarão o trabalho sujo. O governador assina. Vamos ver, tamanho três por três. Para que a ativação faça a função de
observação. Ou as Cruzadas. mesma boa forma. Usaremos alarme, máximo de férias, que
usaremos conciso para o meu trabalho. E então a mesma coisa aqui da camada de perda de
fluido dos filtros. Vamos dobrar o
número de filtros. E depois a camada achatada. Com 256. Você é honesto. E para a ativação da camada de saída. Nós temos. Como estamos lidando com um problema de classificação
binária, usaremos a função de
ativação sigmóide e enviaremos a todos vocês. Então você é um para o sinal
de ativação. Vamos também compilar nosso modelo. Então, vamos modelar o ponto para
compilar a função de perda. É claro que pegaremos
a cruz binária na cópia. O ideal é 0. Digamos que o
otimizador ou as métricas. Realmente pegue o Parker Awesome. Em seguida, precisamos calcular
os pesos da classe. Como eu disse antes, nosso conjunto de dados está desequilibrado. Então, precisamos dar mais peso ao vidro sub-representado. Sorrindo mais, neste caso, para que o modelo preste
mais atenção a esse copo. Podemos começar por conter
o número de cada rótulo usando a função
numpy dot unique. Então, diremos, eu esqueço de devolver o modelo. Então, em troca, o modelo, e diremos que a contagem de rótulos
é a chamada para não pi. O que está correndo na
cabeça, estaremos com nossos rótulos e
diremos retorno, é verdade. Retornar colunas é igual a mostrar, para retornar o número
de cada rótulo. Vamos imprimir esses. Diremos que
não teremos não teremos problemas com os produtos. Nós temos. Vai aqui, já que
não precisamos rotular, todos os rótulos estão definidos como 0. Então, agora estamos no nosso roteiro. Aqui. Como você pode ver, formamos um rotulado 01, que está sorrindo
ou não sorrindo. E para a
variável count, temos 9.475. Desdobre essa camada de revestimento. Temos 3.690. Então, agora precisamos calcular
os pesos das classes. Para isso. Podemos usar
uma operação mais simples. Então, podemos escrever aqui conta. As novas contas serão
iguais às contagens máximas, que estão aqui, e nós as
dividimos pelas contagens anteriores. Vamos mover essas duas
variáveis novamente. Então, aqui, como você pode ver, o mais um é
MyInt plus terá os pesos para 0,56
maiores que o mais 0. Vamos criar um dicionário que mapeará cada
classe com seu peso. Então, podemos escrever mais
peso é igual. Usaremos a função zip. Então, o dicionário. Agora precisamos criar um conjunto de treinamento e um conjunto de
validação e um conjunto de testes. Levaremos 20% dos
dados para rezar por esse conjunto. E dos 80% restantes, levaremos 20% para
criar o conjunto de validação. Então, vamos começar
com o conjunto de testes. Usaremos a função de
divisão de teste de trem para isso. Então, nós gostamos de tentar
proporcionar o nosso dia. E, em seguida, esse
tamanho levará 20 por cento. Digamos, comece o outono. Eles seguem sua
própria demonstração. Ou para fazer. A mesma coisa
para o conjunto de validação. Acabamos de copiar e colar. Estirpe. Escorra lentamente. Nós fornecemos. Certo. Agora estamos prontos para treinar nossos modelos. Então, primeiro construiremos
o modelo escrevendo. O modelo é igual ao módulo. E vamos treinar o
modelo para a 20ª caixa. Portanto, a caixa é igual a um. historiador da arte é o
quantil diria que é a maravilha por que hoje. O conjunto de
validação de dados de validação. E precisamos usar o peso positivo para o tamanho do lote. Diga 64. Desdobrou a caixa, uma caixa. Vamos também guardar o
modelo para mais tarde. Então, podemos simplesmente escrever um não diz e nós o nomearemos, prejudicará um brilho. Aguarda e espera
pelo arquivo inicial. Nós usamos o hoje. Então seja bem-vindo. treinamento não deve
demorar muito Então você pode esperar que o
treinamento termine. Então, como você pode ver
o que nossos ginásios e desligam aproximadamente 90 por cento. Mas vamos traçar as curvas de
aprendizado para visualizar nossos resultados. Então, vou apenas copiar
o código daqui. Não há nada de especial. Aqui. Estamos apenas traçando a precisão do treinamento,
a precisão da validação. E então temos a
perda de treinamento e a validação. Então, vamos reexecutar o script. Então aqui temos
a perda de treinamento, e aqui temos a precisão
de validação do treinamento de aproximar aqui, 1, 2%. O que você pode notar é que a
precisão do treinamento e validação aproximadamente aqui, então começa a divergir. Então, isso é um sinal
de sobreajuste. Podemos melhorar a precisão do nosso modelo usando o aumento de
dados. Mas eu não vou cobrir
isso nesta aula. Então, vamos avaliar nosso
modelo no conjunto de testes. E podemos aplicar nosso modelo
ao resumo ou a quais imagens. Então, essa precisão de perda. Há um gráfico de quantil envolvendo o uso do conjunto de teste. Aqui estamos recentemente durante o
operador de perdas , Awesome. Então, temos uma grama, é aproximadamente
uma pessoa.
5. Como aplicar nosso detector de sorriso às imagens: Agora que nosso modelo está treinado, vamos aplicá-lo a
algumas imagens do mundo real. Então, vamos criar um
novo arquivo Python. Vamos chamá-lo de sorriso, imagem
do detector, PY. E podemos começar a
escrever algum código. Então, vamos importar
muitas vezes dizer v. Então
temos desses modelos. Função de carga. Também precisa. Em seguida, vamos
definir algumas variáveis. Então, vamos creditar que a
largura é igual a 800. Digamos que a altura
seja igual a 600. Também criamos a cor azul, então é igual a 5500. E agora podemos carregar nossa imagem. Então aqui eu tenho uma pasta
com algumas imagens. Vou apenas copiá-lo daqui. Eu tenho dez imagens. Vamos pegar o
primeiro, nossos modelos. Então, vamos gostar que a imagem seja igual
a CV muito alto de um fuzileiro naval. Imagens. Nós damos o primeiro palpite. Também é necessário redimensioná-lo. Então, vamos gostar da ferramenta TV, redimensionar a imagem e usar
a largura e a altura. E finalmente, nos convertemos em
muito tolo para não CBT converter o CV do cabelo para
ler você tem que ficar grisalho. Em seguida, podemos começar a
detectar rostos usando o classificador em
cascata Haar. Então aqui eu
defini nosso XML padrão em cascata, face
frontal. Então vou colocá-lo aqui,
o diretório do projeto, e podemos carregá-lo usando a função CV para
adotar o classificador em cascata. Então, vamos escrever que nosso detector de
rosto é igual a CV para classificador em
cascata. E aqui fornecemos o nome de que também precisamos carregar nosso modelo. Então, diremos mais do que
é igual ao modelo. Aqui temos o nome do nosso
modelo que é mais do que. Agora podemos detectar rostos usando a função detectar multiescala. Como esses retângulos é
igual ao nosso detector facial. Para o primeiro argumento, fornecemos nossa imagem em tons de cinza
e, em seguida, temos
o carro falso em escala. Vamos colocá-lo como 1.1. Então temos que definir
os vizinhos mínimos, que podemos colocar como. Esses parâmetros funcionam. Bem, no meu caso, mas você pode
mudá-los se quiser. Portanto, aqui a
variável de retângulos de face conterá
as caixas delimitadoras de face. Portanto, o próximo passo é fazer um loop sobre as caixas delimitadoras da face e
extrair a região da face. Diremos para x, y, largura e altura. No nosso caso. Aqui vamos primeiro
retângulo ao redor do rosto. Então, nós gostamos do TV2.com. Aqui. Nós conhecemos nossa imagem. E daremos
as contas MSDN, que são x e y. E então temos duas rachaduras diagonais diferentes
, que seriam x mais y mais. E depois temos a cor azul e duas para a espessura. E na próxima semana comece a região
do rosto a partir
da imagem em escala de cinza. Temos as coordenadas
do rosto aqui. Então, escreveremos nosso herói por quê? A ligação para Ray. E simplesmente usaremos o corte. Então, surgiremos
de y para y mais x. X mais largura. Também precisamos redimensionar a região da
face e dimensioná-la para 01 ramo antes de
alimentá-la em nosso modelo. Então vamos mentir ou y é igual
a CV para encaixar o tamanho. Aqui aprenderemos
a dimensioná-lo para 32 por 32, porque é isso que
usamos para treinar nosso modelo. Aqui, para o
tamanho da imagem, temos 32 por 32. Em seguida, escalamos para
01, ramo Dois, 55. Também precisamos adicionar
a imagem a um lote. Nós vamos, porque aqui a forma da imagem de
Trinta e dois. Trinta e dois. Nosso modelo foi treinado
em lotes de imagens. Portanto, a nova forma será
igual a T2, T2 por T2. Então escreveremos
y é igual a y. E usaremos a
função ponto sem canalização, novo acesso a este
novo eixo, eixo y. E vamos manter
tudo igual aqui. Pode imprimir aqui o antes e depois de acessar para ver
o que mudou aqui. A forma. A mesma coisa aqui. Aqui temos um erro de
atributo ou duas vezes. Nos EUA é letra maiúscula. Aqui. Como você pode ver, como eu antes de adicionar o
novo eixo é 32 por 32. E depois de adicionar
o eixo u aqui, Econ 132 por 32. Então agora o passo final é passar
a região do
rosto para não funcionar. Para classificação. Nós nunca removemos. Vamos escrever qual previsão é igual à da seta e vamos
imprimir o dicionário. Então, normalmente,
a previsão terá um valor entre 01. Aqui. Você pode ver aqui o valor da previsão
para essa imagem específica. A previsão é 0,6. Então, o que podemos fazer agora é que nosso rótulo é igual a, digamos, se a previsão for
maior ou igual a 0,5, criaremos o rótulo como, definiremos o rótulo como sorridente. Caso contrário, vamos
configurá-lo para não sorrir. Então, vamos rotular é
igual a sorrir. Se a previsão for
maior ou igual a 0,5, caso contrário, não sorrindo. Isso é colocado na noite. Para verificar este caso, a etiqueta deve estar gastando seu processo sorrindo para o dia. Mas a última coisa que
precisamos fazer é escrever o texto e a
imagem e exibir a imagem. Como CV. Para colocar o x. Aqui, colocaremos texto sobre isso. E gostaríamos de fazer a
rotulagem e a imagem. Para o texto das coordenadas, usaremos as
coordenadas da face. Então vamos dizer x mais x e y. E para a fonte, pode escolher esta é, digamos que esta. E para a escala da fonte, digamos 0,75, cor azul. Formas de visualizar e CB2. Tenho certeza mantemos nossa coluna. A pessoa não está sorrindo, mas nosso modelo
detectou na mineração. Obviamente, nosso modelo não
é 100% preciso, então essa é uma previsão
positiva. Vamos tentar com outra imagem. Digamos que esse. Desta vez. Eu sou Armando previu
com sucesso o slide. Podemos tentar do jeito que a
pessoa está, não sorrindo. Portanto, não aceitaríamos esse que também pode testar com
as outras imagens. E isso é com a imagem. A pessoa não está sorrindo. E nosso modelo foi detectado
com sucesso.
6. Como aplicar nosso detector de sorriso aos vídeos: Agora que você sabe como
detectar imagens de sorrisos, digamos como aplicar nosso
detector de sorriso de aprendizagem profunda dois vídeos. Então, vamos criar um novo arquivo Python. Diga o nome de detector de sorriso, PY. E vamos importar
as bibliotecas para que o código não mude
muito com isso. Vou apenas copiar essa
multa para colar aqui. Então temos a
largura e a altura. Quando a cor azul. Aqui, só precisamos inicializar os objetos de captura de vídeo. Então, renovaríamos sua xícara. Claro que é igual a CV
para captura de vídeo. Aqui, fornecemos o
nome do nosso vídeo. Aqui eu tenho um vídeo
pré-gravado meu no qual fiz alguns testes. Então, vou usá-lo apenas para
esta parte do vídeo aqui. Fiz alguns testes e
sorri e muito dinheiro. Então, aqui vamos colocar o
nome do vídeo mp4. E então temos a mesma coisa. Desta parte. Precisaremos detectar rostos,
nossa maravilha pré-treinada, e detectaremos rostos, perdendo a função de detecção
multiescala. Então, vamos apenas copiar
essas três linhas aqui. Então, aqui está nosso dicionário. Lemos no
navegador os quadros, para que possamos começar a
processar nossos quadros. Podemos dizer, por que é verdade. Então, aqui vamos pegar o próximo quadro do vídeo. Então, quando dizemos quadro de
acordo com a captura de vídeo. E então vamos
convertê-lo em várias curvas, CV para CV, CV para BGR. E aqui podemos usar a função multiescala The digs e passá-la ao longo do quadro de escala de
cinza. Agora podemos fazer um loop sobre as caixas delimitadoras de
face. Então, vou apenas
copiar o código
daqui porque tudo
permanece o mesmo aqui. Só preciso mudar aqui imagem, quadro. Encontre uma nova maneira. Você escreve o texto da mesma forma e nós mostramos nossa moldura. Então, basta copiar o código daqui. Como olhar o currículo aqui no cabeçalho, não
diríamos que seu currículo pareça, espere, espere um minuto. Então a corrente é igual a q. Ok? Nós saímos. Finalmente, lançamos a
captura de vídeo e as janelas. Vamos ver o resultado final. Diremos Python,
três, leitura do detector de sorriso. Então, aqui você pode ver que o
algoritmo não tem problema detectar sorrisos e
sorrisos a partir do vídeo. A detecção é bastante estável.
7. Conclusão: Nesta aula, você
aprenderá a treinar uma rede
neural convolucional para detectar sorrisos em
imagens e vídeos. A primeira coisa
que precisamos fazer é carregar nosso conjunto de dados do disco e
prepará-lo para nossa rede. Em seguida, criamos
nossa rede neural. E aqui calculamos o peso da classe
para levar em conta o desequilíbrio de classe
no conjunto de dados. E assim forçar o modelo a prestar mais atenção à classe
sub-representada. Então, aqui,
dividimos um conjunto de dados em
um conjunto de treinamento, conjunto de
validação
e um conjunto de testes
e, em seguida, continuamos a
treinar nossa rede. Vimos que alcançamos uma precisão de 90 por cento no conjunto de testes. A etapa final foi testar nosso modelo em imagens e vídeos. Então, para isso, usamos um classificador em cascata Haar aqui nesta parte para detectar
o rosto na imagem. E então extraímos
nesta parte aqui, a região da face
da imagem e vinculamos
a região da face para
previsão ao nosso modelo. E, finalmente, rotulamos a imagem como sorrindo
ou não sorrindo.
Yacine Rouizi
