Introducción
El propósito de esta tarea es presentarle la construcción, el entrenamiento y la prueba de modelos de redes neuronales. No solo estará expuesto a la creación de redes de redes neuronales desde cero utilizando paquetes de Python, sino también a los aspectos matemáticos de la propagación hacia atrás y el descenso de gradiente. Pero en el mundo real, no necesariamente tiene que implementar una red neuronal desde cero (como verá en futuros laboratorios y tareas), esta tarea está diseñada para darle una idea del funcionamiento de bajo nivel de paquetes como TensorFlow y Keras comprensión inicial. En esta tarea, utilizará el conjunto de datos de dígitos escritos a mano del MNIST para entrenar una red neuronal de clasificación simple mediante el aprendizaje por lotes y evaluar su modelo.
Inglés (inglés): http://t.csdn.cn/p8KTX
Enlace a este artículo archivo .pdf
-------------------------------------------------- -------------------------------------------------- --------------------------------------------
Código de extracción: v6zc
https://pan.baidu.com/s/1_qFbN0Nhc8MNYCHEyTbkLg%C2%A0
Experimento 2: Numpy red neuronal multicapa escrita a mano
Documentos necesarios para el experimento.
Descripción general del trabajo:
Antes de que comience el experimento:
Respuesta de referencia: http://t.csdn.cn/9sdBN
Documentos necesarios para el experimento.
Adquisición de archivos:
Enlace: https://pan.baidu.com/s/1JQnPdOJQXqQ43W74NuYqwg
Código de extracción: 2wlg
Estructura del archivo:
| - hw2
| - código
| - Arroz
| - 8 archivos .py se utilizan para implementar las funciones de requisitos experimentales
|-asignación.py
| - preproceso.py
| - visualizar.py
| - datos
| - mnista
| - Cuatro archivos de conjuntos de datos
problema conceptual
Envíe preguntas conceptuales sobre Gradescope bajo hw2-mlp Conceptual. Debe ingresar su envío y cargar el archivo PDF. Recomendamos usar LaTeX.
obtener plantilla
¡Enlace de Github Classroom con código de plantilla!
Guía sobre GitHub y GitHub Classroom
obtener datos
Los datos se pueden descargar mediante download.sh. método para ejecutar comandos de script bash.
/script_name.sh (p. ej.: bash ./download.sh).
Esto es similar a HW1. Utilícelo para eliminar el código de plantilla proporcionado, pero no cambie la plantilla a menos que se especifique.
Si lo hace, puede resultar en una incompatibilidad con los programas de clasificación automática. ¡No cambie ninguna firma de método!
Esta tarea requiere NumPy y Matplotlib. Ya debería obtener esto de HW1. Consulte también la guía de entornos virtuales para configurar TensorFlow 2.5 en su máquina local. Por favor siéntase libre
Si debe usar colab, consulte esta guía.
Descripción general del trabajo:
En esta tarea, construirá una imitación de Keras, Beras (jaja, nombre gracioso), y formulará una especificación de modelo secuencial que imita la API de Tensorflow/Keras. ¡El cuaderno de Python asociado con esta tarea está ahí para permitirle explorar una implementación de ejemplo para que pueda implementar la suya! py Nuestra plantilla proporciona una clase modelo con varios métodos e hiperparámetros que necesita usar para su red. También responderá material de preguntas conceptuales relacionadas con las tareas y el trabajo del curso (si es un estudiante de 2470, ¡no olvide responder las preguntas de 2470!). Debe incluir un breve documento LÉAME que explique la precisión de su modelo y cualquier conocimiento conocido. insectos.
Antes de que comience el experimento:
Esta tarea debe entregarse dos semanas después de su publicación. Los laboratorios 1 a 3 brindan buenas prácticas para esta tarea, por lo que si se atasca, puede esperarlos por un tiempo. Específicamente:
☆ -
Implementación de componentes invocables/difusibles : las habilidades necesarias para lograrlo
Se puede encontrar a través del Laboratorio 1. Esto incluye el dominio de las matemáticas.
Símbolos, operaciones matriciales y la lógica detrás de los métodos de llamadas y gradientes .
☆ -
Implementando el Optimizer : Puede implementar la clase BasicOptimizer al
Siga la lógica del método de descenso de gradiente en el laboratorio 1. otras optimizaciones
(por ejemplo, Adam, RMSProp) se tratará en el laboratorio 2: Optimizer .
☆ -
Uso de batch_step y GradientTape: puede aprender a usarlos para entrenar su modelado según las instrucciones de asignación y las implementaciones de estas instrucciones. Dicho esto, imitan la API de Keras. Aprenderá todo sobre Tensorflow en el Laboratorio 3: Introducción. Si su experimento ya pasó la fecha límite, debería estar bien; eche un vistazo a los cuadernos complementarios relacionados con el laboratorio. Puede hacer lo que pueda primero y luego agregar a medida que aprende más sobre la profundidad. ¡Aprende y date cuenta de que los conceptos que aprendes en clase realmente se pueden utilizar aquí!¡No te desanimes, trata de divertirte!
Hoja de ruta: en esta tarea, lo guiaremos a través del proceso de capacitación de la red neuronal, incluida la estructura de la clase modelo y los métodos que debe completar.
1. Datos preprocesados
Antes de entrenar la red, es necesario limpiar los datos. Esto incluye recuperar, cambiar y formatear datos como entrada a la red. Para esta tarea, trabajará con el conjunto de datos MNIST. Está disponible al descargar el script .sh, pero también está vinculado aquí (ignore lo que dice hw1; ¡esta vez usamos este conjunto de datos que es hw2!). La fuente de datos original está aquí. Solo debe entrenar la red con los datos de entrenamiento y luego probar la precisión de la red en los datos de prueba. Su programa debe imprimir su precisión en el conjunto de datos de prueba después de la finalización.
Nota: El código de preprocesamiento debe extraerse de HW1.
2. Codificación en caliente
Antes de entrenar o probar el modelo, debe codificar "one-hot" las etiquetas de clase para que el modelo pueda optimizarse para predecir cualquier clase deseada. Tenga en cuenta que las etiquetas de clase en sí mismas son categorías simples y no tienen significado numérico. En ausencia de codificación one-hot, su modelo podría aprender algún ordenamiento natural entre etiquetas basado en etiquetas de diferentes clases (las etiquetas son arbitrarias). Por ejemplo, supongamos que hay un punto de datos a correspondiente a la etiqueta '2' y un punto de datos B correspondiente a la etiqueta '7'. No queremos que el modelo sepa que B tiene un peso mayor que a, porque numéricamente, 7 > 2. Para codificar sus etiquetas de clase de una sola vez, debe convertir su vector de etiqueta 1D en un vector de tamaño num_classes (el número total de clases en su conjunto de datos). Para el conjunto de datos MNIST, se parece a la matriz de la derecha:
Tienes que rellenar el siguiente método en Beras/onehot.py:
fit(): [TODO] En esta función, toma datos (los almacena en self.uniq) y crea un diccionario con etiquetas como claves y sus correspondientes codificaciones one-hot como valores. Sugerencia: es posible que desee verificar np.eye() para la codificación one-hot. Eventualmente, lo almacenará en el diccionario self.uniq2oh.
forward(): en esta función, pasamos un vector que contiene todos los conjuntos de entrenamiento etiquetados reales en el objeto y llamamos a fit() para llenar el diccionario uniq2oh con etiquetas únicas y sus codificaciones one-hot correspondientes, luego lo usamos para devolver un An matriz de etiquetas codificadas one-hot para cada etiqueta en el conjunto de entrenamiento.
¡Esta función ya está llena para ti!
● inverse(): en la función, invertimos la codificación one-hot a la etiqueta de codificación real.
Esto ya se ha hecho por ti.
Por ejemplo, si tenemos etiquetas X e Y, que están codificadas en caliente como [1,0] y [0,1],
{X: [1,0], Y: [0,1]}. Como se muestra en la figura,
Para MNIST, tendrá 10 etiquetas, ¡así que su diccionario debería tener 10 entradas!
Puede notar que algunas clases heredan de Callable o Diffable. más sobre esto
en la siguiente sección!
3. Abstracción central
Considere la clase abstracta del siguiente módulo. ¡Asegúrese de jugar con esta tarea de cuaderno de Python para obtener una buena comprensión de los módulos abstractos que el núcleo define para usted en Beras/core.py! El cuaderno es exploratorio (no es obligatorio, se proporciona todo el código) y le dará una mucha profundidad para comprender y usar estas abstracciones de clase Tenga en cuenta que los siguientes módulos son muy similares a la API de Tensorflow/Keras.
Invocable: una función con una función de reenvío bien definida. Estas son las implementaciones que necesitas:
● CategoricalAccuracy (./metrics.py): Calcula la probabilidad de precisión pronosticada contra una lista de etiquetas de verdad del terreno. Dado que la precisión no está optimizada, no es necesario calcular su gradiente. Además, la precisión de la clase es discontinua por partes, por lo que los gradientes son técnicamente 0 o indefinidos.
● OneHotEncoder (./onehot.py): puede codificar one-hot una instancia de clase en una distribución de probabilidad optimizada, clasificada como opciones discretas:
Diferenciable: Un objeto invocable que también es diferenciable. ¡Podemos usarlos en nuestra línea de producción y optimizarlos a través de ellos! Así que la mayoría de estas clases son capas de red creadas para usar en su sistema neuronal. Esto es lo que necesitas implementar:
Ejemplo: Considere una instancia de capa densa. Denotemos con s el tamaño de entrada (fuente), d el tamaño de salida (destino) y b el tamaño del lote. Después:
GradientTape: Esta clase funciona exactamente como tf.GradientTape() (ver Experimento 3). Puede pensar en GradientTape como una grabadora. Cada vez que una operación está en el alcance de la cinta de gradiente, registra la operación que tuvo lugar. Entonces, en
Backprop, podemos calcular gradientes para todas las operaciones. Esto nos permite diferenciar el resultado final de cualquier paso intermedio. Cuando las operaciones se calculan fuera de los límites de GradientTape, no se registran, por lo que su código no tendrá registro de ellas y no podrá calcular gradientes. ¡Puedes ver cómo se implementa esto en el núcleo! Por supuesto, la implementación de cintas de degradado de Tensorflow es mucho más complicada y requiere construir un gráfico.
● [TODO] Implementar el método de gradiente, que devuelve una lista de gradientes correspondientes a una lista de pesos entrenables en la red. Detalles en el código.
4. Capa de red
En este artículo, implementará su modelo secuencial en Beras/layers.py. Debes llenar los siguientes métodos:
● forward() : [TODO] Implementar pase hacia adelante y salida de retorno.
● weight_gradients() : [POR HACER] Calcula los pesos y sesgos del degradado en . Esto se utilizará para optimizar la capa.
● input_gradients() : [TODO] Calcula la entrada de la capa de degradado con respecto a . Esto se usará para propagar el degradado a las capas anteriores.
● _initialize_weight() : [TODO] Inicializar valores de peso para capas densas De forma predeterminada, todos los pesos se inicializan a cero (lo que, por cierto, generalmente es una mala idea). También debe permitir opciones más complejas (cuando los inicializadores están configurados en normal, xavier y kaiing). ¡Sigue las suposiciones matemáticas de Keras!
〇 Normal : Distribución normal unitaria que se explica por sí misma.
〇Xavier Normal: Basado en keras.GlorotNormal.
〇Kaiing He Normal: Basado en Keras.HeNormal.
Al implementarlos, puede encontrar útil np.random.normal. El plan de acción explica por qué estos diferentes métodos de inicialización son necesarios, pero para obtener más detalles, consulte este sitio ¡Siéntase libre de agregar más opciones de inicialización!
5. Función de activación
En esta tarea, implementará dos funciones de activación principales, a saber: LeakyReLU y Softmax en Beras/activation.py . Dado que ReLU es un caso especial de LeakyReLU , proporcionamos su código.
● LeakyReLU()
〇forward() : [TODO] Dada la entrada x, calcula y devuelve LeakyReLU(x).
〇input_gradients() : [TODO] Calcula y devuelve la entrada obtenida por derivación de LeakyReLU.
● Softmax():(2470 SOLAMENTE)
forward(): [TODO] Dada la entrada x, calcula y devuelve Softmax(x). Asegúrese de estar utilizando un softmax estable, es decir, restando el máximo de todos los términos para evitar problemas de desbordamiento/desbordamiento.
〇input_gradients(): [TODO] Entrada de escritura parcial de Softmax().
6. Rellene el modelo
Armados con estas abstracciones, creemos un modelo secuencial para el aprendizaje profundo secuencial. Puede encontrar la clase SequentialModel en Assignment.py para inicializar las capas, los parámetros (pesos y sesgos) y los hiperparámetros (optimizador, función de pérdida, tasa de aprendizaje, función de precisión, etc.) de su red neuronal. La clase SequentialModel hereda de Beras/model.py, donde puede encontrar muchos métodos útiles. Esto también contendrá funciones apropiadas para sus datos y modelo para evaluar el rendimiento de su modelo:
● compile() : inicializa el optimizador de modelo, la función de pérdida y la función de precisión, que se ingresan como parámetros para que los use la instancia de SequentialModel .
● fit() : entrena el modelo para asociar la entrada y la salida. El entrenamiento se repite para cada época y los datos se procesan por lotes en función de los parámetros. También calcula Batch_metrics, epoch_metrics y agg_metrics agregados que se pueden usar para rastrear el progreso de entrenamiento del modelo.
● evaluar() : [TODO] Evaluar el rendimiento del modelo final utilizando las métricas mencionadas en la fase de prueba. Casi coincide con la función (); piense en lo que sucede entre el entrenamiento y la prueba).
● call() : [TODO] Sugerencia: ¿Qué significa llamar a un modelo secuencial? Recuerde que un modelo secuencial es una pila de capas, y cada capa tiene solo un vector de entrada y un vector de salida. Puede hacer esto en la clase SequentialModel en asignación.py.
● batch_step() : [TODO] Verá fit() llamando a esta función para cada lote. Primero calculará las predicciones del modelo para el lote de entrada. Durante la fase de entrenamiento, debe calcular gradientes y actualizar sus pesos de acuerdo con el optimizador que está utilizando. Para la retropropagación durante el entrenamiento, utilizará GradientTape de la abstracción principal (core.py) para registrar operaciones y valores intermedios. Luego, utilizará el optimizador del modelo para aplicar gradientes a las variables entrenables del modelo. Finalmente, calcule y
Devuelve la pérdida y la precisión de este lote. Puede hacer esto en la clase SequentialModel en Assignment.py .
Te animamos a echar un vistazo a keras. SequentialModel en el cuaderno de introducción (exploración de una posible implementación modular: TensorFlow/Keras) y la referencia al laboratorio 3 para tener una idea de cómo podemos usar las cintas de gradiente en el aprendizaje profundo.
7. Función de pérdida
Este es uno de los aspectos más críticos del entrenamiento de modelos. En esta tarea, implementaremos la función de pérdida de error cuadrático medio o MSE. Puede encontrar la función de pérdida en Beras/losses.py .
● forward() : [TODO] Escriba una función que calcule y devuelva la media dado el error cuadrático de las etiquetas predichas y reales.
Sugerencia: ¿Qué es MSE? El error cuadrático medio es la diferencia entre el valor pronosticado y el valor real, dadas las etiquetas pronosticadas y reales.
● input_gradients() : [TODO] Calcular y devolver gradientes. Use una fórmula que derive estos gradientes por diferenciación.
8. Optimizador
En el archivo Beras/optimizer .py , asegúrese de cada tipo diferente de optimizador. El experimento 2 debería ayudar, ¡ buena suerte !
● BasicOptimizer: [TODO] Una estrategia de optimización simple, como se muestra en el Experimento 1.
● RMSProp : [TODO] Raíz cuadrática media de la propagación del error.
● Adam: [TODO] Un optimizador común basado en la estimación de movimiento adaptable.
9. Índice de precisión
Finalmente, para evaluar el rendimiento de su modelo, debe usar una métrica de precisión adecuada. En esta tarea, implementará la evaluación de la precisión de la clasificación en Beras/metrics.py :
● forward() : [TODO] Devuelve las probabilidades predichas de precisión de clasificación del modelo y las etiquetas verdaderas. Debe devolver una etiqueta pronosticada proporcional igual a la etiqueta verdadera, donde la etiqueta pronosticada para la imagen es la etiqueta correspondiente a la probabilidad más alta. ¡Consulte la web o las diapositivas de conferencias para conocer las matemáticas de precisión de clasificación!
10. Entrenamiento y pruebas
Finalmente, usando todas las primitivas anteriores, necesitas construir dos modelos en Assignment.py :
● Un modelo simple en get_simple_model() con una capa de difusión como máximo (p. ej. , densidad - ./layers.py ) y una función de activación (en /activation.py ). Si bien es posible hacerlo, esta opción se le brinda de forma predeterminada. Lo puedes cambiar si quieres. ¡Un calificador automático evaluará el original!
● Un modelo un poco más complejo en get_advanced_model() , con dos o más capas de difusión y dos o más funciones de activación. Recomendamos usar el optimizador de Adam para este modelo con una tasa de aprendizaje bastante baja.
Para cualquier hiperparámetro que utilice (tamaño de capa, tasa de aprendizaje, tamaño de época, tamaño de lote, etc.), codifique estos valores en las funciones get_simple_model() y get_advanced_model() . No los almacene debajo del controlador principal. Una vez que todo esté implementado, use python3 asignación.py para ejecutar su modelado y ver la pérdida/precisión.
11. Visualiza los resultados
Le proporcionamos el método visualize_metrics para visualizar su pérdida y precisión cambiando cada vez que usa matplotlib . No edite esta función. Después de almacenar la pérdida y la precisión, cada lote en esta matriz de funciones debe llamarse en el método principal, que se pasará a esta función. Debe ser una línea con el lote i en el eje horizontal y los valores de pérdida/precisión del lote en el eje vertical. ¡Llamar a esto es opcional! También proporcionamos el método visualize_images para visualizar sus predicciones de las etiquetas verdaderas usando matplotlib . Este método actualmente usa etiquetas de forma [número de imágenes, 1]. No edite esta función. Después de entrenar el modelo, debe llamar a esta función con todas las entradas y etiquetas. La función seleccionará aleatoriamente 500 muestras de su entrada y trazará las 10 clasificaciones correctas y las 10 incorrectas para ayudarlo a interpretar visualmente las predicciones del modelo. Debe realizar la última ejecución después de haber alcanzado un punto de referencia de precisión de prueba en esta acción.
CS1470 Estudiantes
- Completar y enviar el concepto HW2
- Implemente Beras de acuerdo con la especificación y cree un modelo secuencial en asignación.py
- Probar el modelo dentro de main
- Obtenga una precisión de prueba >=85 % en MNIST usando get_simple_model_components predeterminados.
- Completar el cuaderno de exploración.ipny y exportarlo a formato PDF.
- Cuaderno jupyter "HW2 Intro to Beras" para su referencia.
CS2470 Estudiantes
- Además de las mismas tareas que 1470 para completar :
- Implementar la función de activación de Softmax (paso hacia adelante y input_gradient)
- Precisión de la prueba >95 % para el modelo MNIST obtenido de get_advanced_model_components.
- Deberá especificar un modelo multicapa, tendrá que explorar las opciones de hiperparámetros y es posible que desee agregar otras características.
- Otras características pueden incluir regularización, otros esquemas de inicialización de peso, capas de agregación, abandonos, programación de tarifas u omisión de conexiones. Si tienes alguna otra idea, siéntete libre de preguntarle a Ed públicamente y te lo haremos saber, está bien.
- Al implementar estas funciones, intente imitar la API de Keras tanto como sea posible. Esta es una gran ayuda para su cuaderno de exploración.
- Completa 2470 componentes de cuadernos de exploración y preguntas conceptuales.
Compatibilidad de calificación y calificación automática
Concepto: Sus criterios de calificación son principalmente correctos, bien pensados y claros.
Código: se le calificará principalmente en función de la funcionalidad. Su modelo debe tener una precisión que sea al menos mayor que un umbral en los datos de prueba. Para el 1470, esto se puede parametrizar proporcionando un modelo simple. Para el 2470, es posible que deba experimentar con hiperparámetros o desarrollar algunos componentes personalizados. Si bien no obtendrá una puntuación en el estilo del código, no debería tener demasiadas declaraciones de impresión en la confirmación final.
Importante: use operaciones vectorizadas siempre que sea posible y limite la cantidad de bucles for que usa. Si bien no existe un límite de tiempo estricto para ejecutar este trabajo, por lo general debe ser de menos de 3 minutos. El evaluador automático se apagará automáticamente después de 10 minutos. No recibirá métodos que utilicen las funciones de Tensorflow o Keras.
Cuadernos: Los cuadernos de expedición se calificarán manualmente y deberán enviarse en formato pdf. Siéntase libre de usar "del cuaderno al pdf de látex". ipynb "notebooks! Envíe sus tareas a través de Gradescope en los trabajos de proyecto correspondientes comprimiendo su carpeta hw2 (la ruta en Gradescope debe ser hw2/code/filename.py) o a través de GitHub (recomendado). Envíe a través de GitHub, confirme y envíe todos los cambios a su repositorio a GitHub. Puede hacer esto ejecutando los siguientes tres comandos (este es un buen recurso para aprender sobre ellos):
1. git add file1 file2 file3 (or -A)
2. git commit -m “commit message”
3. git push
Después de confirmar y enviar sus cambios a su repositorio (puede verificar en línea si no está seguro de si funciona), ¡ahora puede cargar el repositorio en Gradescope! Si prueba su código en varias ramas, puede elegir la rama que desee. .
¡importante!
1. Asegúrese de que todos los archivos estén en hw2/code. De lo contrario, el clasificador automático fallará.
2. Elimine la carpeta de datos antes de comprimir el código.
3. Agregue un archivo en blanco llamado 2470student en el directorio hw2/code Este archivo no debe tener extensión y se usa como marcador para calificar las necesidades específicas de 2470. Si no lo haces, ¡perderás puntos!
¡Gracias!