Redes Neurais em IA e Deep Learning - página 17

[MetaQuotes]

PyTorch para aprendizaje profundo y aprendizaje automático: curso completo (descripción de las partes 21 a 24)

PyTorch para aprendizaje profundo y aprendizaje automático: curso completo

parte 21

• 20:00:00 En esta sección del curso, el instructor presenta el conjunto de datos Food 101, que incluye 101 categorías de alimentos diferentes con 101 000 imágenes. Sin embargo, para practicar el uso de PyTorch, el instructor ha creado un subconjunto más pequeño de este conjunto de datos que incluye tres categorías de alimentos y solo el 10 % de las imágenes. Este conjunto de datos más pequeño tiene 750 imágenes de entrenamiento, 250 imágenes de prueba y alrededor de 75 imágenes de entrenamiento y 25 imágenes de prueba por clase. Al comenzar con este conjunto de datos más pequeño, el objetivo es acelerar la experimentación y reducir el tiempo que lleva entrenar modelos. El instructor proporciona un cuaderno sobre cómo crear este conjunto de datos personalizado y alienta a los estudiantes a comenzar poco a poco y actualizar según sea necesario.
  
  
• 20:05:00 En esta sección, el instructor explica el proceso de descarga y preparación de un conjunto de datos de imágenes para PyTorch. El conjunto de datos incluye imágenes de pizza, bistec y sushi, que se almacenan en una carpeta llamada datos. El instructor usa la biblioteca de solicitudes de Python para descargar los datos y luego los descomprime en la carpeta de datos. El propósito de esta sección es demostrar cómo cargar datos de imagen en PyTorch, que se puede aplicar a cualquier proyecto similar. El instructor enfatiza la importancia de tener un directorio separado para los datos, que se puede ubicar en una computadora local o en la nube.
  
  
• 20:10:00 En esta sección, el instructor explica cómo usar la biblioteca de Python, zipfile, para extraer datos de un archivo zip. Usan el ejemplo de extraer un archivo zip que contiene imágenes de pizza, bistec y sushi para un problema de visión por computadora de aprendizaje automático. El instructor demuestra cómo extraer el contenido del archivo zip a una ruta de archivo específica usando el método zipfile.extractall(). También abordan un error en el código que resultó de copiar la dirección de enlace incorrecta de GitHub, enfatizando la importancia de garantizar que se use el enlace correcto para descargar conjuntos de datos. En general, el proceso que se muestra se puede usar para descargar y extraer cualquier conjunto de datos personalizado para usar en PyTorch. El próximo video explorará más los datos.
  
  
• 20:15:00 En esta sección, el instructor analiza la importancia de convertirse en uno con los datos a través de la preparación y exploración de datos. Comparte una cita inventada de la función de pérdida de Abraham, enfatizando la necesidad de dedicar mucho tiempo a preparar el conjunto de datos. Luego, el instructor recorre cada directorio de los datos de muestra descargados, que se encuentran en un formato de clasificación de imágenes estándar. Utiliza la función dot walk del sistema operativo para generar un árbol de directorios para cada directorio, mostrando información sobre los directorios y las imágenes presentes en cada uno. Finalmente, el instructor configura las partes de entrenamiento y prueba y demuestra la configuración estándar de clasificación de imágenes para ellas.
  
  
• 20:20:00 En esta sección, el instructor explica la estructura de datos de clasificación de imágenes estándar donde una carpeta de conjunto de datos general contiene carpetas de capacitación y prueba con subdirectorios con nombres de clase que contienen imágenes respectivas. El instructor señala que existen formas estandarizadas de almacenar tipos específicos de datos como referencia para los formatos de datos. Para preparar datos de imagen para su uso con PyTorch, se escribe código para convertir los datos en tensores. El instructor destaca el formato de datos necesario para clasificar las imágenes de perros y gatos, donde los directorios de imágenes de entrenamiento y prueba contienen carpetas de clase respectivas. El instructor también menciona los planes para visualizar una imagen y el código para lograr esto, lo que implica obtener todas las rutas de la imagen, elegir una ruta de imagen aleatoria y obtener el nombre de la clase de imagen mediante el módulo Pathlib.
  
  
• 20:25:00 En esta sección, el instructor explica cómo abrir y manipular imágenes usando la biblioteca de imágenes de Python llamada Pillow. Primero, generan una lista de todas las rutas de imágenes dentro de una carpeta específica y usan la biblioteca aleatoria de Python para seleccionar aleatoriamente una imagen de esta lista. Luego abren y muestran la imagen mientras también extraen metadatos sobre ella. Además, el instructor brinda una descripción general de las capacidades de la biblioteca Torch Vision, incluidos los métodos para cargar y procesar imágenes.
  
  
• 20:30:00 En esta sección, el instructor demuestra cómo trabajar con imágenes utilizando la biblioteca PIL y cómo abrir y analizar metadatos de imágenes. La clase de imagen es el nombre del directorio donde se almacenan los datos de la imagen y los metadatos se obtienen mediante la función Imprimir. Luego, el instructor muestra algunas imágenes aleatorias de alimentos del conjunto de datos, que incluyen pizza, sushi y bistec, y explica la importancia de visualizar imágenes al azar para familiarizarse con el conjunto de datos. El instructor ofrece un pequeño desafío para los espectadores, que consiste en visualizar una imagen usando Matplotlib para la siguiente sección.
  
  
• 20:35:00 En esta sección, el instructor muestra cómo trazar imágenes y datos con matplotlib y convertir imágenes en matrices usando el método NumPy NP. Se enfatiza la importancia de comprender la forma de los datos para evitar problemas de desajuste de forma. El formato predeterminado para la biblioteca de píldoras y matplotlib es el último formato de los canales de color, pero PyTorch tiene como valor predeterminado el primer formato de los canales de color. El instructor también muestra cómo visualizar diferentes imágenes y familiarizarse con los datos, y cómo transformar los datos convirtiéndolos en tensores de PyTorch para usar con PyTorch.
  
  
• 20:40:00 En esta sección, el instructor analiza el proceso de transformación de datos objetivo en tensores de PyTorch y la creación de conjuntos de datos y cargadores de datos de PyTorch. Usando la documentación de PyTorch, el instructor muestra cómo crear conjuntos de datos con el módulo de carpeta de imágenes e introduce el parámetro de transformación que permite la aplicación de transformaciones específicas en los datos. Luego, el instructor demuestra cómo crear una transformación para datos de imágenes que cambia el tamaño de las imágenes a 64x64 y las voltea aleatoriamente en el plano horizontal para aumentar artificialmente la diversidad del conjunto de datos. Esto se hace usando el método transforms.compose que toma una lista de transformaciones como argumento.
  
  
• 20:45:00 En esta sección, el instructor explica cómo transformar una imagen en un tensor de antorcha usando el módulo de transformación en PyTorch. Esto se hace con la función "transforms.ToTensor()", que convierte una imagen PIL o una matriz NumPy de altura con canales de color en el rango de 0 a 255 a un tensor flotante de antorcha de canales de color de forma ancho de altura en el rango de 0 a 1. El instructor sugiere tratar de pasar datos a través de esta transformación y muestra cómo cambiar la forma de la imagen usando la función "transforms.Resize()". La sección concluye con una discusión de las diversas transformaciones disponibles en la biblioteca de torchvision, incluidas las transformaciones de aumento de datos y una vista previa del próximo código de visualización para explorar las imágenes transformadas.
  
  
• 20:50:00 En esta sección, el instructor demuestra cómo muestrear aleatoriamente imágenes de una ruta, cargarlas y transformarlas, y luego comparar las versiones original y transformada usando PyTorch. El código usa la función de semilla aleatoria para establecer la semilla para la función aleatoria y muestra aleatoriamente k imágenes de la lista de rutas de imágenes. Luego, el instructor usa la biblioteca matplotlib para crear una subparcela con una fila y n columnas para trazar las imágenes originales y transformadas una al lado de la otra. La imagen transformada debe cambiar su forma para que se ajuste al formato preferido de canales de color de la biblioteca matplotlib. Finalmente, el código establece el título de las imágenes originales y transformadas y establece el supertítulo para el nombre de clase de la imagen.
  
  
• 20:55:00 En esta sección del video, el instructor demuestra cómo usar transformaciones para manipular datos de imágenes para modelos de aprendizaje profundo usando PyTorch. El instructor establece la transformación para que sea igual a la transformación de datos, lo que significa que la imagen cambiará de tamaño, se volteará horizontalmente de forma aleatoria y se convertirá en un tensor. También muestran cómo usar la función de permutación para reorganizar la forma de los datos intercambiando el orden de los ejes. Luego, las imágenes se trazan para mostrar las versiones original y transformada una al lado de la otra, con las imágenes transformadas en formato de tensor, que es ideal para usar con modelos de aprendizaje profundo. El instructor advierte que el tamaño de la imagen es un hiperparámetro que se puede ajustar y alienta a los espectadores a explorar la amplia gama de transformaciones disponibles en PyTorch.

parte 22

• 21:00:00 En esta sección, el instructor explica cómo cargar datos de imágenes usando la opción de carpeta de imágenes. Utilizan el módulo de conjuntos de datos de visión de antorcha para mostrar cómo cargar datos en el formato de clasificación de imágenes genéricas. Se demuestra la función de conjuntos de datos prediseñados, carpeta de imágenes, que luego se puede usar para cargar todas las imágenes personalizadas en tensores con la ayuda de transformaciones. Luego, el instructor muestra cómo transformar el conjunto de datos de entrenamiento y crear un conjunto de datos de prueba, que también se transformará de la misma manera que el conjunto de datos de entrenamiento. Finalmente, imprimen los conjuntos de datos creados.
  
  
• 21:05:00 En esta sección, el instructor explica cómo usar la función de carpeta de imágenes en PyTorch para cargar imágenes en tensores y transformarlas usando una canalización, que luego se puede usar con un modelo de PyTorch. Demuestran cómo acceder y utilizar varios atributos que vienen con el cargador de datos preconstruido, como obtener nombres de clase como una lista o diccionario y verificar la longitud del conjunto de datos. Además, muestran cómo visualizar muestras y etiquetas del conjunto de datos de entrenamiento mediante la indexación.
  
  
• 21:10:00 En esta sección del curso, el instructor demuestra cómo convertir un conjunto de datos de imagen en formato de tensor, que es el formato de datos predeterminado para PyTorch. Usan un ejemplo de una imagen de pizza y muestran cómo obtener su etiqueta asociada y convertirla a formato numérico. Luego imprimen información importante sobre los datos del tensor, como su tipo de datos y forma, que será útil para solucionar problemas más adelante. Finalmente, trazan la imagen usando matplotlib y asignan el título al nombre de la clase, que en este caso es pizza. Animan a los estudiantes a probar esto con diferentes imágenes y explorar diferentes transformaciones.
  
  
• 21:15:00 En esta sección del video, el instructor analiza el proceso de convertir imágenes cargadas en cargadores de datos en PyTorch. Un cargador de datos puede ayudar a convertir conjuntos de datos en iterables, lo que permite a los usuarios personalizar el tamaño del lote y ver una cantidad específica de imágenes a la vez. Esto es importante porque si todas las imágenes se cargaron a la vez, existe el riesgo de quedarse sin memoria. Por lo tanto, la agrupación de imágenes ayuda a aprovechar toda la memoria disponible. El instructor continúa brindando una guía paso a paso para crear un cargador de datos de tren y también presenta el concepto de la cantidad de parámetros de trabajo, que decide cuántos núcleos de CPU se usan para cargar datos.
  
  
• 21:20:00 En esta sección, el instructor explica cómo crear y personalizar cargadores de datos para entrenar y probar datos en PyTorch. Muestra cómo inicializar conjuntos de datos y personalizar hiperparámetros para los cargadores de datos, como el tamaño del lote y la cantidad de trabajadores. El instructor también demuestra cómo iterar a través de los cargadores y obtener información sobre la forma de las imágenes y las etiquetas. La sección concluye con un resumen del proceso de carga y una recomendación para construir una red neuronal convolucional para identificar patrones en tensores de imagen.
  
  
• 21:25:00 En esta sección, el instructor analiza el proceso de creación de una clase de carga de datos personalizada para cargar datos de imagen en formato Tensor. El objetivo es replicar la funcionalidad de la carpeta de imágenes a través de esta clase personalizada, ya que es una buena práctica y puede ser necesaria en los casos en que no exista una función preconstruida. El instructor enumera los pasos necesarios para que la clase personalizada cargue imágenes, obtenga nombres de clases como una lista y obtenga clases como un diccionario del conjunto de datos. También se analizan los pros y los contras de crear un conjunto de datos personalizado, incluida la flexibilidad para crear un conjunto de datos a partir de casi cualquier cosa, pero también la posibilidad de errores y problemas de rendimiento. Luego, el instructor importa los módulos necesarios para crear la clase personalizada, incluido el sistema operativo y la ruta lib para trabajar con el sistema de archivos.
  
  
• 21:30:00 En esta sección, estamos aprendiendo cómo crear un conjunto de datos personalizado en PyTorch y nos enfocamos en escribir una función para obtener nombres de clase del directorio de destino. El conjunto de datos personalizado se usará para cargar imágenes desde un archivo, obtener nombres de clases del conjunto de datos y obtener clases como un diccionario del conjunto de datos. La función usará el escáner del sistema operativo para atravesar el directorio de destino y obtener los nombres de las clases y generará un error si no se encuentran los nombres de las clases, lo que indica un problema con la estructura del directorio. Posteriormente crearemos una subclase de torch.utils.data.Dataset para crear un conjunto de datos personalizado.
  
  
• 21:35:00 En esta sección del video, el instructor demuestra cómo crear una función llamada "find_classes" que toma un directorio como una cadena y devuelve una lista de nombres de clase y un diccionario que asigna los nombres de clase a números enteros. La función utiliza el escáner del sistema operativo para escanear el directorio de destino y obtener los nombres de las clases. El instructor también demuestra cómo generar un error si no se pueden encontrar los nombres de las clases. La función se puede usar para cualquier directorio dado y replica la funcionalidad realizada anteriormente para el directorio de entrenamiento.
  
  
• 21:40:00 En esta sección del video, el instructor explica cómo crear un conjunto de datos personalizado subclasificando torch.utils.data.dataset. El conjunto de datos debe representar un mapa de claves a muestras de datos, donde las claves se refieren a objetivos o etiquetas, y las muestras de datos en este caso son imágenes de alimentos. La subclase debe anular el método get item, que obtiene una muestra de datos para una clave determinada y, opcionalmente, sobrescribir el método len para devolver el tamaño del conjunto de datos. El instructor recorre los pasos para crear el conjunto de datos personalizado y explica cómo usar la función auxiliar que creamos en la sección anterior para asignar nombres de clase a números enteros.
  
  
• 21:45:00 En esta sección, el instructor explica cómo crear un conjunto de datos personalizado en PyTorch. Para hacer esto, necesitamos crear una subclase de la clase torch.utils.data.Dataset e inicializar nuestro conjunto de datos personalizado pasando el directorio de destino (donde residen los datos) y transformar (para realizar cualquier transformación de datos). Además, necesitamos crear varios atributos como rutas, transformación, clases y clase para ID X. Además, necesitamos crear una función para cargar imágenes, anular el método LAN para devolver la longitud de nuestro conjunto de datos y obtener método de elemento para devolver una muestra dada cuando se pasa un índice. Finalmente, escribimos un conjunto de datos personalizado implementando pathlib y pasando directorios de destino como los directorios de prueba o tren.
  
  
• 21:50:00 En esta sección, el instructor explica los diferentes pasos involucrados en la creación de una clase de conjunto de datos de PyTorch personalizada. El primer paso implica obtener todas las rutas de imagen que siguen la convención de nombre de archivo correcta. El siguiente paso es crear un conjunto de transformaciones de imágenes, que pueden ser opcionales. También se crea una función para cargar imágenes, que toma un índice y devuelve una imagen. Luego, el instructor muestra cómo anular el método "len" para devolver el número total de muestras en el conjunto de datos, que es opcional. Por último, el método "obtener elemento" se sobrescribe para que devuelva una muestra en particular si se le pasa un índice.
  
  
• 21:55:00 En esta sección, aprendemos a crear subclases de torch.utils.data.Dataset para personalizar la forma en que se cargan los datos en PyTorch. La clase se inicializa con un directorio raíz y un diccionario que asigna nombres de clase a índices. El método __len__ devuelve la longitud del conjunto de datos, mientras que __getitem__ permite la indexación en el conjunto de datos para devolver una tupla de una imagen de tensor de antorcha y la etiqueta entera correspondiente. La clase también tiene un parámetro de transformación opcional para aplicar transformaciones en la imagen antes de devolver la tupla. Las ventajas de subclasificar torch.utils.data.Dataset son las capacidades de personalización que ofrece, pero requiere escribir cantidades significativas de código que pueden ser propensos a errores.

parte 23

• 22:00:00 En esta sección, el instructor muestra cómo crear un conjunto de datos personalizado en PyTorch utilizando el módulo Torchvision. Crean una transformación para convertir imágenes JPEG sin procesar en tensores y configuran la composición de transformaciones de entrenamiento y prueba. Luego prueban la clase de carpeta de imagen personalizada y ven si funciona en su propio conjunto de datos personalizado. Comprueban los atributos de longitud y clase para asegurarse de que funciona correctamente. Finalmente, inspeccionan el personalizado de datos del tren y el personalizado de datos de prueba para verificar que todo funcione como se esperaba.
  
  
• 22:05:00 En esta sección del curso completo de PyTorch para aprendizaje profundo y aprendizaje automático, el instructor demuestra cómo verificar la igualdad entre el conjunto de datos de la carpeta de imágenes original y el conjunto de datos personalizado que creó en la sección anterior al comparar la clase con el ID. X de ambos conjuntos de datos. Afirma que podemos replicar la funcionalidad principal de la clase de conjunto de datos de la carpeta de imágenes mediante la creación de nuestra propia función de carga de conjuntos de datos personalizados, y las conclusiones de esto son que PyTorch proporciona una clase de conjunto de datos base para heredar, y siempre que anulemos la tierra y obtener métodos de elementos y devolver algún tipo de valores, podemos crear nuestra propia función de carga de conjuntos de datos. El instructor procede a explicar cómo crear una función para mostrar imágenes aleatorias de la clase personalizada de datos entrenados para visualizar nuestros datos.
  
  
• 22:10:00 En esta sección, el instructor recorre los pasos para crear una función llamada "mostrar imágenes aleatorias" que toma un "conjunto de datos", "clases" y "n" como parámetros. La función muestra un número n de imágenes seleccionadas al azar del conjunto de datos e imprime su forma si "mostrar forma" se establece en verdadero. El instructor también revisa los detalles de implementación, como ajustar la pantalla si n es mayor que 10 y establecer la semilla aleatoria para la reproducibilidad. Además, la función recorre las imágenes de muestra aleatorias o los índices y los traza con Matplotlib.
  
  
• 22:15:00 En esta sección, el instructor continúa construyendo su modelo de aprendizaje profundo en PyTorch configurando la trama y asegurándose de que las dimensiones de sus imágenes se alineen con matplotlib. Ajustan sus dimensiones de tensor para el trazado, agregan una subtrama a su trama matplotlib y ajustan el título de la trama en función de la variable de clases, una lista de clases. Luego crean una función para mostrar imágenes aleatorias de la carpeta de imágenes, tanto para la carpeta de imágenes de pytorch incorporada como para el conjunto de datos personalizado creado por el instructor. Finalmente, ajustan la semilla y trazan las imágenes para ver cómo tiene sentido su código para ajustar la trama.
  
  
• 22:20:00 En esta sección de la transcripción, el instructor demuestra cómo convertir un conjunto de datos de imagen cargado personalizado en cargadores de datos, lo cual es un paso necesario para agrupar las imágenes en lotes y usarlas con un modelo. Usando torchvision.datasets.ImageFolder y torchvision.transforms, el conjunto de datos personalizado se convierte en un formato de tensor. El siguiente paso es convertir el conjunto de datos en un cargador de datos usando torch.utils.data.DataLoader. El instructor establece el tamaño del lote en 32 y el número de trabajadores en 0 para el cargador de datos de entrenamiento personalizado y el cargador de datos de prueba personalizado. La diferencia entre ellos es que los datos del tren se mezclarán mientras que los datos de la prueba no se mezclarán.
  
  
• 22:25:00 En esta sección, el video cubre los cargadores de datos personalizados y la transformación de datos en PyTorch. El instructor primero restablece el recuento de CPU OOS y establece los trabajadores insensibles en cero para garantizar que la capacitación se desarrolle sin problemas. Después de configurar el cargador de datos personalizado, usa la función de impresión para verificar la forma de la imagen y el tamaño del lote, que se establecieron en 32 por la transformación que se configuró previamente. El instructor también explica cómo el aumento de datos puede aumentar artificialmente la diversidad del conjunto de datos de entrenamiento y demuestra las diversas formas en que los datos se pueden transformar utilizando el módulo de transformación de visión de la antorcha, incluido el cambio de tamaño, el recorte central, la escala de grises, las transformaciones aleatorias y el aumento aleatorio. .
  
  
• 22:30:00 aprendí sobre el aumento de datos, que es el proceso de agregar artificialmente diversidad a sus datos de entrenamiento mediante la aplicación de varias transformaciones de imágenes. Esto ayuda a que el modelo sea más generalizable a datos no vistos. Hay muchos tipos diferentes de aumento de datos, como recortar, reemplazar, cortar y más. PyTorch tiene un paquete de visión de antorcha que incluye primitivas o funciones que pueden ayudar a entrenar modelos para que funcionen bien. Mediante el uso de aumento de datos y otras mejoras, PyTorch ha podido entrenar modelos de última generación con alta precisión, como el modelo ResNet 50.
  
  
• 22:35:00 En esta sección, el instructor analiza formas de mejorar la precisión del modelo, como la optimización de la tasa de aprendizaje, la capacitación durante más tiempo y el uso de diferentes técnicas de aumento. El instructor se enfoca en la técnica de aumento trivial, que aprovecha el poder de la aleatoriedad para cambiar las imágenes de varias maneras utilizando varios contenedores de magnitud. El instructor demuestra cómo implementar un aumento trivial utilizando la biblioteca de transformaciones de visión de la antorcha PyTorch y proporciona un enlace al documento para aquellos interesados en leer más al respecto. Además, el instructor aconseja probar diferentes técnicas y experimentos de aumento para ver qué funciona mejor para problemas individuales. Finalmente, el instructor muestra cómo probar la canalización de aumento obteniendo todas las rutas de imágenes y agregando todos los archivos y carpetas que coinciden con un patrón específico.
  
  
• 22:40:00 En esta sección, el video demuestra el uso de aumento trivial, una técnica de aumento de datos, en la transformación de imágenes para agregar artificialmente diversidad a un conjunto de datos de entrenamiento. El poder de la aleatoriedad se aprovecha seleccionando entre diferentes tipos de aumento y aplicándolos con diferentes niveles de intensidad. Esta sección muestra cómo se aplica el aumento trivial a imágenes transformadas aleatoriamente y se muestran los resultados. El objetivo es permitir que el modelo de aprendizaje automático aprenda los patrones de las imágenes manipuladas y pueda identificarlas en consecuencia. La siguiente sección se enfoca en construir el primer modelo de visión por computadora sin aumento de datos utilizando la pequeña arquitectura VGG.
  
  
• 22:45:00 En esta sección, el presentador recorre el proceso de creación de transformaciones y carga de datos para un modelo de PyTorch. El objetivo es cargar imágenes de la carpeta de datos, en este caso, pizza, bistec y sushi, y convertirlas en tensores. Las transformaciones incluyen cambiar el tamaño de las imágenes a 64x64 y convertirlas en tensores para que los valores estén entre 0 y 1. El presentador también explica cómo crear cargadores de datos y ajustar el tamaño del lote y la cantidad de núcleos de CPU dedicados a cargar los datos. El tamaño de lote utilizado en este ejemplo es 32.
  
  
• 22:50:00 En esta sección, el instructor explica cómo cargar y transformar datos usando DataLoader de PyTorch. El proceso implica crear una transformación y luego cargar y transformar los datos al mismo tiempo usando la función DataLoader. El instructor también proporciona un código simple para construir la arquitectura Tiny VGG desde cero, que incluye la creación del primer bloque COM que consta de capas como COM, ReLU, MaxPool y ComToD. El modelo se inicializa con la forma de entrada, las unidades ocultas y los parámetros de forma de salida. El instructor alienta a los alumnos a experimentar con diferentes valores para los hiperparámetros, como el tamaño del núcleo y la zancada.
  
  
• 22:55:00 En esta sección, vemos la creación de una red neuronal convolucional usando PyTorch. Comenzamos definiendo los bloques convolucionales y las capas de agrupación máxima para la red. Luego, replicamos el mismo bloque para crear otro y cambiamos la forma de entrada para que coincida con la forma de salida. A continuación, creamos una capa clasificadora para convertir la salida de los bloques convolucionales en un vector de características y lo pasamos a través de una capa lineal para generar diez clases. Finalmente, anulamos el método directo para pasar los datos a través de los bloques convolucionales e imprimir su forma en cada paso. El método directo también podría reescribirse para incluir la fusión de operadores, lo que acelera el cálculo de la GPU.

parte 24

• 23:00:00 En esta sección, el instructor analiza el concepto de fusión de operadores, que es la optimización más importante en los compiladores de aprendizaje profundo. También crean un modelo utilizando la pequeña arquitectura VGG para imágenes en color RGB y verifican sus formas de entrada y salida. El instructor destaca la importancia de usar la fusión de operadores para acelerar la computación de grandes redes neuronales al evitar el transporte entre la memoria y la computación. También sugieren pasar datos ficticios a través del modelo para solucionarlo y asegurarse de que el método de reenvío funcione correctamente. Finalmente, se muestra un mensaje de error al intentar pasar el lote de imágenes al modelo debido a una falta de coincidencia en los tipos de entrada.
  
  
• 23:05:00 En esta sección, el instructor soluciona un error de forma del modelo. Explican que las reglas de multiplicación de matrices deben cumplirse al pasar tensores a través de capas lineales. El instructor investiga las formas de la matriz y determina que 10, que representa el número de unidades ocultas, está causando un problema cuando se multiplica por 2560. Usan la forma de salida de la capa anterior para determinar que 10 debe multiplicarse por 16x16 para obtener 2560. Después de corregir esto y al verificar que las formas del modelo se alinean con la salida del explicador de CNN, pasan a una solución de problemas adicional y eventualmente descubren que quitar el relleno de las capas convolucionales alineará las formas con la salida del explicador de CNN.
  
  
• 23:10:00 En esta sección, el instructor presenta Torch Info, un paquete que permite a los usuarios imprimir un resumen de sus modelos de PyTorch. Primero, el instructor comenta las declaraciones impresas del método directo e instala Torch Info en Google CoLab usando el comando pip install. Luego, el instructor importa el resumen de Torch Info y lo usa para pasar el modelo y un tamaño de entrada para obtener las formas de los datos que fluyen a través del modelo. El instructor muestra cómo Torch Info imprime un resumen del modelo, incluidas las capas y sus formas correspondientes.
  
  
• 23:15:00 En esta sección, el orador analiza el paquete de información de la antorcha, que se utiliza para dar una idea de las formas de entrada y salida de cada capa en un modelo de PyTorch. Explican que el paquete también proporciona información sobre la cantidad de parámetros en cada capa, lo que puede ser útil para determinar el tamaño del modelo y las restricciones de almacenamiento para aplicaciones futuras. El orador señala que a medida que un modelo se hace más grande y tiene más capas, tendrá más parámetros, lo que dará como resultado un tamaño de entrada más grande y un tamaño total estimado. En la siguiente sección, el orador avanza hacia el entrenamiento de un conjunto de datos personalizado y crea dos funciones, paso de entrenamiento y paso de prueba, que son genéricas y se pueden usar con casi cualquier modelo y cargador de datos. La función de paso de entrenamiento toma un modelo, un cargador de datos, una función de pérdida y un optimizador, y pone el modelo en modo de entrenamiento mientras configura las métricas de evaluación.
  
  
• 23:20:00 En esta sección, el orador analiza la configuración de los valores de pérdida y precisión del tren para una función de bucle de tren en PyTorch. Los datos se recorren mediante el cargador de datos y, para cada lote, se realiza el pase hacia adelante para hacer predicciones y calcular la pérdida. Luego, el optimizador se usa para realizar la retropropagación y dar un paso. Una vez que se completa el bucle del tren, se calcula la precisión obteniendo la clase predicha y comparándola con las etiquetas correctas. Esto se hace fuera del ciclo de lotes, donde la pérdida del tren y la precisión del tren se ajustan para obtener el promedio por época en todos los lotes. Luego, el orador desafía a los espectadores a escribir una función de bucle de prueba.
  
  
• 23:25:00 En esta sección, el instructor recorre el proceso de creación de un paso de prueba para evaluar el rendimiento de un modelo de aprendizaje profundo de PyTorch en un conjunto de datos. El paso consiste en configurar el modelo en modo de evaluación, recorrer los lotes del conjunto de datos, enviar los datos al dispositivo de destino, realizar un avance, calcular la pérdida y la precisión por lote, acumular la pérdida y la precisión y ajustar las métricas. para obtener los valores medios. Luego, el instructor sugiere crear una función de entrenamiento para funcionalizar el proceso de entrenamiento del modelo, que se tratará en la siguiente sección.
  
  
• 23:30:00 En esta sección, el instructor recorre el proceso de creación de una función de entrenamiento que combina las funciones de paso de entrenamiento y paso de prueba. La idea es crear una función para llamar a ambas funciones para entrenar y evaluar un modelo con solo una llamada de función. La función de tren toma una variedad de parámetros del modelo, incluidos el optimizador, los cargadores de datos, la función de pérdida y otros. Luego, el instructor crea un diccionario vacío para ayudar a rastrear el rendimiento del modelo a medida que se entrena, incluida la pérdida y la precisión del entrenamiento y la prueba. Luego recorren las épocas, llamando a TQDM para obtener una barra de progreso mientras el modelo se está entrenando. La función de entrenamiento es una herramienta útil para no tener que volver a escribir el código al entrenar más modelos y aprovechar el código existente.
  
  
• 23:35:00 En esta sección, el instructor explica la función de entrenamiento que realiza un seguimiento del entrenamiento y las pruebas mediante las funciones de paso de entrenamiento y prueba, respectivamente. La función se ejecutará durante un número específico de épocas y, para cada época, imprimirá el tren y probará la pérdida y la precisión mediante una declaración de impresión elegante. Los resultados se almacenarán en el diccionario de resultados para ser utilizados posteriormente para el análisis. La función de tren aprovechará la función de paso de tren y la función de paso de prueba para actualizar el modelo y probarlo respectivamente. La función devolverá los resultados de la época.
  
  
• 23:40:00 En esta sección, el instructor revisa el progreso realizado en el flujo de trabajo de PyTorch, que incluye la preparación de datos, la construcción y selección de un modelo, la construcción de un ciclo de entrenamiento y ahora el desafío de crear una función de pérdida y un optimizador. Pasando a la sección 7.7, el instructor explica cómo entrenar y evaluar el modelo cero, el modelo de referencia, en su conjunto de datos personalizado. Establecieron las semillas aleatorias para la reproducibilidad, instanciaron el diminuto modelo VGG con una forma de entrada de tres para imágenes en color, establecieron la cantidad de unidades ocultas y la forma de salida para que coincida con la cantidad de clases en su conjunto de datos de entrenamiento. También seleccionan la función de pérdida de entropía cruzada para la clasificación multiclase y prueban el optimizador de Adam con una tasa de aprendizaje de 0,001.
  
  
• 23:45:00 En esta sección, el instructor muestra cómo cronometrar el proceso de capacitación de un modelo de aprendizaje profundo. Primero importan la clase de temporizador predeterminada de time y luego inician el temporizador antes de entrenar el modelo cero usando la función de tren de un video anterior. Luego configuraron los datos del tren para entrenar el cargador de datos simple y los datos de prueba para probar el cargador de datos simple, así como el optimizador para FriendlyAtomOptimizer y la función de pérdida para la pérdida de entropía cruzada n. El modelo se entrena durante cinco épocas y el temporizador finaliza para mostrar el tiempo total de entrenamiento. Luego, el instructor muestra los resultados de precisión del modelo en los conjuntos de entrenamiento y prueba, que están alrededor del 40 % y 50 % respectivamente. Sugieren probar diferentes métodos para mejorar el modelo, como agregar más capas o unidades ocultas, ajustar por más tiempo, cambiar las funciones de activación y ajustar la tasa de aprendizaje.
  
  
• 23:50:00 En esta sección, el instructor explica cómo trazar curvas de pérdida para seguir el progreso del modelo a lo largo del tiempo. Una curva de pérdida es una forma de seguir el progreso de un modelo a lo largo del tiempo al visualizar el valor de pérdida a la izquierda y los pasos en el eje inferior. Al trazar los valores de precisión y pérdida de prueba y tren de nuestro diccionario de resultados usando matplotlib, podemos ver cómo se está desempeñando nuestro modelo y evaluarlo. El instructor escribe una función llamada "curvas de pérdida de diagrama de definición" que toma un diccionario de resultados que contiene los valores de pérdida y precisión como una cadena y una lista de flotantes.
  
  
• 23:55:00 En esta sección, el instructor muestra cómo crear curvas de pérdida para datos de entrenamiento y prueba utilizando épocas como métrica de tiempo. La trama consta de dos subtramas, una de pérdida y otra de precisión, con etiquetas y títulos para cada una de ellas. La tendencia ideal para una curva de pérdida es que la pérdida disminuya con el tiempo y la precisión aumente. El instructor anima al espectador a experimentar con épocas adicionales para ver si la pérdida alcanza el valor óptimo. El próximo video cubrirá diferentes formas de curvas de pérdida, y el instructor recomienda una guía para interpretar las curvas de pérdida.

[MetaQuotes]

PyTorch para aprendizaje profundo y aprendizaje automático: curso completo (descripción de las partes 25 y 26)

PyTorch para aprendizaje profundo y aprendizaje automático: curso completo

parte 25

• 24:00:00 En esta sección del curso PyTorch para aprendizaje profundo y aprendizaje automático, el instructor analiza las curvas de pérdida y su importancia en la evaluación del rendimiento de un modelo a lo largo del tiempo. Una curva de pérdida debe mostrar una tendencia de pérdida decreciente a lo largo del tiempo y una precisión creciente. Existen diferentes formas de curvas de pérdida, y una curva de pérdida ideal muestra que la pérdida de entrenamiento y prueba disminuyen a un ritmo similar. El ajuste insuficiente ocurre cuando la pérdida del modelo podría ser menor, mientras que el ajuste excesivo ocurre cuando el modelo aprende demasiado bien los datos de entrenamiento, lo que lleva a una pérdida de entrenamiento menor que la pérdida de prueba. El instructor proporciona un plan de estudios adicional de la guía de la curva de pérdida de Google y analiza los métodos para abordar el sobreajuste, como las técnicas de regularización y la reducción de la complejidad del modelo.
  
  
• 24:05:00 algunas formas de reducir el sobreajuste en su modelo de aprendizaje profundo que se discutieron en esta sección. Obtener más datos a través del aumento de datos o una mejor calidad de los datos puede ayudar a que su modelo aprenda patrones más generalizables. Usar el aprendizaje por transferencia tomando patrones aprendidos de modelos previamente entrenados y aplicándolos a su propio conjunto de datos también puede ser efectivo. Simplificar su modelo reduciendo el número de capas o unidades ocultas también puede ayudar. La disminución de la tasa de aprendizaje puede ayudar al disminuir la tasa de aprendizaje con el tiempo, y detenerse antes de tiempo puede detener el proceso de entrenamiento antes de que ocurra el sobreajuste.
  
  
• 24:10:00 En esta sección, se analiza el concepto de detención anticipada como método para abordar el sobreajuste en el aprendizaje automático. Antes de que el error de prueba comience a aumentar, se realiza un seguimiento del error de prueba del modelo y se detiene el entrenamiento del modelo o se guardan los pesos/patrones donde la pérdida del modelo fue menor. También se exploran diferentes métodos para lidiar con el ajuste insuficiente, como agregar más capas/unidades al modelo, ajustar la tasa de aprendizaje, capacitar durante más tiempo y usar el aprendizaje por transferencia. Se enfatiza el equilibrio entre el ajuste excesivo y el ajuste insuficiente, y se destaca la importancia de evaluar el rendimiento de un modelo a lo largo del tiempo utilizando curvas de pérdida. Finalmente, se analizan las formas de evitar la regularización excesiva del modelo y terminar con un ajuste insuficiente, y se enfatiza el objetivo de lograr un equilibrio justo entre el ajuste insuficiente y el sobreajuste.
  
  
• 24:15:00 En esta sección del video sobre PyTorch para el aprendizaje profundo y el aprendizaje automático, el instructor analiza el concepto de sobreajuste y desajuste en los modelos, junto con las formas de manejarlos. El aumento de datos es uno de los métodos introducidos para lidiar con el sobreajuste, donde las imágenes se manipulan para aumentar la diversidad del conjunto de datos de entrenamiento. Luego, el instructor continúa demostrando cómo crear una transformación con aumento de datos y cargar datos usando esas transformaciones para crear conjuntos de datos de entrenamiento y prueba y cargadores de datos. El video enfatiza la importancia de probar diferentes modelos con varios ajustes y transformaciones para encontrar el que mejor se adapte a un problema en particular.
  
  
• 24:20:00 En esta sección del video, el instructor recorre el proceso de creación de un conjunto de datos y un cargador de datos mediante transformaciones de PyTorch y la clase ImageFolder. Proporcionan ejemplos de código y alientan a los espectadores a probarlo por su cuenta si lo desean. El conjunto de datos se crea a partir de imágenes de pizza, bistec y sushi para las carpetas de entrenamiento y prueba. El instructor también analiza la importancia de ser claro con los nombres de las variables cuando se trabaja con nombres similares en todo el cuaderno. Configuraron los cargadores de datos para los conjuntos de datos de entrenamiento y prueba, y el conjunto de datos de entrenamiento se aumentó con la función trivial de aumento amplio. Luego, el instructor sugiere que los espectadores construyan y entrenen el modelo uno utilizando la pequeña clase VGG y la función de entrenamiento.
  
  
• 24:25:00 En esta sección del curso completo de PyTorch, el instructor guía al espectador a través del proceso de creación y entrenamiento de un nuevo modelo usando la misma arquitectura que antes, pero con datos de entrenamiento aumentados. El objetivo es comparar el rendimiento de este modelo con el modelo de referencia sin aumento de datos. El instructor usa la clase creada previamente para el pequeño modelo VGG y establece una semilla manual para la reproducibilidad. Luego definen la función de pérdida y el optimizador, configuran los hiperparámetros e inician el temporizador. Finalmente, el instructor entrena el modelo llamando a la función de entrenamiento creada previamente, pasando el modelo y los cargadores de datos, y evaluando los resultados.
  
  
• 24:30:00 En esta sección, el instructor continúa el entrenamiento del segundo modelo con aumento de datos y muestra que no se desempeñó tan bien como el primer modelo sin aumento de datos debido a que la pérdida ya estaba bajando y allí no estaba demasiado sobreajustado. Luego, el instructor introduce una función para trazar curvas de pérdida y la usa para evaluar el rendimiento del segundo modelo. La curva de pérdida muestra que el modelo se está ajustando por debajo y posiblemente sobreajustado, lo que se indica por la mayor pérdida de prueba en comparación con la pérdida de entrenamiento. Luego, el instructor plantea la pregunta de qué se puede hacer para abordar tanto el ajuste insuficiente como el sobreajustado en el modelo, sugiriendo opciones como obtener más datos, simplificar el modelo, usar el aprendizaje por transferencia o agregar más capas.
  
  
• 24:35:00 En esta sección, el instructor analiza la importancia de comparar los resultados del modelo y proporciona algunas herramientas, como PyTorch más TensorBoard y pesos y sesgos, para realizar un seguimiento de diferentes experimentos. Sin embargo, enfatiza que este curso se centrará solo en PyTorch puro por ahora. Luego, el instructor configura una gráfica para comparar los resultados del modelo uno al lado del otro, utilizando marcos de datos para cada uno de los resultados del modelo. También sugiere probar un experimento para entrenar el modelo cero durante más tiempo para ver si mejora. En última instancia, comparar diferentes experimentos y sus métricas entre sí visualmente es crucial para mejorar los modelos.
  
  
• 24:40:00 En esta sección, el instructor usa subparcelas para comparar diferentes métricas en dos modelos con los que experimentó. Comienzan creando un rango para el número de épocas y luego crean un gráfico para la pérdida de trenes usando PLT.subplot() y PLT.plot(). Hacen lo mismo para la pérdida de prueba y la precisión de los datos de entrenamiento y prueba. El instructor señala que el modelo uno, que implementó el aumento de datos, parece estar sobreajustado en esta etapa, mientras que el modelo cero se está desempeñando mejor en términos de pérdida. El instructor sugiere que si tuvieran más modelos para comparar, podrían convertir esto en una función, pero también señala que herramientas como TensorBoard, pesos y sesgos, y MLflow pueden ayudar a dar sentido a estos gráficos cuando se realizan numerosos experimentos.
  
  
• 24:45:00 En esta sección, el orador analiza la importancia de evaluar modelos en función de su rendimiento en el conjunto de datos de prueba en lugar de solo el conjunto de datos de entrenamiento. Sugieren que si bien las métricas en el conjunto de datos de entrenamiento son buenas, el objetivo final es que el modelo funcione bien en datos no vistos. El orador recomienda entrenar a los modelos por más tiempo y posiblemente agregar más unidades ocultas a cada capa para lograr mejores resultados. Luego pasan a demostrar cómo hacer predicciones en imágenes personalizadas que no están en el conjunto de datos de entrenamiento o prueba, usando una aplicación de reconocimiento de alimentos como ejemplo. Explican el flujo de trabajo para descargar una imagen personalizada y hacer una predicción usando un modelo PyTorch entrenado, pero advierten que el modelo actual puede no tener un gran rendimiento.
  
  
• 24:50:00 En esta sección, el instructor muestra cómo descargar una imagen personalizada de una pizza y prepararla para la predicción utilizando el modelo que ha entrenado. La imagen se descarga mediante una URL sin procesar de GitHub y se guarda en la carpeta de datos. El instructor señala que la imagen personalizada debe tener el mismo formato que los datos que se usaron para entrenar el modelo, específicamente la forma Tensor con el tipo de datos antorcha flotante 32 y una forma de 64 por 64 por tres. Demuestran cómo cargar la imagen en PyTorch usando el paquete de visión de antorcha y la función read_image, que lee un JPEG o PNG en un tensor de escala de grises o RGB tridimensional.
  
  
• 24:55:00 En esta sección, el instructor demuestra cómo leer una imagen personalizada en PyTorch usando torch vision.io y convertirla en un tensor. También muestra cómo obtener metadatos sobre la imagen, como su forma y tipo de datos. El instructor señala que antes de pasar la imagen a través de un modelo, es posible que deba cambiar su tamaño, convertirla a float32 y colocarla en el dispositivo correcto. En la siguiente sección, planea demostrar cómo hacer una predicción en la imagen personalizada usando un modelo PyTorch.

parte 26

• 25:00:00 En esta sección, el instructor analiza la importancia de los tipos de datos y las formas en el aprendizaje profundo y cómo corregir los errores relacionados con ellos. El instructor intenta hacer una predicción en una imagen, pero se encuentra con errores porque los datos personalizados no son del mismo tipo de datos con los que se entrenó originalmente el modelo. Muestran cómo solucionar el error al recrear el tensor de imagen personalizado y convertirlo en antorcha flotante 32. Luego, el instructor enfrenta otro problema con la forma de la imagen personalizada y muestra cómo solucionarlo creando una canalización de transformación para cambiar el tamaño de la imagen a del mismo tamaño en el que se entrenó el modelo.
  
  
• 25:05:00 En esta sección, el instructor muestra cómo usar el paquete de transformaciones de PyTorch para transformar una imagen de entrada y prepararla para que la use un modelo de aprendizaje profundo. Demuestran cómo aplicar una canalización de transformación a una imagen personalizada, lo que da como resultado que la imagen se comprima y pixele. El instructor señala que esto podría afectar potencialmente la precisión del modelo y recomienda experimentar con tamaños de imagen más grandes para mejorar el rendimiento. También analizan la importancia de garantizar que las dimensiones del tensor se alineen con los requisitos del modelo, incluida la adición de una dimensión por lotes a una imagen personalizada antes de pasarla por el modelo para la inferencia.
  
  
• 25:10:00 En esta sección del video, el presentador demuestra cómo hacer predicciones sobre datos de imágenes personalizados usando un modelo PyTorch. Resaltan la importancia de formatear los datos correctamente y asegurarse de que tengan el mismo tipo de datos, forma y dispositivo con los que se entrenó el modelo para evitar errores. El presentador también muestra cómo convertir los resultados sin procesar del modelo, o logits, en probabilidades de predicción mediante la función softmax. Aunque el modelo utilizado en el ejemplo no funciona bien, se ilustra el proceso de predicción de datos personalizados.
  
  
• 25:15:00 En esta sección del video, el instructor muestra cómo funciona el proceso de predicción de imágenes personalizado. Esta función toma un modelo de PyTorch, una ruta de imagen, una lista de nombres de clases, una transformación y un dispositivo como entradas. Carga la imagen con TorchVision, la formatea, obtiene las etiquetas de predicción y traza la imagen con su predicción como título. El instructor desafía a los espectadores a intentar construir esta función por su cuenta y luego analiza una posible implementación en el video. La función no está completamente implementada en esta sección y continuará en el próximo video.
  
  
• 25:20:00 En esta sección, vemos cómo hacer una predicción sobre datos personalizados usando PyTorch. Primero, necesitamos escalar los datos de la imagen para que estén entre 0 y 1 para que nuestro modelo pueda procesarlos correctamente. Luego, verificamos si es necesaria alguna transformación y pasamos la imagen a través de ella si lo es. A continuación, nos aseguramos de que el modelo esté en el dispositivo correcto y lo ponemos en modo de inferencia. También agregamos una dimensión adicional a la imagen para reflejar el tamaño de lote de 1 que nuestro modelo predecirá. Luego hacemos una predicción, convertimos los logit sin procesar en probabilidades de predicción usando softmax y luego los convertimos en etiquetas de predicción usando argmax. Finalmente, creamos un gráfico de la imagen junto con su predicción y probabilidad de predicción. Si se proporciona una lista de nombres de clase, la función replicará los nombres de clase para cada predicción en el gráfico.
  
  
• 25:25:00 En esta sección, el instructor explica cómo crear una función que pueda tomar imágenes y mostrar su clase predicha usando un modelo PyTorch entrenado previamente. La función puede tomar una lista de nombres de clase para etiquetar y también muestra la probabilidad de predicción. Luego, el instructor demuestra el uso de esta función en imágenes personalizadas y un modelo previamente entrenado, explicando la importancia de poner el resultado en la CPU para compatibilidad con matplotlib. A pesar del pobre desempeño del modelo, el instructor enfatiza el poder de visualizar los resultados.
  
  
• 25:30:00 En esta sección, el instructor resume las conclusiones principales de la sección anterior, que cubría cómo predecir datos personalizados con PyTorch. Los puntos principales a recordar son que los datos deben procesarse previamente para que coincidan con el formato esperado del modelo, incluido el tipo de datos correcto, el dispositivo correcto y la forma correcta. PyTorch tiene muchas funciones integradas para manejar diferentes tipos de datos, y los usuarios pueden escribir sus propias clases de conjuntos de datos personalizados si es necesario. Además, el instructor destaca la importancia de equilibrar el sobreajuste y el desajuste al entrenar modelos y menciona varios recursos para seguir aprendiendo y practicando, incluidos ejercicios y materiales extracurriculares.
  
  
• 25:35:00 En esta sección, el instructor alienta a los alumnos a pasar primero por la plantilla de ejercicios de conjuntos de datos personalizados de PyTorch e intentar completar todo el código por su cuenta. En caso de que se atasquen, pueden consultar las soluciones de ejemplo proporcionadas por el instructor. Las soluciones que se ofrecen son solo una forma de hacer las cosas, y los usuarios son libres de consultarlas y compararlas con su implementación. Las soluciones y los errores encontrados durante el proceso también se pueden ver en los tutoriales en vivo disponibles en YouTube. El instructor recuerda a los usuarios que han cubierto una gran cantidad de ejercicios y que pueden consultar los ejercicios y soluciones adicionales en el repositorio de aprendizaje profundo de PyTorch. El instructor concluye mencionando que hay cinco capítulos más disponibles en learnpytorch.io, que los alumnos pueden explorar para obtener más información sobre el aprendizaje por transferencia, el seguimiento de experimentos del modelo pytorch, la replicación en papel pytorch y la implementación del modelo pytorch.

[MetaQuotes]

Curso de aprendizaje automático sin caja negra: aprenda sin bibliotecas

Curso de aprendizaje automático sin caja negra: aprenda sin bibliotecas

00:00:00 - 01:00:00 En este video de YouTube, el instructor presenta un curso de aprendizaje automático sin caja negra que enseña cómo codificar en aprendizaje automático sin depender de bibliotecas. El curso cubre temas relacionados con la creación de una aplicación web que reconoce dibujos, incluida la recopilación de datos, la extracción y visualización de características, y la implementación de clasificadores como el vecino más cercano y el vecino más cercano K. El instructor enfatiza la importancia de comprender los datos en el aprendizaje automático y sugiere recursos para aquellos que necesitan repasar la experiencia en matemáticas y programación de la escuela secundaria. El video demuestra el proceso de creación de una página web que actúa como creador de datos utilizando JavaScript sin bibliotecas externas. El presentador también incluye instrucciones sobre cómo crear un botón de deshacer y un campo de entrada de nombre, almacenar dibujos en un objeto de datos y guardar las rutas en la computadora del usuario. Finalmente, el video muestra cómo crear un generador de conjuntos de datos en node.js y generar datos asociados con cada muestra usando JavaScript.

01:00:00 - 02:00:00 En este video de YouTube, el instructor les enseña a los espectadores cómo crear un conjunto de datos de aprendizaje automático y extraer funciones sin usar bibliotecas. Demuestran cómo almacenar el conjunto de datos en una carpeta que puede comunicarse entre scripts de nodos y aplicaciones web y crear una aplicación de visor de datos. El instructor también muestra cómo visualizar los datos recopilados mediante gráficos de Google y cómo identificar y enfatizar elementos seleccionados en el gráfico y la lista. En general, el video proporciona una guía completa para que los estudiantes creen conjuntos de datos de aprendizaje automático y extraigan funciones usando solo JavaScript. 02:00:00 - 03:00:00 El video "Curso de aprendizaje automático sin caja negra: aprender sin bibliotecas" demuestra cómo clasificar dibujos en función de sus características sin usar bibliotecas de aprendizaje automático. El creador del video enfatiza la importancia de tener un sistema rápido y receptivo para inspeccionar datos para evitar errores manuales. Demuestran cómo agregar funciones al gráfico, cómo ocultar el fondo y cómo mostrar las etiquetas predichas en la pantalla usando contenedores dinámicos con HTML y CSS. El video también cubre técnicas de escalado de datos como la normalización y la estandarización. Finalmente, el video muestra cómo implementar el clasificador de K vecinos más cercanos y contar el número de cada etiqueta dentro de los K vecinos más cercanos.

03:00:00 - 03:50:00 El video de YouTube "Curso de aprendizaje automático sin caja negra - Aprende sin bibliotecas" cubre varios temas relacionados con la clasificación del vecino más cercano sin usar bibliotecas de aprendizaje automático como JavaScript y Python. El video explica cómo dividir conjuntos de datos en conjuntos de entrenamiento y prueba, manejar muestras de entrenamiento y prueba por separado y normalizar los datos. El instructor también analiza la importancia de los límites de decisión para comprender cómo funciona un clasificador, demuestra cómo implementar un clasificador K-vecino más cercano (KNN) en JavaScript y generar un gráfico basado en píxeles sin usar bibliotecas de aprendizaje automático. Finalmente, el video termina con una llamada para que los espectadores exploren capacidades adicionales de Python y reflexionen sobre lo que han aprendido hasta ahora.

Parte 1

• 00:00:00 En esta sección, el orador presenta el curso de aprendizaje automático sin caja negra que se enfoca en la codificación sin depender de bibliotecas. El curso cubre varios temas para crear una aplicación web que reconozca dibujos, incluida la recopilación de datos, la extracción y visualización de características, y la implementación de clasificadores como el vecino más cercano y el vecino más cercano K. El orador enfatiza la importancia de comprender los datos en el aprendizaje automático y brinda un breve descanso para que los estudiantes se concentren en la tarea, al mismo tiempo que sugiere recursos para repasar la experiencia en matemáticas y programación de la escuela secundaria. Luego, el curso pasa a la fase dos, donde se cubrirán métodos más avanzados, como las redes neuronales. También se muestra un ejemplo de creación de una aplicación de dibujo para la recopilación de datos con funciones de deshacer y guardar.
  
  
• 00:05:00 En esta sección del video, el instructor recorre el proceso de creación de una página web que se usará como creador de datos para un conjunto de datos. Comienzan creando una nueva carpeta llamada web y dentro de esta carpeta, crean el primer archivo, una página web llamada Creator.html. La página incluye HTML básico, una sección de título y una hoja de estilo externa llamada Styles.css. También agregan estilos básicos para la página, incluida la familia de fuentes y el color de fondo. Luego, el instructor pasa a implementar el bloc de dibujo usando un archivo JavaScript externo llamado sketchpad.js y define el constructor de la clase del bloc de dibujo para contener el elemento del lienzo.
  
  
• 00:10:00 En esta sección, el instructor configura un lienzo usando JavaScript y agrega un detector de eventos "onmousedown" para detectar acciones del mouse. Obtienen las coordenadas del mouse obteniendo el rectángulo del área delimitada del lienzo y restando los lados izquierdo y superior respectivamente. Después de redondear las coordenadas a números enteros, el instructor crea una matriz de ruta que contiene las coordenadas del mouse cuando se hace clic en el lienzo. También establecieron "dibujo" en falso y "camino" en vacío. Se agrega otro detector de eventos para "onmousemove" para continuar agregando más puntos a la matriz de ruta a medida que se mueve el mouse.
  
  
• 00:15:00 En esta sección, el orador explica cómo implementar eventos de mouse para dibujar en un lienzo usando JavaScript, sin el uso de bibliotecas. Mediante el uso de detectores de eventos para "onMouseMove" y "onMouseUp", el código rastrea los movimientos del mouse y agrega la ubicación a una ruta si el usuario está dibujando. Además, se crea una nueva función "obtener mouse" para agregar la ubicación al lienzo. Finalmente, el orador demuestra cómo crear un objeto de utilidad de "dibujar" para borrar y dibujar la ruta en el lienzo.
  
  
• 00:20:00 En esta sección, el video instructor continúa creando un programa de dibujo sin bibliotecas externas al abordar algunos problemas con las líneas dibujadas, como la apariencia de las esquinas y los extremos de las líneas rectas. Luego proceden a crear una función para dibujar varias rutas y la incorporan al programa. El instructor encuentra algunos problemas al ejecutar el programa en un dispositivo móvil debido a la ventana gráfica y lo soluciona usando una metaetiqueta en la sección principal del archivo HTML.
  
  
• 00:25:00 En esta sección, el tutorial se enfoca en hacer que el lienzo se ajuste a pantallas más pequeñas como las de los dispositivos móviles agregando comandos específicos a la etiqueta meta de la ventana gráfica en el código HTML. Sin embargo, los detectores de eventos para el tacto son diferentes de los del mouse, lo que requiere una modificación del bloc de dibujo con detectores de eventos para el tacto. Para mejorar aún más el lienzo, se crea un botón de deshacer, pero solo cuando hay rutas para deshacer. El botón está deshabilitado cuando el lienzo está vacío.
  
  
• 00:30:00 En esta sección, el video explica cómo mejorar la apariencia del botón cambiando el estilo en el archivo CSS. El narrador agrega un efecto de desplazamiento y establece los estilos para el estado deshabilitado. A continuación, aprenderemos a crear un campo de entrada para que los usuarios ingresen su nombre y un botón para avanzar al siguiente dibujo. El video también explica cómo recopilar datos de estos campos y almacenarlos en un objeto con tres campos: estudiante, sesión y dibujos. Finalmente, el narrador comienza a implementar la función de inicio que se utilizará para iniciar el proceso de dibujo.
  
  
• 00:35:00 En esta sección del video, el presentador muestra cómo implementar una aplicación de dibujo usando JavaScript sin usar bibliotecas. Comienzan definiendo un índice para las etiquetas de las cosas que quieren dibujar, como un auto, un pez, una casa, etc. También agregan un campo para las instrucciones y modifican el botón de inicio para cambiar a "siguiente" después del primer dibujo. . Luego implementan una función para el botón "siguiente", que aumenta el índice, obtiene la siguiente etiqueta y actualiza las instrucciones. También almacenan los dibujos en un objeto de datos para la etiqueta específica y agregan un método público para restablecer el bloc de dibujo. El presentador prueba la aplicación y muestra que el objeto de datos recopila los dibujos.
  
  
• 00:40:00 En esta sección, el instructor explica cómo guardar las rutas dibujadas por los usuarios localmente en su computadora. Crean un elemento "a" con el atributo href establecido en "texto sin formato de datos" y codifican el componente URI utilizando la versión en cadena de los datos. Los datos recopilados se guardan como una cadena JSON en un archivo con un nombre único generado a partir de una marca de tiempo. Finalmente, se activa la acción de descarga para descargar el archivo. El instructor también agrega instrucciones sobre qué hacer con el archivo descargado y afirma que esto tendrá más sentido después de la próxima lección.
  
  
• 00:45:00 En esta sección, el instructor muestra cómo solucionar un problema potencial con el bloc de dibujo agregando un detector de eventos en el documento en lugar del lienzo. También les pide a los espectadores que ayuden a probar el sistema en diferentes dispositivos e informen cualquier problema o propongan soluciones. Luego, el instructor explica cómo procesar los datos recopilados en una forma más manejable usando node.js y muestra cómo navegar al directorio del proyecto y crear una nueva carpeta para almacenar los datos. Finalmente, crea una carpeta "sin procesar" donde pega todos los datos recopilados de casi 500 presentaciones de estudiantes, cada uno con ocho dibujos diferentes, y explica cómo procesará estos archivos para crear un conjunto de datos donde cada muestra es un dibujo.
  
  
• 00:50:00 +Alt+M y el archivo Json tendrá un buen formato. En esta sección, el instructor explica cómo crearán un generador de conjuntos de datos en nodejs para procesar las muestras y visualizarlas usando dos carpetas separadas: una para representaciones Json y otra para imágenes. El script leerá los nombres de los archivos del directorio de datos sin procesar, extraerá contenido de ellos y almacenará información sobre cada muestra, como su identificación, etiqueta, nombre del estudiante e identificación del estudiante, sesión y dibujo. Finalmente, la sección muestra brevemente cómo ejecutar y probar el código, lo que resulta en la creación de un archivo Json de muestra en el directorio designado.
  
  
• 00:55:00 En esta sección, el ponente explica cómo generar datos asociados con cada muestra usando JavaScript. Esto implica escribir archivos en un directorio Json y clasificar el dibujo de cada etiqueta específica. Luego, el orador demuestra cómo generar una representación de imagen de cada dibujo utilizando un lienzo y la función 'dibujar rutas' desde un directorio común. Para hacer esto, el orador exporta el objeto 'dibujar' del archivo 'draw.js' para usarlo en el generador de conjuntos de datos e instala la biblioteca de lienzo usando el administrador de paquetes de nodos.

Parte 2

• 01:00:00 En esta sección, el instructor muestra cómo crear un lienzo y usarlo para dibujar rutas en el lienzo, luego almacenarlo como una imagen. También limpian el lienzo antes de dibujar nuevos caminos. Después de generar los archivos de imagen, el instructor corrige un problema en la aplicación de dibujo causado por el módulo que no está definido en Draw JS. Utilizan una estructura que se usará a lo largo del curso, separando constantes en otro archivo y exigiéndolo. El instructor agrega un indicador de progreso en un nuevo archivo llamado utils creando el objeto utils y agregando la función llamada progreso de impresión. Usan el proceso STD out para obtener la salida estándar, calculan el porcentaje usando la función para formatear un porcentaje y lo escriben en la salida estándar para mostrar el indicador de progreso.
  
  
• 01:05:00 En esta sección, el creador del video explica cómo almacenar el conjunto de datos generado de manera que el navegador pueda leerlo. Crea una carpeta llamada "JS_objects" que contendrá archivos que pueden comunicarse entre los scripts del nodo y las aplicaciones web. Se crea un archivo JavaScript de "muestras" que inicializará un objeto JavaScript dentro de la carpeta JS_objects. El creador del video también menciona que creará una aplicación de visor para el conjunto de datos y crea un archivo HTML llamado "viewer.html" con código HTML básico. La sección de encabezado del archivo incluye una metaetiqueta para admitir caracteres UTF y un título para la página. La sección del cuerpo incluye una etiqueta H1 con el título "Visor de datos" y un div con una ID de "contenedor" para contener el conjunto de datos. El archivo JavaScript de "muestras" se incluye en el archivo HTML.
  
  
• 01:10:00 En esta sección, el instructor está trabajando en la creación de una tabla con muestras agrupadas por ID de estudiante. Para hacer esto, implementan una función de "agrupar por" en el archivo utils.js, que agrupa una matriz por una clave dada. Luego registran los grupos en la consola para comprobar si funciona. Luego, crean una función llamada "crear fila" en un archivo display.js separado, que toma un contenedor, el nombre de un estudiante y muestras como parámetros y crea una fila con el nombre a la izquierda y las muestras a la derecha. Crean un ciclo para iterar a través de cada ID de estudiante, llaman a la función "crear fila" y pasan los parámetros necesarios para mostrar los datos en un formato de tabla.
  
  
• 01:15:00 En esta sección, el instructor muestra cómo crear dinámicamente una fila de imágenes con etiquetas y alinearlas correctamente con CSS. Comienzan recorriendo un conjunto de muestras de imágenes, creando un elemento de imagen y asignando los atributos de fuente y estilo. Luego, las imágenes se agregan a una fila mientras se crea una etiqueta div y se agrega a un contenedor de muestra. Luego, el contenedor de muestra se envuelve con un div, al que se le asigna una ID y una clase. Luego, el instructor refina el CSS para centrar las etiquetas y las imágenes y agregar puntos suspensivos a los nombres más largos. Finalmente, agregan un fondo blanco a los dibujos de muestra al crear un div y agregarlo después de la etiqueta.
  
  
• 01:20:00 En esta sección, el creador del video modifica la visualización de las muestras de imágenes recopiladas en la aplicación web. La modificación implica la creación de un contenedor de muestra con un fondo blanco, un texto alineado al centro, una esquina redondeada y un margen de un píxel. La miniatura se establece en 100 y la etiqueta de la fila tiene una propiedad que ocupa el 20 por ciento del espacio, y las ocho muestras restantes ocupan el diez por ciento del espacio cada una. La estructura de visualización resultante es ordenada, pero algunas imágenes no encajan perfectamente, lo cual no es gran cosa porque está destinado a aplicaciones de escritorio. Además, el creador agrega un filtro de desenfoque a algunos dibujos realizados por usuarios marcados usando sus ID. Algunos de los dibujos recopilados son impresionantes, mientras que otros contienen interpretaciones erróneas que hacen que los datos sean más desafiantes.
  
  
• 01:25:00 En esta sección, el YouTuber echa un vistazo a algunos dibujos en el conjunto de datos y comenta sobre su calidad, señalando que algunos son muy detallados y deben haber tomado mucho tiempo para crear. También mencionan que su conjunto de datos es diferente del conjunto de datos Quick Draw, ya que tienen un botón de deshacer y no tienen límite de tiempo, lo que significa que sus dibujos deberían ser de mejor calidad en promedio. Finalmente, hacen un comentario improvisado sobre la organización y el estilo de la página.
  
  
• 01:30:00 En esta sección, el instructor explica cómo extraer características de muestras sin usar bibliotecas. Las funciones para extraer el recuento de rutas y el recuento de puntos se implementan en un archivo denominado Features.js y se agregan a un objeto llamado Features. Luego, en el archivo feature extractor.js, las muestras se leen y las características se extraen recorriendo todas las muestras y obteniendo el recuento de rutas y el recuento de puntos para cada uno de ellos. Estos valores de características luego se combinan en una matriz y se escriben en un nuevo archivo. Por último, los nombres de las funciones y las muestras se combinan en otro archivo llamado functions.json. Al ejecutar la secuencia de comandos del extractor de características, el registro dice "extrayendo características" y al final, "hecho". A continuación, se pueden examinar las características resultantes en el directorio del conjunto de datos.
  
  
• 01:35:00 En esta sección, el creador del video explica cómo usar un objeto JavaScript para contener datos adicionales que aún no están contenidos en un archivo de funciones. El objeto se puede guardar en un archivo JavaScript separado y usarse para extraer todos los datos necesarios para una aplicación web. El creador también demuestra cómo visualizar los datos usando gráficos de Google, donde se pueden definir opciones como ancho, alto, títulos de eje y el paquete de gráficos principal en un objeto. Se crea una tabla de datos con dos columnas para valores de características y sus nombres correspondientes.
  
  
• 01:40:00 En esta sección, el video demuestra cómo crear un gráfico de dispersión con Google Visualization, lo que permite a los usuarios investigar diferentes características de los datos más de cerca mediante el uso de acciones del Explorador para acercar y alejar. El video también muestra cómo usar diferentes colores para cada clase e implementar transparencia para una mejor visualización de la densidad en diferentes partes usando una versión diferente de la biblioteca de gráficos de Google llamada gráficos de materiales.
  
  
• 01:45:00 En esta sección, el creador del video muestra cómo crear un gráfico de dispersión usando los gráficos de Google y luego crear un nuevo gráfico con su propio código JavaScript. El creador simplifica las opciones del gráfico y cambia el esquema de colores para usar emojis en su lugar, lo que permite un reconocimiento más fácil de los puntos de datos sin necesidad de etiquetas o leyendas. La transparencia del gráfico también se ajusta para permitir una mejor visibilidad de los datos densamente trazados.
  
  
• 01:50:00 En esta sección, el instructor agrega una función de devolución de llamada al gráfico para identificar cualquier elemento seleccionado en la tabla a continuación. La nueva función se llama "manejar clic", que agrega una clase de "enfatizar" al elemento seleccionado y usa "desplazarse a la vista" y "bloquear el centro" para garantizar que se desplace automáticamente al centro de la página. Luego, el instructor modifica el diseño de la página para que el gráfico esté en el lado derecho de la página, con el resto del contenido en el lado izquierdo. El gráfico también tiene una posición fija para que no se mueva cuando el usuario se desplaza.
  
  
• 01:55:00 En esta sección del video, el presentador muestra cómo seleccionar elementos del gráfico y la lista, y también deseleccionarlos. Especifican un parámetro para establecer si debe ocurrir el desplazamiento y agregan código para manejar el error que ocurre al intentar no seleccionar nada. Además, el presentador agrega la capacidad de enfatizar un elemento a través de una clase, eliminando la clase si ya está enfatizada. Finalmente, prueban la funcionalidad del gráfico y ajustan el tamaño del gráfico.

parte 3

• 02:00:00 En esta sección, el orador demuestra el uso de un bloc de dibujo como entrada para dibujar algo para clasificar. Preparan un contenedor para él, le agregan estilos y fijan su posición a cierta distancia de la derecha y la parte superior de la pantalla. También le dan un margen para una visibilidad clara y un botón de deshacer en el centro. Luego agregan un panel de control y un botón para alternar la entrada visible o no que funciona correctamente en la prueba. El orador enfatiza la importancia de tener un sistema rápido y receptivo al inspeccionar datos para evitar errores manuales que puedan conducir a errores.
  
  
• 02:05:00 En esta sección, el instructor en video muestra cómo agregar un panel de control al gráfico y cómo ocultar el fondo cuando la entrada está presente. Demuestran una solución para ocultar el fondo en el HTML del visor haciendo que el contorno del lienzo del bloc de dibujo sea transparente. También muestran cómo mostrar las características en el gráfico inmediatamente cuando se dibuja algo en el bloc de dibujo agregando una función de devolución de llamada de actualización que extrae las características de la misma manera que el extractor de características. El instructor encuentra un problema con los objetos en conflicto llamados funciones, pero lo resuelve cambiándoles el nombre a funciones de funciones en todas partes.
  
  
• 02:10:00 En esta sección, el orador demuestra un punto dinámico que se puede agregar al gráfico, que se mueve a medida que se dibuja. Esto se logra estableciendo un atributo a un valor y volviendo a dibujarlo. El punto dinámico se agrega a la clase de gráfico y se dibuja antes de que se muestren los ejes. Al arrastrar, el punto se mueve a diferentes áreas, y cuando se dibuja con un punto blanco transparente sobre un fondo negro, es mucho más visible. El valor debe ser grande, ya que se puede ampliar el gráfico y el punto permanece visible sin sobrepasar los bordes.
  
  
• 02:15:00 En esta sección, el instructor demuestra cómo activar un método de actualización en sketchpad.js, que funciona ocultando la entrada dinámica y mostrando los datos cuando se presiona la entrada alterna. Con el método de activación de actualización, el instructor aplica las funciones de obtención de características de ancho y alto en Funciones de características comunes para calcular el ancho y la altura del dibujo, que se utilizan para extraer nuevas características en el extractor de características del nodo. El instructor sugiere que necesitan reestructurar el HTML para que se use el mismo recurso para extraer y mostrar datos.
  
  
• 02:20:00 En esta sección, el creador del video demuestra cómo eliminar código innecesario y reemplazarlo con funciones nuevas, lo que da como resultado un proceso de creación de puntos más generalizado y multidimensional. Después de regenerar las funciones y actualizar los nombres de las funciones, se observan algunos puntos de muestra problemáticos, lo cual es un problema común cuando se trabaja con datos. El creador señala que se esperan valores atípicos e inconsistencias en los datos e invita a los espectadores a ayudar a identificar la causa del problema.
  
  
• 02:25:00 En esta sección, el instructor explica cómo clasificar un dibujo según sus características sin usar bibliotecas de aprendizaje automático. Extraen características de la entrada y observan los puntos cercanos para clasificar la entrada. Para encontrar el punto más cercano, el instructor copia la función de obtención más cercana del gráfico de math.js y la pega en su código. Luego llaman a la función para identificar la etiqueta del dibujo y registrar el resultado.
  
  
• 02:30:00 En esta sección, el creador del video agrega la funcionalidad para mostrar la etiqueta predicha en la pantalla usando contenedores dinámicos con HTML y CSS. La etiqueta predicha se muestra en un contenedor blanco con un texto concatenado que muestra si el objeto es un automóvil o no. El creador experimenta dibujando diferentes objetos como relojes y lápices para probar las capacidades predictivas del programa. Luego, el creador del video actualiza el gráfico utilizando puntos dinámicos con etiquetas e imágenes y dibuja líneas que conectan las muestras más cercanas.
  
  
• 02:35:00 En esta sección, el orador analiza la importancia de no aplastar ni estirar los datos en los gráficos cuando se trabaja en proyectos de aprendizaje automático. Demuestran cómo la relación de aspecto de un gráfico puede afectar la forma en que se interpretan los datos, lo que genera confusión y errores. Para resolver este problema, el orador calcula un delta para los valores máximos de x e y y ajusta el gráfico en consecuencia. Aunque esto crea un espacio vacío, permite una visualización adecuada de los datos y resultados de aprendizaje automático precisos.
  
  
• 02:40:00 En esta sección de la transcripción, el creador del video enfatiza la importancia del escalado de datos en el aprendizaje automático para garantizar que todas las características tengan el mismo significado en la clasificación. El creador demuestra cómo los datos se pueden aplastar y estirar durante la extracción de características, lo que da como resultado un tratamiento desigual de ciertas características. Para nivelar el campo de juego, el creador presenta la normalización, una técnica común para reasignar valores de características a un rango entre 0 y 1. El video explica la implementación de una nueva función llamada "normalizar puntos" en la sección "utilidades" para lograr esto. reasignación
  
  
• 02:45:00 En esta sección, el video tutorial muestra cómo normalizar los datos cambiando los valores para que estén entre 0 y 1. La función se inicializa para que sea lo suficientemente general y se calculan los valores mínimo y máximo para cada función. Los puntos se modifican para que estén entre 0 y 1 restando el valor mínimo y dividiendo por la diferencia. La función lerp inversa se utiliza para convertir el valor dado en un porcentaje para normalizar las características extraídas del dibujo. Los valores min-max se devuelven desde la función y se escriben en uno de los archivos de objetos de JavaScript para comunicarse con la interfaz. Finalmente, se generan los datos y los valores min-max se incluyen en los archivos de objetos de JavaScript.
  
  
• 02:50:00 En esta sección, el presentador explica cómo normalizar puntos antes de intentar clasificarlos usando la función de normalización de puntos de Utils. Para hacer esto, los datos de características sin procesar se cargan y pasan como entrada a la función. Además, se puede pasar un valor mínimo-máximo para admitir la normalización sin tener que calcularlos. También se demuestra cómo la normalización es sensible a los puntos atípicos y cómo lidiar con ellos, por ejemplo, detectándolos y eliminándolos automáticamente o usando la estandarización como una escala de datos diferente.
  
  
• 02:55:00 En esta sección, el instructor analiza la técnica de estandarización, que consiste en calcular la media y la desviación estándar de cada función y reasignarla restando la media y dividiendo por la desviación estándar. Esta técnica es menos sensible a los valores atípicos y puede funcionar mejor en ciertos casos. El instructor también presenta el clasificador de K vecinos más cercanos, donde la clase se determina en función de la mayoría de los K vecinos más cercanos. El código se actualiza para permitir la búsqueda de K vecinos más cercanos y el instructor demuestra cómo contar el número de cada etiqueta dentro de los K vecinos más cercanos.

parte 4

• 03:00:00 En esta sección, el instructor explica el proceso de averiguar la mayoría de un conjunto de muestras en función de sus etiquetas. Esto implica contar las ocurrencias de cada etiqueta en las muestras y establecer la etiqueta mayoritaria como la que tiene el recuento más alto. El instructor actualiza el código para devolver todas las muestras más cercanas y trazar líneas hacia ellas en el gráfico, en lugar de solo la más cercana. Luego demuestran el funcionamiento del clasificador en varios conjuntos de datos y alientan a los espectadores a compartir sus propias implementaciones de otras variantes de los clasificadores vecinos más cercanos. Por último, el instructor enfatiza la necesidad de dividir los datos en conjuntos de entrenamiento y prueba para evaluar objetivamente el desempeño del clasificador.
  
  
• 03:05:00 En esta sección, el video demuestra cómo dividir un conjunto de datos en conjuntos de entrenamiento y prueba, escribirlos en archivos y definir constantes para esas divisiones en el código usando JavaScript. El conjunto de entrenamiento está configurado para ser el 50% del número de muestras, y el video advierte sobre el error de probar los datos de entrenamiento. Para probar, el código recorre todas las muestras de prueba y almacena el valor de la etiqueta en un atributo llamado Verdad mientras finge no conocer la etiqueta con fines de prueba.
  
  
• 03:10:00 En esta sección, el video explica cómo manejar las muestras de entrenamiento y prueba por separado y cómo normalizar correctamente los datos. El orador explica que es importante normalizar los datos solo con el conjunto de entrenamiento, ya que no tenemos idea de cuál será el conjunto de prueba. También explican cómo clasificar correctamente usando solo información de los datos de entrenamiento y demuestran cómo manejar puntos de datos desconocidos usando la función de clasificación.
  
  
• 03:15:00 En esta sección, el creador del video agrega un atributo correcto a una etiqueta de prueba y compara esta etiqueta con el valor real anterior para determinar la precisión. También se agrega un subtítulo para aclarar dónde comienza el conjunto de prueba. Luego, el creador agrega un campo de estadísticas para calcular y mostrar la precisión del clasificador de vecinos más cercanos K, que se establece en 10 vecinos más cercanos, lo que da como resultado una precisión del 39,62 %. Al cambiar el parámetro a un vecino más cercano, la precisión es mucho peor, lo que demuestra que considerar varios vecinos fue una buena idea.
  
  
• 03:20:00 En esta sección, el instructor refactoriza el código y analiza la importancia de los límites de decisión para comprender cómo funciona un clasificador. Crean un nuevo archivo llamado "ejecutar evaluación" y cargan las constantes y utilidades necesarias. El instructor explica cómo crear un clasificador y cómo obtener muestras de prueba y entrenamiento para calcular la precisión de un clasificador. También introducen límites de decisión, que brindan información valiosa sobre cómo un clasificador determina la clasificación de un punto de datos. El instructor afirma que los límites de decisión son más útiles que simplemente contar las diferentes características de un punto de datos.
  
  
• 03:25:00 En esta sección, el orador explica cómo implementar un clasificador K-vecino más cercano (KNN) en JavaScript. El código comienza con la predicción de etiquetas para cada punto de muestra de prueba utilizando el método KNN y calculando la precisión al verificar el recuento de predicciones correctas. El archivo KN.js se crea para definir la clase que toma muestras de entrenamiento y K para almacenar y predecir un punto determinado. El código de clase para la clasificación se copia del visor HTML a KN.js y se modifica para adaptarse a la nueva clase. El script de evaluación de ejecución se actualiza para usar el clasificador KNN en lugar del antiguo método de clasificación. Al refactorizar de esta manera, el código se vuelve más manejable y se pueden evitar errores tontos.
  
  
• 03:30:00 En esta sección, el instructor demuestra cómo generar un gráfico basado en píxeles sin usar bibliotecas de aprendizaje automático al normalizar los valores de píxeles y codificarlos por colores en función de los valores predichos. Luego, el gráfico se guarda como una imagen PNG y se establece como fondo de un gráfico. El instructor muestra cómo implementar esta nueva función en el archivo chart.js tomando la coordenada superior izquierda de acuerdo con los datos, obteniendo el valor de píxel de los límites de datos a los límites de píxel y dividiéndolo según cómo se hizo la escala usando la transformación.
  
  
• 03:35:00 En esta sección del video, el presentador comenta la imagen generada en la sección anterior y comenta sobre su baja resolución y efecto de suavizado. Luego introducen una imagen de mayor resolución, que ya no requiere la visualización de datos. Explican que las regiones coloreadas nos hablan de las diferentes etiquetas y lo interesante que es observar cómo aparecen las diferentes regiones. Luego desafían a los espectadores a calcular la precisión de todos los valores posibles de K y crear un gráfico de líneas para determinar el mejor valor y también para generar un gráfico de límite de decisión de alta resolución para el mejor valor.
  
  
• 03:40:00 En esta sección, el YouTuber explica cómo preparar datos para Python escribiendo una función para convertir datos de muestra en formato CSV usando JavaScript. Crean una función llamada toCSV que convierte datos de muestra con encabezados y nombres de características en formato CSV, que se usa comúnmente en Python. Generan el CSV con nombres y etiquetas de funciones para los datos de entrenamiento y prueba, y luego pasan a la implementación de Python del vecino más cercano de K usando bibliotecas. Abren el archivo CSV de entrenamiento, leen las líneas y analizan los datos como una matriz de filas representada como una cadena, con el carácter de nueva línea.
  
  
• 03:45:00 En esta sección, el instructor explica cómo preparar los datos para la clasificación de K vecinos más cercanos sin el uso de bibliotecas. Los datos se leen de un archivo CSV y se almacenan en dos matrices vacías en Python: X para valores de características e Y para etiquetas. El instructor recorre un ciclo para llenar las matrices, convertir los valores de las características en flotantes y reasignar las etiquetas en números. La reasignación se logra utilizando un diccionario de Python. Luego, los datos se ajustan a un objeto clasificador KNN con parámetros establecidos para emular la aplicación web, incluidos 250 vecinos, algoritmo de fuerza bruta y pesos uniformes. El instructor termina destacando la importancia de la sangría en Python y extrayendo los datos de características de lectura de un archivo como una función.
  
  
• 03:50:00 En esta sección, el orador demuestra cómo pasar datos al modelo y comprobar su precisión mediante la función de puntuación. También alientan a los espectadores a explorar capacidades adicionales de Python, como instalar matplotlib para visualizar valores de características y límites de decisión. El video concluye con un llamado para que los espectadores reflexionen sobre lo que han aprendido hasta ahora y se preparen para la siguiente fase del curso.

[MetaQuotes]

MIT 6.034 "Inteligencia Artificial". Otoño de 2010. Lección 1. Introducción y alcance

1. Introducción y Alcance

Este video es una introducción al curso MIT 6.034 "Inteligencia artificial". El profesor explica la definición de inteligencia artificial y su importancia, y continúa discutiendo los modelos de pensamiento y representaciones que son importantes para comprender el tema. Finalmente, el video proporciona una breve descripción general del curso, que incluye cómo se calcula la calificación y qué implicarán el cuestionario y la prueba final.

• 00:00:00 En este video, un profesor analiza la definición de inteligencia artificial y su importancia. Continúa diciendo que cualquiera que tome el curso se volverá más inteligente. El profesor también discute modelos de pensamiento y cómo son importantes para tener una buena comprensión del tema. Finalmente, habla de la importancia de las representaciones para hacer buenos modelos.
  
  
• 00:05:00 En este video, el profesor explica cómo funcionan los giroscopios y cómo representar un problema en términos de un gráfico. Luego continúa explicando cómo resolver el problema del granjero Fox, el ganso y el grano, que es un ejemplo con el que muchas personas pueden estar familiarizadas desde la infancia.
  
  
• 00:10:00 El video presenta el concepto de inteligencia artificial y sus diversos componentes, incluidas las pruebas generadas por inteligencia artificial. Luego, el video continúa discutiendo el principio de Rumpelstiltskin, que establece que una vez que puedes nombrar algo, puedes tener poder sobre él.
  
  
• 00:15:00 Este video presenta el concepto de ideas simples, que son poderosas y pueden ser simples o complejas. Luego, el video continúa discutiendo la definición y ejemplos de ideas simples. El punto principal del video es que las ideas simples son importantes para construir programas más inteligentes y que los científicos e ingenieros tienen diferentes motivaciones para estudiarlas.
  
  
• 00:20:00 Este video analiza la historia de la inteligencia artificial, comenzando con el trabajo realizado por Ada Lovelace hace más de un siglo. La era moderna de la IA se inició con el artículo escrito por Marvin Minsky en 1960. En un día, la discusión sobre la inteligencia artificial se incluirá en el curso.
  
  
• 00:25:00 La "era de la excavadora" se refiere a la edad en la que la gente empezó a ver que tenía acceso a una potencia informática ilimitada y empezó a desarrollar sistemas expertos basados en reglas.
  
  
• 00:30:00 El video analiza la historia de la evolución humana y la idea de la escuela secundaria, que es que los humanos evolucionaron a través de una mejora gradual y continua. Continúa discutiendo cómo los cambios accidentales que condujeron a la evolución humana fueron productos evolutivos accidentales, y especula sobre cuáles podrían ser estos cambios.
  
  
• 00:35:00 Este video proporciona una breve introducción a las ideas de Noam Chomsky sobre el desarrollo de la inteligencia humana. Los puntos principales que se destacan son que el lenguaje está en el centro de la inteligencia humana y que el objetivo principal del curso es ayudar a los estudiantes a desarrollar habilidades en el área. El video también menciona la importancia de las recitaciones y tutoriales, que son aspectos clave del curso.
  
  
• 00:40:00 Este video brinda una breve descripción general del curso del MIT, incluida su correlación entre la asistencia a clases y las calificaciones. Luego, el video proporciona un resumen de cómo el curso calcula la calificación de un estudiante, lo que incluye tener en cuenta el desempeño del estudiante en las pruebas y la final. Finalmente, el video advierte a los estudiantes que no intenten realizar todos los exámenes finales, ya que habría demasiada presión y menos oportunidades de mejora.
  
  
• 00:45:00 El video presenta el cuestionario y el examen final y explica cómo funcionará el cuestionario y el formato del examen final. El video también explica cómo los estudiantes podrán comunicarse con el instructor y programar tutoriales.

[MetaQuotes]

Lección 2. Razonamiento: árboles de objetivos y resolución de problemas

2. Razonamiento: árboles de objetivos y resolución de problemas

Este video analiza cómo razonar, árboles de objetivos y resolución de problemas. Introduce una técnica llamada "reducción de problemas" y explica cómo se puede utilizar para resolver problemas de cálculo. También analiza cómo usar transformaciones heurísticas para resolver problemas y cómo se puede usar el conocimiento para resolver problemas en dominios complejos.

• 00:00:00 El video presenta la reducción de problemas, que es una técnica común de resolución de problemas utilizada por los estudiantes de cálculo. Discute la filosofía educativa detrás de la reducción de problemas y proporciona una lista de ejemplos de reducción de problemas.
  
  
• 00:05:00 El orador está explicando cómo funciona la resolución de problemas y cómo las diferentes transformaciones pueden ayudar a resolver un problema. Repasa cuatro transformaciones seguras que son necesarias para resolver un problema. El primer paso es aplicar todas las transformaciones seguras y luego mirar en la tabla para ver si el problema se ha resuelto. Si el problema se resolvió, el orador informará que se logró.
  
  
• 00:10:00 El video analiza el concepto de árboles de objetivos y resolución de problemas, y presenta la idea de transformaciones heurísticas. Estas transformaciones, aunque no siempre exitosas, pueden ser útiles en ciertas situaciones.
  
  
• 00:15:00 El video analiza varias transformaciones heurísticas que se pueden usar para resolver problemas. Una de estas transformaciones es una familia de transformaciones de las cuales les mostraré solo una. Esta transformación es así: si tienes la integral de una función de la tangente y X, puedes reescribirla como la integral de una función de Y sobre 1 más y al cuadrado dy. Esta transformación de una forma trigonométrica a una forma polinomial elimina toda esa basura trigonométrica con la que no queremos lidiar. Hay una C que también necesitamos, y esa será su reacción instintiva adecuada. Ves algo de la forma 1 menos x al cuadrado, y ¿qué haces cuando ves eso? Bueno, podrías hacer eso. No hay nada que puedas hacer si Kristen tiene algo que pueda sugerir. Ella dice que debido a lo que es nuestro giro húngaro nuestro turno joven, sugiere que hagamos que la transformación que implica el signo de personas X se aplique. Esto significa que Scylla ya no tiene que recordar eso porque en el futuro, nunca tendrá que integrar nada personalmente en su vida. Ella simplemente puede simular el programa. Estos van de la forma polinomial a la forma trigonométrica, por lo que tienes tres
  
  
• 00:20:00 El video analiza el razonamiento, los árboles de objetivos y la resolución de problemas. El presentador presenta una técnica de resolución de problemas llamada "árbol de objetivos". Este árbol muestra cómo se relacionan los objetivos entre sí y puede ser útil para tomar decisiones sobre qué problema resolver. El presentador explica que esta técnica también se conoce como "árbol de inducción de problemas" o "árbol de objetivos".
  
  
• 00:25:00 Este video presenta el concepto de árboles de objetivos y resolución de problemas, y muestra cómo se puede medir la profundidad de la composición de funciones usando símbolos. Luego, el video demuestra cómo se puede aplicar una transformación segura para dividir una integral en tres partes y cómo funciona para una función racional particular.
  
  
• 00:30:00 El video analiza el programa de razonamiento, que resuelve problemas al componer transformaciones seguras. Muestra cómo el programa no llegó a una solución en un problema particular y volvió a trabajar en otro problema.
  
  
• 00:35:00 El video analiza el razonamiento detrás del modelo de Schlegel de problemas de cálculo de primer año, que es un modelo en el que el conocimiento sobre transformaciones, cómo funcionan los árboles antiguos y las tablas son necesarios para resolver los problemas. El video también menciona cómo la profundidad de la composición funcional, que es una técnica que sugirió Brett, en realidad no importa porque el árbol no crece profundo ni ancho.
  
  
• 00:40:00 El video analiza cómo se representa el conocimiento en la resolución de problemas y cómo ciertas transformaciones simplifican el problema. También analiza cómo se puede utilizar el conocimiento para resolver problemas en dominios complejos.
  
  
• 00:45:00 El orador demuestra un programa que supuestamente demuestra cómo las computadoras pueden ser "inteligentes". Sin embargo, el hablante rápidamente se da cuenta de que el programa hace lo mismo que él, por lo que la computadora no es realmente inteligente.

[MetaQuotes]

Lección 3. Razonamiento: árboles de objetivos y sistemas expertos basados en reglas

3. Razonamiento: árboles de objetivos y sistemas expertos basados en reglas

Este video explica cómo funciona un sistema experto basado en reglas. El sistema está diseñado para resolver problemas que son difíciles de resolver utilizando métodos más tradicionales. El sistema se compone de varias reglas que están conectadas por y puertas, lo que permite que el sistema reconozca un animal específico con certeza.

• 00:00:00 Este video explica cómo se construye un sistema experto basado en reglas (RBS) y proporciona un ejemplo de cómo funciona el sistema. El RBS está diseñado para resolver problemas que son difíciles de resolver utilizando métodos más tradicionales, como ecuaciones algebraicas.
  
  
• 00:05:00 En este video, el profesor Patrick Winston explica cómo funcionan los programas de razonamiento o sistemas expertos basados en reglas. La estructura del programa es muy simple, con cuatro bloques que se ejecutan en un bucle iterativo para lograr el resultado deseado. El programa es capaz de resolver problemas que involucran bloques simples porque toma pistas de preguntas que ha respondido en el pasado y usa la recursividad para lograr un resultado complejo.
  
  
• 00:10:00 El video explica cómo se usa un árbol de objetivos para responder preguntas sobre cómo se hizo algo y cómo se puede usar un árbol and-or para hacer esto. También explica que el programa de integración puede usar árboles de objetivos para responder preguntas sobre su propio comportamiento.
  
  
• 00:15:00 Este video analiza cómo el comportamiento complejo es el resultado de la complejidad del entorno, no de la complejidad del programa. Los sistemas expertos basados en reglas se desarrollaron a fines de los años 60 como una forma de encapsular el conocimiento en reglas simples y todavía se usan en la actualidad.
  
  
• 00:20:00 Este video de YouTube analiza cómo se puede usar un sistema experto basado en reglas (RBSES) de cadena progresiva para identificar animales en un zoológico pequeño. El RBSES se compone de varias reglas que están conectadas por y puertas, lo que permite que el sistema reconozca un animal específico con certeza.
  
  
• 00:25:00 Este video explica cómo funciona un sistema experto basado en reglas (RBE), retrocediendo desde una hipótesis para determinar si un objeto es cierto tipo de animal.
  
  
• 00:30:00 Se creó un sistema experto basado en reglas para diseñar casas similares a las diseñadas por el arquitecto portugués Siza. El sistema es capaz de traducir lo que dice un embolsador de la tienda de comestibles en una regla si-entonces, lo que permite que un ingeniero de conocimiento lo entienda.
  
  
• 00:35:00 En este video, el profesor Patrick Winston analiza los principios de la ingeniería del conocimiento, incluida la necesidad de casos específicos y el uso de la heurística. También proporciona un ejemplo de cómo la heurística número dos, la cuestión de si dos objetos son iguales o diferentes, se puede utilizar para resolver problemas.
  
  
• 00:40:00 El presentador analiza tres formas en que se puede mejorar la inteligencia humana: mediante la creación de sistemas basados en reglas, mediante el desarrollo de programas orientados a objetivos y mediante el uso de programas de integración. La heurística número tres es que cuando no se sigue una regla o un objetivo, el sistema se agrieta, lo que indica la necesidad de un mayor conocimiento. El presentador lo demuestra discutiendo un caso en el que un programa prescribió un barril de penicilina a un paciente.
  
  
• 00:45:00 Este video explica cómo funciona el razonamiento a través de árboles de objetivos y sistemas expertos basados en reglas. En ambos ejemplos, el sistema puede leer historias y determinar las consecuencias de las acciones.

[MetaQuotes]

Lección 4. Búsqueda: profundidad primero, escalada, haz

4. Búsqueda: profundidad primero, escalada, haz

En este video de YouTube, Patrick Winston analiza diferentes algoritmos de búsqueda, incluidas las búsquedas Primero en profundidad, Escalada de colinas, Haz y Mejor primero. Usando un mapa como ejemplo, demuestra las ventajas y limitaciones de cada algoritmo y cómo la comprensión de diferentes métodos de búsqueda puede mejorar las habilidades para resolver problemas. Winston también analiza la aplicación de algoritmos de búsqueda en sistemas inteligentes, utilizando el sistema Génesis para responder preguntas sobre la historia de Macbeth. También presenta el concepto de una victoria pírrica y cómo los programas de búsqueda pueden descubrir tales situaciones mirando gráficos e informando sus hallazgos en inglés. En general, el video proporciona una descripción completa de los algoritmos de búsqueda y su uso práctico en escenarios del mundo real.

• 00:00:00 En esta sección, Patrick Winston analiza diferentes métodos de búsqueda y cómo se relacionan con nuestras propias habilidades para resolver problemas. Demuestra la importancia de un buen algoritmo de búsqueda con el ejemplo de encontrar la ruta óptima de un punto a otro en un mapa. También introduce el concepto de búsqueda en el Museo Británico, en el que se exploran todos los caminos posibles, pero señala que este método no es eficiente. Continúa discutiendo la profundidad primero, la escalada de colinas y la búsqueda de haz y cómo se pueden usar en diferentes escenarios. Él enfatiza que comprender diferentes algoritmos de búsqueda puede ayudar a desarrollar la intuición sobre la resolución de problemas y también puede dar una idea de cómo nuestros cerebros abordan los problemas.
  
  
• 00:05:00 En esta sección, se introducen los conceptos de búsqueda en profundidad, subida de colinas y haz utilizando el ejemplo de un mapa. El algoritmo del Museo Británico se utiliza para ilustrar cómo se pueden encontrar todos los caminos posibles sin morderse la cola en un mapa. Si bien la búsqueda se representa a través de mapas, se aclara que no se limita a ellos y que en realidad se trata de elecciones que se hacen al intentar tomar decisiones. La búsqueda en profundidad es una de las búsquedas que se muestran, y consiste en avanzar con determinación, elegir un camino y retroceder cuando se enfrenta a un callejón sin salida. El proceso de retroceso también se presenta como una forma de hacer que el algoritmo sea más eficiente.
  
  
• 00:10:00 En esta sección, el video analiza dos algoritmos de búsqueda principales: búsqueda primero en profundidad y búsqueda primero en amplitud. La búsqueda primero en profundidad se utiliza mejor junto con la técnica opcional de retroceso, ya que puede evitar perder un camino que conduce a la meta. La búsqueda en amplitud construye un árbol nivel por nivel y completa un camino que conduce a la meta. Luego, el video prueba ambos algoritmos de búsqueda en un problema de muestra, moviendo la posición inicial y ajustando la búsqueda en consecuencia. Se presenta un diagrama de flujo para demostrar el algoritmo para la búsqueda, utilizando una cola para representar las rutas bajo consideración.
  
  
• 00:15:00 En esta sección, el orador explica cómo funciona el algoritmo de búsqueda en profundidad. El algoritmo comienza con la inicialización de la cola y la extensión de la primera ruta en la cola. Después de extender s, el hablante obtiene dos caminos, s va a a y s va a b. Para la búsqueda primero en profundidad, las nuevas rutas extendidas se colocan al frente de la cola para que el algoritmo pueda seguir bajando en el árbol de búsqueda. El orador también explica que la búsqueda primero en amplitud usa el mismo algoritmo que la búsqueda primero en profundidad con una línea cambiada, que consiste en colocar las nuevas rutas al final de la cola en lugar de al frente.
  
  
• 00:20:00 En esta sección, aprendemos sobre las limitaciones de Breadth-First Search y cómo mejorarla. El algoritmo se considera ineficiente y no puede saber si se está acercando o alejando de la meta. Además, a menudo extiende caminos que van al mismo nodo más de una vez, y debemos evitarlo. Al modificar el algoritmo para que no extienda una ruta a menos que no se haya extendido antes un nodo final, podemos evitar perder tiempo en rutas duplicadas. Con este método, vemos una mejora significativa en la eficiencia de la búsqueda y la calidad de la ruta.
  
  
• 00:25:00 En esta sección, el video explora la búsqueda de Hill Climbing como un enfoque más informado para encontrar el nodo objetivo considerando la distancia al nodo. De forma similar a la búsqueda en profundidad, Hill Climbing enumera las opciones léxicamente y rompe vínculos en función de la proximidad al nodo objetivo. Esto da como resultado una ruta más recta sin retroceso, aunque puede que no siempre sea la ruta óptima. El video demuestra que Hill Climbing produce menos colas y una ruta más directa en comparación con la búsqueda en profundidad. El video fomenta el uso de heurísticas en los algoritmos de búsqueda, si están disponibles.
  
  
• 00:30:00 En esta sección, el instructor analiza la técnica de Beam Search, un complemento o una adición a Breadth-first Search que permite una búsqueda informada utilizando heurística. Beam Search establece un límite en la cantidad de rutas a considerar en cada nivel y solo mantiene las dos rutas principales que pueden acercarse más al objetivo aprovechando la información adicional o la medición heurística de la distancia al objetivo. El instructor menciona que Hill Climbing también es una búsqueda informada que agrega nuevos caminos al frente de la cola al considerar la distancia a la meta, que se ordenan para mantener todo en orden.
  
  
• 00:35:00 En esta sección, el orador analiza Beam Search y Best-first Search, dos algoritmos de búsqueda adicionales que se pueden usar en espacios continuos como montañas. Beam Search implica seleccionar y mantener las mejores rutas w como solución, mientras que Best-first Search implica trabajar siempre en el nodo hoja más cercano al objetivo y puede saltarse el árbol de búsqueda. Hill Climbing puede encontrar problemas en espacios continuos, como quedarse atascado en un máximo local o no poder moverse en un área plana. Finalmente, el orador ilustra un problema adicional con Hill Climbing en espacios de dimensiones altas, donde puede estar presente un puente afilado.
  
  
• 00:40:00 En esta sección, el video analiza la inteligencia de modelado y la necesidad de algoritmos de búsqueda en la construcción de sistemas inteligentes. El orador usa el ejemplo de un mapa topográfico para ilustrar cómo podemos engañarnos y pensar que estamos en la cima, cuando en realidad no lo estamos. Esto lleva al concepto de búsqueda, que es necesario para hacer planes y evaluar opciones. Luego, el orador demuestra el uso del sistema Génesis para responder preguntas sobre la historia de Macbeth utilizando un algoritmo de búsqueda. El sistema absorbe información, construye un gráfico de elaboración y busca patrones en la historia relacionados con la venganza y otros conceptos de nivel superior.
  
  
• 00:45:00 En esta sección, Patrick Winston analiza el concepto de una victoria pírrica, que es una situación en la que todo parece ir bien al principio, pero al final tiene consecuencias negativas. Demuestra cómo los programas de búsqueda pueden descubrir dicha información al mirar a través de gráficos y pueden responder preguntas basadas en esa información. Los programas usan una combinación de declaraciones explícitas y reglas si/entonces para construir estos gráficos y reportar la información en inglés. Winston también menciona que estos programas pueden generar respuestas de sentido común y pensamientos de alto nivel al informar sobre las búsquedas que produjeron la información. Por último, demuestra la capacidad del sistema para responder preguntas sobre el carácter y las motivaciones de Macbeth utilizando la salida de lenguaje generada por un sistema analizador.

[MetaQuotes]

Clase 5. Búsqueda: Óptima, Branch and Bound, A*

5. Búsqueda: Óptima, Branch and Bound, A*

El video analiza varios algoritmos de búsqueda para encontrar el camino más corto entre dos lugares, centrándose en el ejemplo de la Ruta 66 entre Chicago y Los Ángeles. El video presenta el concepto de distancia heurística y proporciona ejemplos de diferentes algoritmos de búsqueda, como escalada de colinas, búsqueda de haz y bifurcación y límite. El ponente destaca la importancia de utilizar heurísticas admisibles y consistentes en el algoritmo A* para optimizar la búsqueda. Además, el video destaca la efectividad de usar una lista extendida y distancias de líneas aéreas para determinar los límites inferiores en el camino más corto. En última instancia, el video concluye con la promesa de analizar mejoras adicionales del algoritmo A* en la próxima lección.

• 00:00:00 En esta sección, el profesor analiza cómo encontrar el camino más corto entre dos lugares, centrándose en el ejemplo de la Ruta 66 entre Chicago y Los Ángeles. Menciona la creación del sistema de carreteras interestatales por parte del presidente Eisenhower, quien quería replicar la capacidad del ejército alemán para mover tropas rápidamente por todo el país. Luego, el profesor introduce el concepto de distancia heurística y cómo puede ayudar a encontrar el mejor camino, aunque no siempre es cierto. También da ejemplos de diferentes algoritmos de búsqueda, como la escalada de colinas y la búsqueda de haz, que tienen como objetivo encontrar el mejor camino estando cerca del destino.
  
  
• 00:05:00 En esta sección, el profesor analiza el concepto de distancia heurística y el principio de resolución de problemas preguntando a alguien que sabe la respuesta. Usando el ejemplo de encontrar el camino más corto en un mapa, el profesor sugiere seguir el camino sugerido por Juana, pero lo verifica comprobando que todos los demás caminos posibles terminan siendo más largos que la ruta sugerida. El profesor profundiza en el proceso de cálculo de la longitud del camino y la elección del camino más corto para extender, hasta que la longitud del camino coincida con la sugerida por Juana.
  
  
• 00:10:00 En esta sección, el orador analiza cómo encontrar el camino más corto sin un oráculo. El enfoque consiste en extender el camino más corto hasta llegar a la meta. El orador brinda un ejemplo para ilustrar el proceso de encontrar el camino más corto al considerar caminos con longitudes no negativas. El enfoque verifica si parte del trabajo realizado hasta ahora se desperdicia y, si no, entonces la longitud del camino es la más corta. El orador explica que este enfoque puede encontrar el camino más corto, pero puede haber otros caminos si existen longitudes de longitud cero.
  
  
• 00:15:00 En esta sección del video, el orador demuestra el uso de bifurcación y límite para encontrar el camino más corto en un mapa más complicado. Mencionan decorar el diagrama de flujo y explican el proceso de inicializar la cola, probar la primera ruta en la cola y extender las rutas que no son ganadoras. El orador señala que el enfoque de bifurcación y límite pone muchos caminos en la cola y extiende muchos caminos que no son óptimos, pero esto se puede mejorar extendiendo solo los caminos que no se han extendido antes. El orador enfatiza la importancia de usar solo el enfoque de caminos extendidos para encontrar caminos óptimos.
  
  
• 00:20:00 En esta sección, se introduce el concepto de una lista extendida como una mejora de ajuste al algoritmo de bifurcación y enlace. La lista extendida evita que el algoritmo extienda rutas que ya se han extendido y que tienen longitudes de ruta más largas que las que ya han llegado al mismo punto. Al mantener una lista extendida, se pueden podar vastas áreas del árbol, lo que reduce la cantidad de extensiones necesarias para llegar a una solución. En comparación con el ejemplo anterior, el nuevo algoritmo solo requiere 38 extensiones en lugar de 835, lo que genera un ahorro sustancial en el tiempo de cómputo.
  
  
• 00:25:00 En esta sección, se introduce el concepto de utilizar las distancias de las líneas aéreas para determinar el límite inferior de la ruta más corta posible. La distancia acumulada y la distancia de la línea aérea se suman para proporcionar un límite inferior en la ruta. A continuación, se demuestra la simulación con la selección de la ruta con la distancia potencial más corta de S a G. En caso de empate en la puntuación, se elige la ruta con el valor léxico más bajo.
  
  
• 00:30:00 En esta sección, el orador analiza el uso de heurística para acelerar los algoritmos de búsqueda de gráficos. El uso de una heurística admisible es cuando se garantiza que una estimación será menor que la distancia real. La lista extendida es más útil que usar una de estas heurísticas de límite inferior. Sin embargo, la eficacia de la heurística depende del problema y, al cambiar la ubicación de la posición inicial, se pueden alterar los resultados de la búsqueda. En última instancia, es importante tener en cuenta que es posible que el uso de heurísticas no repita los movimientos a través del mismo nodo, pero no necesariamente hará algo esencial para una búsqueda eficiente.
  
  
• 00:35:00 En esta sección, el video analiza A*, un algoritmo de búsqueda que combina la heurística admisible y el algoritmo de bifurcación y límite. Al utilizar ambas técnicas, A* puede mejorar en gran medida su desempeño individual. La heurística admisible utiliza un objetivo estricto, mientras que el algoritmo de ramificación y límite comprende la exploración espacial involucrada. El video muestra cómo A* puede resolver problemas de manera más eficiente cuando ambas técnicas se utilizan juntas. Sin embargo, el video también señala que ciertas circunstancias pueden hacer imposible la admisibilidad si la búsqueda va más allá de los mapas tradicionales. Como resultado, la jerarquía admisible y el algoritmo A* pueden volverse menos efectivos para encontrar soluciones óptimas.
  
  
• 00:40:00 En esta sección, el profesor explica el concepto de heurística admisible en el algoritmo A*. Muestra un ejemplo de un mapa con distancias impares y explica cómo el uso de una heurística admisible no siempre conduce a encontrar el camino más corto. El profesor enfatiza que la heurística admisible solo funciona para mapas y que para que el algoritmo funcione en situaciones que no son mapas, se necesita algo más fuerte que la admisibilidad en las heurísticas. El video concluye con la promesa de discutir este refinamiento en la próxima lección.
  
  
• 00:45:00 En esta sección, el disertante analiza los requisitos para que una función heurística funcione dentro del algoritmo A*. Introduce los conceptos de admisibilidad y consistencia, explicando que una función heurística debe ser tanto admisible como consistente para trabajar en situaciones donde no es un mapa. Muestra que el uso de una heurística admisible pero inconsistente puede hacer que el algoritmo falle, incluso en escenarios en los que habría funcionado una heurística consistente. Finalmente, el disertante enfatiza la importancia de utilizar todas las ventajas disponibles para optimizar el algoritmo A*, incluido el uso de una lista extendida y una función heurística apropiada.

[MetaQuotes]

Lección 6. Búsqueda: Juegos, Minimax y Alpha-Beta

6. Búsqueda: Juegos, Minimax y Alpha-Beta

El video analiza la historia de los juegos en IA, comenzando con la famosa cita de Dreyfus de que las computadoras no pueden jugar al ajedrez. Los oradores explican cómo las reglas si-entonces no son efectivas en los programas de juegos, y se requiere un análisis y una estrategia más profundos. Presentan el algoritmo minimax y el concepto de poda alfa-beta para optimizar la eficiencia de búsqueda de juegos. El video también explora técnicas como la minimización del costo de las pólizas de seguro y la profundización progresiva. El orador concluye que si bien la inteligencia de la excavadora es importante, no es necesariamente el mismo tipo de inteligencia que los humanos tienen en sus propias cabezas.

• 00:00:00 En esta sección, los oradores discuten la historia temprana de los juegos en IA, destacando una cita famosa de Hubert Dreyfus de que las computadoras no pueden jugar al ajedrez. Sin embargo, los disertantes argumentan que los juegos pueden modelar algunos elementos de inteligencia, por lo que proceden a explicar cómo una computadora puede jugar al ajedrez. Consideran usar reglas si-entonces para abordar un juego, un método que no es muy efectivo, pero que se ha implementado con éxito en algunos programas de juego de damas. Los oradores finalmente concluyen que se requiere un análisis y una estrategia más profundos junto con tácticas y velocidad en los programas de juegos, que explorarán más adelante en la sección.
  
  
• 00:05:00 En esta sección, el orador analiza la tercera forma de crear un programa sólido para jugar al ajedrez, que implica mirar hacia adelante y evaluar todas las posibles consecuencias de los movimientos para determinar la mejor situación posible en el tablero. Esto requiere una función que combine las características del tablero de ajedrez para producir un valor estático utilizado para determinar la mejor situación del tablero. El orador explica que la forma más popular de formar un valor estático es mediante un polinomio de puntuación lineal. Sin embargo, el método utilizado no tiene que clasificar las situaciones del tablero ni darles números; simplemente tiene que determinar cuál es el mejor. El orador también habla sobre el factor de ramificación de los árboles de movimiento y cómo calcular el número de nodos terminales o de hoja.
  
  
• 00:10:00 En esta sección, el ponente explica las limitaciones del algoritmo del Museo Británico en ajedrez debido a la gran cantidad de nodos hoja en el árbol de decisión del juego. Según Claude Shannon, hay alrededor de 10 a 120 nodos de hoja en el ajedrez, lo que hace que sea impracticable utilizar el tratamiento del Museo Británico para evaluar la mejor jugada. Para poner ese número en perspectiva, el orador calcula que incluso si todos los átomos en el universo estuvieran haciendo evaluaciones estáticas a velocidades de nanosegundos desde el comienzo del Big Bang, aún nos faltarían 14 órdenes de magnitud. Por lo tanto, el orador concluye que debemos mirar hacia adelante lo más lejos posible si queremos evaluar la mejor jugada en el ajedrez.
  
  
• 00:15:00 En esta sección, el orador explica el algoritmo minimax, que consiste en asignar valores a los nodos de hoja de un árbol de juego y "respaldarlos" nivel por nivel para determinar el mejor movimiento posible para cada jugador. El jugador que maximiza quiere llevar la jugada hacia el valor más grande, mientras que el jugador que minimiza quiere empujarla hacia el valor más pequeño. Al calcular estos valores y decidir el mejor curso de acción, el algoritmo se puede usar para jugar juegos de confrontación como el ajedrez. El orador ilustra el algoritmo con un árbol de juego simple y también muestra un ejemplo del algoritmo en acción con un árbol de juego más grande.
  
  
• 00:20:00 En esta sección del video, la atención se centra en encontrar formas de llegar lo más abajo posible en el árbol de búsqueda para aclarar las medidas crudas de la calidad del tablero que pueden dar una idea bastante buena del próximo movimiento a realizar. . La solución para cortar grandes porciones del árbol de búsqueda radica en el algoritmo alfa-beta, que es una capa encima de minimax. Alpha-beta utiliza dos parámetros, alfa y beta, para cortar secciones del árbol de búsqueda, lo que permite una búsqueda más eficiente. Este algoritmo no es una alternativa al minimax, sino una forma de hacerlo más eficiente. Se da un ejemplo para demostrar cómo funciona el algoritmo alfa-beta en la práctica.
  
  
• 00:25:00 En esta sección, el orador analiza el proceso de búsqueda de juegos y cómo se puede optimizar mediante el uso de algoritmos como minimax y alpha-beta. El ejemplo utilizado es un árbol de profundidad cuatro o mayor, donde el hablante encierra en un círculo los números que deben calcularse, lo que revela que ciertas ramas no necesitan evaluarse debido a situaciones de corte. Esto ahorra tiempo de cálculo y permite una búsqueda de juegos más eficiente. El orador también presenta el concepto de corte profundo, donde los números se comparan en niveles separados en el árbol y ciertas ramas se consideran irrelevantes. Si bien esto puede parecer difícil de creer, el proceso es efectivo y puede mejorar en gran medida la eficiencia de la búsqueda de juegos.
  
  
• 00:30:00 En esta sección, el video analiza el concepto de poda alfa-beta y cómo puede ahorrar tiempo computacional en los algoritmos de juego. Al evaluar los estados del tablero, el minimizador y el maximizador pueden decidir cuál es el mejor movimiento posible. El minimizador obtiene un 8 de cierta manera y el maximizador puede obtener un 9 de otra manera, creando una situación límite. La poda alfa-beta permite que el algoritmo avance a través de los árboles, con alfa y beta reduciéndose alrededor de la situación, lo que ahorra cálculos. Aunque este método solo funciona en la situación óptima donde el factor de ramificación es constante, aún ahorra mucho tiempo y cálculo, lo que lo convierte en una herramienta necesaria para los programas de juegos.
  
  
• 00:35:00 En esta sección, aprendemos a minimizar el costo de las pólizas de seguro para los cálculos del árbol del juego. Al calcular los valores estáticos un nivel por encima del nivel inferior y no completamente hacia abajo, brinda una póliza de seguro para garantizar un buen movimiento sin tener que calcular b para los nodos de hoja d. El costo de la póliza de seguro se calcula sumando el número de hojas en cada nivel del árbol. Sin embargo, para minimizar el costo, existe un límite de cuántos niveles debe cubrir la póliza a partir del primer nivel. Usando álgebra, se encuentra que el cálculo requerido para la política del nivel más alto es igual a ba d menos 1 sobre b menos 1, que es un cálculo manejable.
  
  
• 00:40:00 En esta sección, se introduce el concepto de profundización progresiva como una forma de optimizar el resultado de las pólizas de seguro en el árbol del juego. Al tener siempre un movimiento disponible en cada nivel como una póliza de seguro contra no pasar al siguiente nivel, la profundización progresiva ejemplifica cómo los algoritmos en cualquier momento siempre tienen una respuesta lista para usar tan pronto como se requiera. Además, Christopher sugiere usar valores temporales para mejorar el rendimiento de alfa-beta, una idea que luego se muestra como una reinvención de un concepto significativo. El programa Deep Blue no es muy diferente de otros programas de juego, excepto por el uso de la computación paralela y técnicas de propósito especial para el juego final.
  
  
• 00:45:00 En esta sección, el orador analiza el desarrollo de un árbol desigual durante un juego y cómo no es necesario que el árbol baje a un nivel fijo. Habla de que Deep Blue derrotó a Kasparov en 1997 debido a las florituras adicionales que tenía Deep Blue. Sin embargo, menciona que este tipo de cómputo en el que uno está realizando cálculos de la misma manera que una excavadora procesa grava, es diferente a la inteligencia humana. Los maestros de ajedrez humanos juegan juegos de manera diferente, reconociendo patrones en lugar de realizar largos cálculos. El orador concluye que es importante entender la inteligencia de la excavadora, pero no es necesariamente el mismo tipo de inteligencia que los humanos tienen en sus propias cabezas.

[MetaQuotes]

Lección 7. Restricciones: interpretación de dibujos lineales

7. Restricciones: interpretación de dibujos lineales

El video analiza el desarrollo de un problema de satisfacción de restricciones para interpretar dibujos lineales, que comenzó con el intento de crear una computadora que pudiera ver objetos simples. Se analizó el trabajo del experimentalista Guzmán, que condujo al enfoque de David Huffman de trabajar en un mundo matemático simple con restricciones que le permitieron desarrollar una teoría mejor que el programa de Guzmán. El video explora el vocabulario utilizado para catalogar y categorizar líneas y uniones en dibujos, la posibilidad de tener cinco octantes llenos de cosas y el uso de restricciones para probar la constructibilidad de los objetos. El video también analiza el desafío de usar etiquetas para interpretar dibujos lineales, el algoritmo de Waltz y el proceso de tratar con vértices de horquilla en el análisis de dibujos. Las restricciones desarrolladas en este proyecto tienen aplicaciones en la resolución de problemas con muchas restricciones, como la coloración de mapas y la programación.

• 00:00:00 Interpretaría dibujos lineales y determinaría el número de objetos dentro de ellos. Esta idea fue refinada aún más por Dave Huffman, Dave Waltz y Jane Froydter. El trabajo en este proyecto estuvo inicialmente motivado por un intento de crear una computadora que pudiera ver, comenzando con objetos simples como bloques para niños. En esta sección de la transcripción, Patrick Winston comparte la historia detrás de la lucha por desarrollar uno de los métodos más poderosos en la materia, que incluye problemas de satisfacción de restricciones, y cómo todo comenzó con el intento de hacer una computadora capaz de ver.
  
  
• 00:05:00 En esta sección, el disertante analiza el trabajo de Guzmán, quien investigó los dibujos lineales y cómo interpretarlos. Guzmán descubrió que estos dibujos tienden a tener muchas uniones tipo flecha y uniones tipo horquilla, y las usó como evidencia para deducir qué caras pertenecen al mismo objeto. Guzmán ideó una teoría sobre el uso de "enlaces" como cantidad de evidencia para resolver este problema. Rechazó la teoría de un enlace y descubrió que la teoría de dos enlaces era demasiado conservadora, lo que lo llevó a una tercera teoría de dos longitudes repetidas. Sin embargo, hubo muchas situaciones en las que este método no funcionó, y se planteó la pregunta de por qué funcionó y cuándo no funcionó. Se descubrió que funcionaba porque el mundo está lleno de uniones de tres caras o vértices.
  
  
• 00:10:00 En esta sección, el video analiza el enfoque de David Huffman para desarrollar una teoría sobre la interpretación de dibujos lineales después de analizar el programa del experimentalista Guzmán. Huffman decidió trabajar en un mundo matemático simple con varias características, como un mundo en posición general que solo contenía vértices triédricos formados a partir de la intersección de tres planos, y distinguir entre cuatro tipos de líneas: cóncavas, convexas y de límite marcadas con más, menos y flechas, respectivamente. Estas limitaciones le permitieron manejar el problema manualmente mientras desarrollaba una teoría diferente y mejor que el programa de Guzmán.
  
  
• 00:15:00 En esta sección, el profesor Patrick Winston analiza el vocabulario utilizado para catalogar y categorizar líneas y cruces en dibujos, incluidos vértices, aristas, cruces y líneas. Continúa explicando que solo hay 18 formas de colocar etiquetas alrededor de un cruce y que todo lo demás está excluido. También proporciona ejemplos de las seis L, cinco bifurcaciones, cuatro T y tres flechas que son legítimas para etiquetar cruces. Las diferentes formas de etiquetar los cruces dependen de los octantes, y el número de octantes ocupados determina el tipo de cruce.
  
  
• 00:20:00 En esta sección, el orador analiza las posibilidades de tener cinco octantes llenos de cosas y explica cómo ver un objeto desde tres perspectivas diferentes para analizar lo que se observa. Al mirar el objeto desde la perspectiva de una tiza morada, hay una unión de flechas con dos cóncavas y una convexa; de la tiza azul, hay una línea cóncava y un límite, mientras que el otro lado es un
  opuesto simétrico de la perspectiva azul. El orador examina más a fondo los vértices que pueden crear uniones de estilo de horquilla y de estilo L, así como oscurecer objetos que pueden crear formas de T con la línea restante como límite. Finalmente, el ponente menciona que también se pueden crear vértices con seis caras cuando los objetos se juntan en un punto.
  
  
• 00:25:00 En esta sección, el orador analiza las restricciones y cómo se pueden usar para determinar si un objeto en particular es construible o no. Al estudiar la disposición de líneas y flechas alrededor de un cruce, se crea un catálogo de todas las disposiciones posibles. Usando este catálogo, el orador demuestra cómo etiquetar las líneas y flechas alrededor de un objeto que se parece al plato de home. Sin embargo, ante un cruce que no encaja en el catálogo, se determina que el objeto es imposible de construir. Este método proporciona una forma de probar la constructibilidad de los objetos, aunque pasar la prueba no es suficiente para garantizar la constructibilidad.
  
  
• 00:30:00 En esta sección, el video explora el problema de interpretar dibujos lineales en la visión por computadora. El enfoque inicial consistía en etiquetar los cruces con cuatro caras, pero algunos dibujos no se pudieron etiquetar debido a la falta de caras. El estudiante de posgrado David Waltz se dispuso a resolver este problema y agregó más consideraciones, como grietas, sombras y vértices no triédricos. Esto resultó en un aumento de la cantidad de etiquetas de cuatro a más de 50, lo que dificultaba el trabajo manual. El trabajo de Waltz mostró la importancia de tener un problema, un método que funcione y un principio generalizable.
  
  
• 00:35:00 En esta sección, el orador discute el desafío de usar etiquetas para interpretar dibujos lineales. Comparte un ejemplo de un dibujo lineal y explica cómo se puede utilizar el algoritmo de Waltz, que implica el uso de la búsqueda en profundidad para explorar todas las etiquetas posibles y sus combinaciones, para interpretarlo. Sin embargo, el algoritmo resulta ser computacionalmente costoso y, después de un año y medio, Waltz tuvo que idear un nuevo método que pudiera manejar el espacio de búsqueda exponencial. El orador señala que la eficacia del algoritmo se debió a la combinación del conjunto de etiquetas de Waltz y su nuevo método.
  
  
• 00:40:00 En esta sección, el orador analiza el algoritmo de Waltz y cómo verifica los cruces vecinos para ver si las líneas que se colocaron en el cruce dos son compatibles con las de los cruces vecinos. De las seis posibilidades iniciales, la mitad de ellas se eliminan debido a las líneas de límite no permitidas entre los cruces uno y dos. Las posibilidades restantes se comparan con el cruce tres y, a partir de ahí, se verifica cualquier restricción adicional en los cruces, lo que da como resultado una sola interpretación para todos los cruces y líneas entre ellos.
  
  
• 00:45:00 En esta sección, el orador discute el proceso de tratar con los vértices de la bifurcación en el análisis del dibujo. Después de colocarlos, el hablante concluye que tiene una interpretación única para todos los cruces e identifica qué líneas son convexas o cóncavas. Luego, el orador demuestra el proceso para los dibujos con más ambigüedad y señala que la actividad de propagación de restricciones es similar a cómo los humanos interpretan los dibujos lineales, lo que revela que podemos tener un aparato de propagación de restricciones que usamos en la visión. Por último, el disertante discute cómo este tipo de mecanismo podría usarse para resolver problemas que involucran mucha restricción, específicamente en el coloreado de mapas que tiene aplicaciones en la programación.