Transcripciones
1. Introducción: Bienvenido a la clase podría
detección con deep learning, donde estaremos creando una
aplicación de extremo a extremo que puede detectar minas en
imágenes y videos. Mi nombre es el arsine y
seré su instructor
en esta clase. Llevo programando
desde 2019. Y soy el autor
del blog, no te
repitas yourself.org, donde tengo más de 5
mil desarrolladores cada mes para aprender
más sobre Python, machine learning y visión por
computador. La clasificación de imágenes es tareas
muy comunes
en la visión por computador. Es una tarea donde se
tiene un conjunto de imágenes y la unidad para clasificarlas
en un conjunto de categorías. En este curso, específicamente, clasificaremos las imágenes
en dos categorías. Sonriendo y asintiendo, sonriendo. Que usaremos el aprendizaje profundo
y comenzaremos entrenando una red neuronal convolucional
en este conjunto de datos menos, que contiene rostros de personas
sonriendo y no sonriendo. Una vez que la red se esté secando, pasaremos por los
siguientes pasos para detectar sonrisas en
imágenes y videos. Usaremos las duras cascadas
para detectar un rostro, una imagen. A continuación, extraemos la región
facial de la imagen. Después pasaremos
la región cara a la red para su clasificación. Y por último,
anotaremos la imagen con la etiqueta sonriendo
o no sonriendo, dependiendo de la
salida de la red. Si eso suena emocionante, entonces entremos a
la clase y comencemos a construir nuestra aplicación de
detección de olores.
2. Instalación: En este primer video, veremos cómo instalar los paquetes requeridos
para este proyecto. Puedes tomar el
archivo
requirements.txt del código fuente
e instalar lo que hay en él. O si me estás
siguiendo, puedes crear nuevo archivo
en el directorio del proyecto. Le nombraremos el requisito
dxdy e insertaremos las librerías
necesarias para este proyecto. Entonces necesitamos num pi. Hemos hecho cómo
los ciclistas aprenden OpenCV. También necesitamos coágulos de barro. Entonces por fin necesitamos, ahora guardamos el archivo. Y a partir de la terminología que
aprendimos partió del texto de puntos de
requisitos de potencia. En mi caso, los paquetes ya
están instalados. Por lo que aquí podemos ver
requisito ya satisfecho todas estas bibliotecas. Pero en tu caso, verás que los paquetes
se están instalando. Y podría llevar algún tiempo
instalarlos todos.
3. Cómo cargar los datos: En este video,
vamos a cargar estos ratones. El conjunto de datos de ratones contiene más de 13 mil imágenes en
escala
de grises de 64 por 64 píxeles en crisis. sonriendo, y
no sonríen. Para las caras no sonrientes, tenemos más de
9 mil imágenes. Y para las caras sonrientes, tenemos 3 mil 690 imágenes. Por lo que el conjunto doctype
está desequilibrado, lo que significa que hay una distribución pareja
de las imágenes. Una técnica común
para lidiar con un conjunto de datos desequilibrado es
aplicar la espera de clase. Veremos cómo hacerlo
cuando construyamos nuestro modelo. Por lo que primero
descargaremos el conjunto de datos. Puedes navegar a esta
URL para descargarla. Por lo que haremos click en el botón Grabar y lo
descargaremos en formato zip. Cuando se
descarga el archivo, lo descomprimimos. Eliminamos este archivo. Y nuestro conjunto de datos está contenido en esta fórmula
que sonríe carpeta. Entonces aquí tenemos dos subcarpetas,
positivas y negativas. Éste contiene imágenes
de rostros con sonrisas, como puedes ver aquí. Y el contenido de la
carpeta de negativos, imágenes de no sonrientes. Por lo que como se puede ver, las imágenes son en escala de
grises y son un
poco más 64 por 64. Por lo que normalmente podemos entrenar nuestro
modelo con problema de ductos. No debe consumir
muchos recursos. No olvides copiar la carpeta
al directorio del proyecto. Ahora estamos listos para cargar
nuestro conjunto de datos a partir de esto. Entonces empecemos por importar
los paquetes necesarios. Primero crearemos un nuevo archivo
Python, training dot p-y. Empezaremos
importando la función de
división de prueba de tren de scikit-learn
got wandering selection. Hoy y esta división, lo
usaremos para dividir nuestro
conjunto de datos en conjunto de entrenamiento, conjunto de
validación
y un conjunto de pruebas. Entonces tenemos la función de matriz de
imágenes. Así que no hay pulsos en mi imagen o imagen a matriz. Y luego tenemos de TensorFlow keras dot load in range, que utilizaremos para
cargar una imagen a partir de esto. A continuación tenemos el modelo
secuencial. Por lo que de servir Flow Keras, Secuencial. Y luego necesitamos algunos abogados. Por lo que tendremos a TensorFlow. Keras, capas llega al año. Después tenemos la piscina de los monjes, luego tenemos la capa aplanar, y finalmente la capa densa. También necesitamos el módulo pyplot, numpy y el paquete OS. Entonces vamos a importarlos también. Y ahora estamos listos
para cargar nuestro conjunto de datos. Así que vamos a crear una función
llamada partes de imagen, que llevará el bot
al conjunto de datos como argumento. Y devolverá la lista de rutas a las imágenes
en el conjunto de datos. Por lo que primero podemos crear una
lista de extensiones válidas. Por lo que diremos
formatos válidos es igual a. Gpg incluirá P y G. Así que básicamente usaremos esta lista para comprobar si la extensión del
archivo es una imagen. Y la siguiente, vamos a crear una lista vacía
llamada partes de imagen. Es igual a una
lista vacía, que contendrá,
contendrá las partes a las imágenes en
el conjunto de datos. A continuación revisaremos
el árbol de directorios raíz. Digamos por tus nombres de vaina en la pared. Y aquí la ruta es la ruta al
directorio actual en el árbol. Y sus nombres son de los subdirectorios
del directorio actual
en los tres, y los cinco nombres son los archivos del directorio
actual. Entonces empecemos por imprimir. Aquí está mi Harris y
veremos lo que diré aquí. Tú muchas plantas. Aquí vamos justo fuera de
este axón ligero. Ejecutaremos nuestro guión. Entonces la salida aquí son todos los subdirectorios
del directorio de sonrisas. Como pueden ver, tenemos
los negativos, los positivos, que está aquí, y
luego menos siete, positivos, siete, que
están aquí. Y aquí. Ahora haremos un bucle
sobre el iris final. Por lo que escribiremos
por nombre en nombres. Imprimamos también la pipa y la parte final para
ver qué está pasando. Para que podamos escribir que estás en tu propio guión a color. Entonces aquí como pueden ver, tenemos esta olla directorio
y luego este grano fino. Y entonces esta capa realmente
compró este nombre de archivo, que es una imagen, y así sucesivamente. Entonces lo que podemos hacer ahora es
extraer la extensión del archivo, que es o bien Esto, esto, y compararlo con nuestro, a esta lista para comprobar si
el nombre del archivo es una imagen. Por lo que escribiremos aquí extensión. ¿ Quieres dividir texto. Proporcionamos nombre fino. Noé. Entonces escribiremos nuestra extensión está en la lista de formatos
válidos. Construiremos el
camino completo hacia nuestra imagen. Por lo que diremos parte de la
imagen es igual a OS dot, dot, dot join. Y aquí nos uniremos a
la parte de directorio, que es esta. Definimos nombre aquí parte. Con el financiamiento para
esta imagen en particular. El nombre completo de la
imagen será éste. Y también necesitamos anexar
nuestra imagen dos, nuestra lista. Ya terminamos con esta función. Sólo partes de imágenes escritas. Entonces ahora cuando esta
función tenemos la ruta completa a cada imagen en el conjunto de datos
almacenada en una lista. Por lo que el siguiente paso es usar esta imagen partes y cargar
el conjunto de datos más inteligente. Entonces podemos decir, vamos a crear una nueva función. Nómbralo célula de carga. Y aquí
aportaremos dos argumentos. El primero es
las partes de la imagen, y el segundo es el tamaño
objetivo de las imágenes. Aquí lo definimos. Digamos que el tamaño de la imagen
es igual a 3232. Trayectos de imagen corporal de imagen. Ahora podemos crear
dos listas vacías. Primero, le
nombraremos el pueblo, que lo hará, que
contendrá las imágenes. Y luego lo leemos. También lo puede hacer el llamado etiquetas, que contendrá la etiqueta para cada imagen sonriendo
o no sonriendo. Por lo que a continuación comenzaremos
por conseguir las imágenes. Para que podamos recorrer
las partes de la imagen. Diremos para vainas de parte de imagen. Aquí escribiremos
imagen es igual a, cargaremos nuestra imagen usando
la función load image. Aquí el primer argumento
es el camino hacia nuestra imagen. Y luego tenemos el
modo de color, que es escala de grises. Y luego el último argumento
es el tamaño objetivo, que podemos usar
nuestro tamaño objetivo. A continuación, necesitamos convertir
nuestra imagen a una matriz NumPy. Simplemente escribiremos imagen dos. Y finalmente, anexamos
nuestra imagen a los datos. Entonces aquí terminamos
con las imágenes. Ya podemos conseguir las etiquetas. Ahora para conseguir la etiqueta, podemos extraer eso
de la imagen. Pero así por ejemplo, aquí imprimiremos
las partes de la imagen. Y diremos: ver lo que obtenemos. Los datos. Proporcione la caja de la imagen. Entonces aquí como puedes ver, tenemos el bot a cada
imagen en nuestro conjunto de datos. Por ejemplo, aquí está el camino completo a esta imagen
en particular. Entonces si tomamos la parte completa, podemos extraer la
etiqueta de esta parte, que aquí es positivos. Entonces para esta imagen en particular, la persona está sonriendo. Tenemos una
cara sonriente en esta imagen. Por lo que para conseguir la etiqueta, aquí
encontraremos esta línea. Y escribiremos etiqueta es igual a enlace de imagen y
formaremos la imagen, pero la dividiremos
en base al separador de directorios, que es este separador aquí. Y nos llevaremos la
tercera desde el final. Entonces este es el primero, menos uno, menos dos,
y menos tres. Por lo que aquí vamos a conseguir etiqueta
es igual a dos positivos. Ahora diremos si nuestra etiqueta
es igual a dos positivos, codificaremos como uno. Entonces escribiremos uno. Si num es igual a positivos, lo contrario, lo
codificaremos tiene 0. Por último, añadimos nuestra
etiqueta a nuestra lista. El último paso es simplemente
devolver los datos, lista y lista. Nos aseguramos de
convertirlos a una matriz NumPy. Diremos return num pi dot, reescribimos las etiquetas top y
non pi dot. También escuchamos la
necesidad de escalar los datos al rango 01
dividiendo por 255. aquí a aquí podemos obtener nuestras tablas de datos
usando nuestra función.
4. Capacitación del detector de sonrisa: En esta parte
vamos a construir nuestro modelo y empezamos a entrenar. El modelo que vamos a
construir consiste en holgura para curvar a la marca más
desove a través de los blogs, seguido de una capa completamente
conectada. Por lo que como se puede ver
en esta imagen, tendremos esta capa delgada que max pooling a la capa. Y luego lo mismo aquí, C plus max pooling layers. Y entonces tendremos el bloque
totalmente conectado, que consiste en capa
aplanada, y luego una capa densa y otra capa que
esperará hacia afuera como. Entonces, vamos a crear una función. Le daremos el nombre de modelo. Y tomará la buena forma de un
argumento, que será igual a
la ciencia promedio. Brillo uno para una dimensión
de canal. Pero no necesitaríamos cambiar. En este tema. Usaremos modelos de esta
ecuación para que
podamos escribir murmurando,
queremos secuencial. Tendremos todos los filtros tomará trabajo sucio. Firma el gobernador. A ver, tamaño de tres por tres. Para la activación para hacer la función
de observación. O las Cruzadas. Misma buena forma. Utilizaremos alarma, vacaciones max-pooling, que
utilizaremos conciso a mi trabajo. Y luego lo mismo aquí de capa de pérdida de
fluido de los filtros. Doblaremos el
número de filtros. Y luego la capa aplanada. Con 256. Eres honesto. Y para la activación de la capa de salida. Tenemos. Ya que estamos lidiando con un problema de clasificación
binaria, usaremos la función de
activación sigmoide y os enviaremos todos. Entonces eres uno para la señal
de activación. Compilemos también nuestro modelo. Por lo que vamos a modelar dot
compilar la función de pérdida. Por supuesto que tomaremos
la cruz binaria en copia. El óptimo es 0. Digamos
optimizador o las métricas. Realmente llévate el Parker Awesome. A continuación tenemos que calcular
los pesos de las clases. Como dije antes, nuestro conjunto de datos está desequilibrado. Por lo que necesitamos darle más peso al vidrio subrepresentado. Smiling plus, en este caso, para que la modelo le preste
más atención a este vaso. Podemos empezar por contiene
el número de cada etiqueta usando la función
numpy dot único. Por lo que diremos, me olvida devolver el modelo. Entonces a cambio el modelo, y diremos recuentos de etiquetas
es la llamada a non pi. Lo que está corriendo en la
cabeza estaremos con nuestras etiquetas y
diremos retorno, cierto. Columnas de retorno es igual a mostrar, para devolver el número
de cada etiqueta. Vamos a imprimir estos. Diremos que
no tendremos no tendremos problema a los productos. Tenemos. Va aquí, ya que
no tenemos que etiquetar, todas las etiquetas están puestas a 0. Entonces ahora estamos en nuestro guión. Aquí. Como pueden ver, hemos formado una etiquetada 01, que sonríen
o no sonríen. Y para la
variable de conteo, tenemos 9,475. Despliega esta capa de forro. Tenemos 3,690. Entonces ahora necesitamos calcular
los pesos de clase. Por eso. Podemos utilizar
una operación más simple. Para que podamos escribir aquí conteos. Las nuevas cuentas serán
iguales a los recuentos max, que es aquí, y
lo dividimos por los conteos anteriores. Volvamos a mover estas dos
variables. Entonces aquí, como puedes ver, el más uno es
MyInt plus tendrá los pesos a 0.56
mayores que el más 0. Vamos a crear un diccionario que mapee cada
clase con su peso. Por lo que podemos escribir más
peso es igual. Usaremos la función zip. Por lo que el diccionario. Ahora necesitamos crear un conjunto de entrenamiento y un conjunto de
validación y un conjunto de pruebas. Tomaremos el 20% de los
datos para rezar este conjunto. Y del 80% restante, tomaremos el 20 por ciento para
crear el conjunto de validación. Entonces comencemos
con el conjunto de pruebas. Utilizaremos la función de
división de prueba de trenes para eso. Entonces nosotros, nos gustó que está tratando proporcionar nuestro día. Y luego seguido con este
tamaño se llevará el 20 por ciento. Diga, empieza la caída. Siguen su
propia demostración. O para hacer. Lo mismo
para el conjunto de validación. Acabamos de copiar y pegar. Cepa. Escurra lentamente. Nosotros proveemos. Correcto. Ahora estamos listos para entrenar nuestros modelos. Por lo que primero construiremos
el modelo escribiendo. El modelo es igual al módulo. Y entrenaremos el
modelo para caja 20. Entonces la caja es igual a uno. Historiador del arte es el
cuantil diría que es la maravilla por qué hoy. El conjunto de
validación de datos de validación. Y necesitamos usar el peso más para el tamaño del lote. Diga 64. Desplegó la caja, una caja. También guardemos el
modelo para después. Entonces simplemente podemos escribir uno no dice y lo nombraremos, dañará un brillo. Espera y espera
el archivo de inicio. Usamos el de hoy. Así que bienvenidos. entrenamiento no debe
tardar demasiado para que puedas esperar a que termine el
entrenamiento. Por lo que como se puede ver
lo que nuestros gimnasios y off aproximadamente 90 por ciento. Pero trazemos las curvas de
aprendizaje para visualizar nuestros resultados. Por lo que sólo voy a copiar
el código desde aquí. No hay nada especial. Aquí. Solo estamos trazando la precisión del entrenamiento,
la precisión de validación. Y luego tenemos la
pérdida de entrenamiento y la validación. Entonces volvamos a ejecutar el guión. Entonces aquí tenemos
la pérdida de entrenamiento, y aquí tenemos la precisión
de validación de entrenamiento de aproximarse aquí, 1, 2%. Lo que se puede notar que la
precisión de entrenamiento y validación aproximadamente aquí, entonces comienzan a divergir. Entonces esto es una señal
de sobreajuste. Podemos mejorar la precisión de nuestro modelo utilizando el aumento de
datos. Pero no
lo cubriré en esta clase. Así que vamos a evaluar nuestro
modelo en el conjunto de pruebas. Y podemos aplicar nuestro modelo
a resumen o a qué imágenes. Por lo que esta precisión de pérdida. Hay una gráfica de cuantiles que implica el uso del conjunto de pruebas. Aquí recientemente durante
el operador de pérdida , Impresionante. Entonces tenemos una cubierta de hierba, es aproximadamente
uno a persona.
5. Cómo aplicar nuestro detector de sonrisas a las imágenes: Ahora que nuestro modelo está entrenado, lo
aplicaremos a
algunas imágenes del mundo real. Entonces vamos a crear un
nuevo archivo Python. Lo llamaremos sonrisa, imagen
detector, PY. Y podemos empezar a
escribir algún código. Por lo que vamos
a importar a menudo decir v. Entonces
tenemos de esos modelos. Función de carga. También necesita. A continuación,
definamos algunas variables. Por lo que vamos a acreditar el
ancho es igual a 800. Digamos que la altura
es igual a 600. También creamos el color azul, por lo que es igual a 5500. Y ahora podemos cargar nuestra imagen. Entonces aquí tengo una carpeta
con algunas imágenes. Simplemente lo copiaré desde aquí. Tengo diez imagen. Tomaremos el
primero, nuestros modelos. Por lo que nos va a gustar imagen es igual
a CV demasiado alto un marino. Imágenes. Tomamos la primera corazonada. También hay que redimensionarlo. Por lo que nos va a gustar la herramienta de TV, cambiar el tamaño de la imagen y utilizar
el ancho y la altura. Y por último, convertimos
a muy tontos para no CBT convertir el pelo CV para
leer hay que gris. A continuación podemos comenzar a
detectar rostros utilizando el clasificador
en cascada Haar. Por lo que aquí he
definido nuestra cascada, frontal face default XML. Entonces solo lo pondré aquí, el directorio del proyecto,
y podemos cargarlo usando la función CV para
adoptar el clasificador en cascada. Por lo que vamos a escribir nuestro detector de
cara es igual a CV a clasificador en
cascada. Y aquí proporcionamos el nombre de que también necesitamos cargar nuestro modelo. Entonces diremos más de lo que
es igual al modelo. Aquí tenemos nombre de nuestro
modelo que es más que. Ahora podemos detectar rostros usando la función detectar multiescala. Al igual que estos rectángulos es
igual a nuestro detector de rostros. Para el primer argumento, proporcionamos nuestra imagen en escala de grises, y luego tenemos
el auto falso a escala. Lo pondremos como 1.1. Entonces hay que definir
los vecinos mínimos, que podemos ponerlo como. Estos parámetros funcionan. Bueno en mi caso, pero puedes
cambiarlos si quieres. Entonces aquí la
variable de rectángulos de cara contendrá
los cuadros delimitadores de cara. Por lo que el siguiente paso es hacer un bucle sobre los cuadros delimitadores de cara y
extraer la región de la cara. Diremos para x, y, ancho, y alto. En nuestro caso. Aquí primero haremos
rectángulo alrededor de la cara. Entonces nosotros, nos gusta TV2.com. Aquí. Sí conocemos nuestra imagen. Y vamos a dar
las cuentas MSDN, que son x e y. y luego tenemos dos diferentes
las grietas diagonales, que serían x plus y plus. Y luego tenemos el color azul y dos para el grosor. Y a la próxima semana arranca la región facial a partir de
la imagen en escala de grises. Aquí tenemos las coordenadas
de la cara. Entonces escribiremos a nuestro héroe ¿por qué? El llamado a Ray. Y simplemente usaremos rebanar. Por lo que surgiremos
de y a y más x. X más ancho. También necesitamos cambiar el tamaño de la región
facial y escalarla a 01 rama antes de
alimentarla a nuestro modelo. Por lo que mentiremos o y es igual
a CV para atracar el tamaño. Aquí aprenderemos
a dimensionarlo a 32 por 32 porque esto es lo que
usamos para entrenar nuestro modelo. Aquí para el
tamaño de la imagen tenemos 32 por 32. Después lo escalamos a
01, rama Dos, 55. También necesitamos agregar
la imagen a un lote. Lo haremos, porque aquí la imagen forma de
Treinta y dos. Treinta y dos. Nuestro modelo fue entrenado
en lotes de imágenes. Por lo que la nueva forma será
igual a T2, T2 por T2. Entonces escribiremos
y es igual a y. y utilizaremos la
función punto no canalizado, nuevo acceso a este
nuevo eje, eje y. Y aquí vamos a mantener
todo igual. Puede imprimir aquí el antes y después de acceder para ver
qué ha cambiado aquí. La forma. Lo mismo aquí. Aquí tenemos un error de
atributo o dos veces. En EU es letra mayúscula. Aquí. Como pueden ver, cómo yo antes de agregar el
nuevo eje es 32 por 32. Y después de agregar aquí
el eje u, Econ 132 por 32. Por lo que ahora el paso final es pasar la región de la
cara PARA no trabajar. Para clasificación. Nunca removemos. Escribiremos qué predicción es igual para predecir flecha y vamos a
imprimir diccionario. Por lo que normalmente hacer predicción
tendrá un valor entre 01. Aquí. Se puede ver aquí es el valor de la predicción
para esta imagen en particular. La predicción es 0.6. Entonces lo que podemos hacer ahora mismo es que nuestra etiqueta sea igual a, digamos, si la predicción es
mayor o igual a 0.5, vamos a crear la etiqueta a, vamos a poner la etiqueta a sonreír. De lo contrario lo
configuraremos para que no sonría. Por lo que etiquetaremos es
igual a sonreír. Si la predicción es
mayor o igual a 0.5, de lo contrario, no sonriendo. Eso se pone en la noche. Para revisar este caso, la etiqueta debe estar gastando su proceder con sonrisa para el día. Pero lo último que
tenemos que hacer es escribir el texto y la
imagen y mostrar la imagen. Al igual que CV. Para poner la x Aquí, le pondremos texto a eso. Y nos gustaría hacer el
etiquetado y la imagen. Para el texto de coordenadas, utilizaremos las
coordenadas de la cara. Entonces diremos x plus x e y. y para la fuente, puede elegir este es, digamos éste. Y para la escala de fuente, digamos 0.75, color azul. Formas de ver y CB2. Seguro que nos quedamos con nuestra columna. La persona no está sonriendo, pero nuestro modelo ha
detectado en la minería. Por supuesto, nuestro modelo no
es 100% exacto, por lo que esta es una predicción
positiva. Probemos con otra imagen. Digamos éste. Esta vez. Soy Armando ha pronosticado
con éxito la diapositiva. Podemos probarlo como está la
persona, no sonriendo. Entonces no tomaríamos este que puede probar con
las otras imágenes también. Y eso es con la imagen. La persona no está sonriendo. Y nuestro modelo ha detectado
con éxito.
6. Cómo aplicar nuestro detector de sonrisas a videos: Ahora que ya sabes cómo
detectar imágenes de sonrisas, digamos cómo aplicar nuestro
detector de sonrisas de aprendizaje profundo dos videos. Así que vamos a crear un nuevo archivo Python. Nómbrelo detector de sonrisa, PY. Y vamos a importar
las librerías para que el código no cambie
mucho de esto. Simplemente copiaré este
fino para pegarlo aquí. Entonces tenemos el
ancho y la altura. Cuando el color azul. Aquí, solo necesitamos inicializar los objetos de captura de video. Por lo que renovaríamos su copa. Seguro es igual a CV
a captura de video. Aquí proporcionamos el
nombre de nuestro video. Aquí tengo un video
pregrabado de mí en el que hice algunas pruebas. Por lo que sólo lo usaré para
esta parte del video aquí. Le hice algunas pruebas y
sonriente y mucho dinero. Por lo que aquí vamos a poner el
nombre del video mp4. Y entonces tenemos lo mismo. De esta parte. Necesitaremos enfrentar detector,
nuestra maravilla pre-entrenada, y vamos a detectar rostros, perdiendo la función de detección
multiescala. Por lo que sólo copiaremos
estas tres líneas aquí. Entonces aquí está nuestro diccionario. Leemos desde el
navegador los frames, para que podamos empezar a
procesar nuestros frames. Podemos decir, por qué es cierto. Entonces aquí vamos a sacar el siguiente fotograma del video. Entonces cuando decimos marco de acuerdo
a la captura de video. Y luego
lo convertiremos a varias curvas, CV a CV, CV a BGR. Y aquí podemos usar La función multiescala de Las excavaciones y la pasamos a lo largo del marco de escala de
grises. Ahora podemos recorrer los cuadros delimitadores de
cara. Por lo que sólo voy a
copiar el código de aquí porque todo
sigue igual aquí. Solo hay que cambiar aquí imagen, marco. Encuentra una nueva forma. Tú escribes el texto de la misma manera, y nosotros mostramos nuestro marco. Entonces solo copia el código desde aquí. Cómo CV mirar aquí en el encabezado, no
diríamos tu CV para mirar, Espera, espera un minuto. Entonces corriente es igual a q ¿De acuerdo? Nos desatamos. Por último, lanzamos la
captura de video y las ventanas. Veamos el resultado final. Diremos Python,
tres, lectura detector de sonrisa. Por lo que aquí se puede ver el
algoritmo no tiene problema detectar
sonriendo y sonriendo del video. La detección es bastante estable.
7. Conclusión: En esta clase
aprenderás a entrenar una red
neuronal convolucional para detectar sonreír en
imágenes y video. Lo primero que
tenemos que hacer es cargar nuestro conjunto de datos desde el disco y
prepararlo para nuestra red. A continuación, creamos
nuestra red neuronal. Y aquí calculamos peso
de la clase
para dar cuenta del desequilibrio de clases
en el conjunto de datos. Y así obligar al modelo a prestar más atención a la clase
subrepresentada. Entonces aquí, esta parte dividimos un conjunto de datos en
un conjunto de entrenamiento, conjunto de
validación
y un conjunto de pruebas, y luego procedemos a
entrenar nuestra red. Vimos que logramos una precisión del 90 por ciento en el conjunto de pruebas. El paso final fue probar nuestro modelo en imágenes y videos. Entonces para eso, utilizamos un clasificador en cascada Haar aquí en esta parte para detectar
el rostro en la imagen. Y luego extraemos
en esta parte aquí, la región de
la cara de la imagen y une la región facial para
predicción a nuestro modelo. Y por último, etiquetamos la imagen como sonriente
o no sonriente.
Yacine Rouizi
