Tutorial de pytorch

PyTorch es una biblioteca de aprendizaje automático de código abierto que se utiliza para Python. El equipo de investigación de inteligencia artificial de Facebook lo creó inicialmente, sirviendo como base para el software Pyro de Uber para la programación probabilística. Es un conjunto de herramientas matemáticas que permite calcular modelos basados ​​en gráficos de contraste de manera efectiva y automática.

Dado que es sencillo y adaptable, la API de Pytorch es popular entre los académicos e investigadores, creando nuevos modelos y aplicaciones de aprendizaje profundo. Debido al uso generalizado, ya existen numerosas extensiones para aplicaciones de nicho, como texto, visión por computadora y datos de audio, y modelos previos a la capacitación potencialmente listos para usar.

Características

Las características clave de Pytorch son:

Fácil de usar

Dado que Pytorch tiene una API intuitiva y depende de Python, se considera relativamente fácil de usar. La ejecución del código se simplifica con este marco.

Uso de Python

Este módulo interactúa sin problemas con el Python Data Science STAC y se considera Pythonic. Como resultado, puede utilizar todas las características y servicios que proporciona el entorno de Python.

Gráficos computacionales

Pytorch ofrece un entorno efectivo para gráficos computacionales dinámicos. Esto permite la modificación de tiempo de ejecución por parte del usuario.

Herramientas y bibliotecas

Una comunidad vibrante de investigadores y creadores ha establecido una red integral de herramientas y bibliotecas para la difusión de Pytorch y el avance de fomento en campos como la visión por computadora y el aprendizaje de refuerzo.

Beneficios de Pytorch

• Es fácil de entender y fácil de codificar porque se basa en Python
• Habilita la depuración simple con herramientas de Python muy queridas
• Pytorch es simple de escala y tiene un excelente soporte en las plataformas en la nube más populares
• Enfoca su pequeña comunidad en código abierto
• Tiene la capacidad de exportar modelos de aprendizaje en el formato común de intercambio de redes neuronales (ONNX) abiertos

Diferencia entre la antorcha y pytorch

Torch (TORCH7) es una biblioteca de aprendizaje automático Freeware y un marco informático científico basado en el lenguaje de programación y generalmente se accede utilizando la interfaz LUA. Ya no se está desarrollando activamente.

Pytorch es la biblioteca basada en una antorcha, ya que es sencillo y adaptable. En Pytorch, "Py" indica la pitón donde la "antorcha" refleja su biblioteca de antorcha anterior.

Cómo instalar pytorch

Recuerde que Python está instalado, particularmente la versión 3.7 o más, antes de configurar Pytorch. Python se puede instalar usando Anaconda. Después de configurar nuestro entorno Python, procederemos a nuestro próximo paso de instalar Pytorch.

Primero, tenemos que crear un entorno virtual para conda en el que queremos instalar todos nuestros paquetes y establecer el entorno.

$ conda create -n pytorch python = 3.7

Conda es un administrador de entornos que lo ayuda a instalar el paquete del programa de aprendizaje automático. Si tiene que trabajar con otra versión de Python, entonces no tiene que cambiar a ella. Conda lo administrará automáticamente. Solo tiene que usar algunos comandos para hacer su entorno de acuerdo con su elección.

Donde Crear es una palabra clave para decirle al compilador que cree un nuevo entorno para Pytorch que usará el "Python 3.Versión de 7 ". Cuando nuestros paquetes se descargan correctamente, le pedirá su permiso para instalarlos o no.

A medida que su entorno se crea con éxito, mostrará la salida, como se muestra en el siguiente fragmento:

Comencemos con la instalación de Pytorch:

Abra el siguiente enlace y vaya al sitio web de Pytorch. Vaya a la pestaña Comenzar y haga clic en Inicio localmente.

https: // pytorch.org/Get-started/localmente/

Se verá una zona como la de la figura debajo. El primer selector será Pytorch Build y Seleccione Estable (1.12.1) De las opciones dadas. Ahora, el segundo campo selector será su elección, y puede seleccionar el sistema operativo según sus requisitos. Seleccionaremos Windows OS de las opciones dadas porque estamos utilizando Windows para realizar nuestras tareas. La tercera pestaña será el paquete. Elegiremos conda de las opciones dadas. Si usamos cualquier otro paquete, seleccionaremos ese paquete.

En la segunda última opción, seleccione el nombre del idioma que está utilizando y, en nuestro caso, eso será Python para que lo seleccionemos de las opciones dadas. Por fin, seleccionaremos la CPU de las opciones dadas porque estamos utilizando la CPU como nuestra plataforma informática. Si estamos utilizando alguna otra plataforma como CUDA, seleccione CUDA.

Después de seleccionar todas las opciones de los selectores dados anteriormente, se mostrará un comando en el campo a continuación. Copie ese comando y ejecute ese comando en su símbolo del sistema Conda.

En el comando anterior, Conda se le instruirá para instalar Pytorch y otras bibliotecas, TorchVision y Torchaudio, donde TorchVision es la biblioteca de Python. Fue diseñado para simplificar las pruebas y estudiar en el campo de la visión por computadora. Tiene arquitecturas modelo, transformaciones de imágenes comunes y otros conjuntos de datos populares para la visión por computadora.

Torchaudio también es un paquete de Pytorch, y fue construido para el procesamiento de audio y señales de computadoras. También tiene conjuntos de datos populares, E/S y transformaciones de audio comunes.

Cuando se descarguen todos nuestros paquetes, le pedirá su permiso si continuará con él o no.

Ahora, pasar a nuestro siguiente paso, active nuestros paquetes de pytorch. Al hacerlo, ejecutaremos el siguiente comando en el símbolo del sistema Anaconda:

$ conda activar pytorch

Ahora, activar nuestros paquetes de Pytorch utilizando el comando mencionado anteriormente en este activado es la palabra clave utilizada para instruir a Conda para activar la biblioteca de pytorch que ya hemos instalado.

Podemos verificar iniciando Python que si se está ejecutando, mostrará la siguiente salida:

Después de eso, tenemos que importar la antorcha en ella; Si muestra un error de módulo no encontrado, esto significa que su instalación no fue correcta. En este caso, la instalación fue correcta, por lo que no mostró ningún error.

Ahora, podemos crear un tensor de antorcha para verificar si funciona correctamente para hacerlo; digamos:

$ x = antorcha.Rand (3)
$ imprime (x)

En el comando anterior, creamos una variable "x" y la asignamos a la antorcha de valor.Rand, donde Rand indica un valor aleatorio. Luego mostramos la salida de la antorcha utilizando la función de impresión y pasándola nuestra variable "x". La siguiente captura de pantalla muestra cómo se muestran los valores del tensor:

Ahora, revisando la versión de la antorcha, importamos la antorcha y, utilizando la función de impresión, pasaremos el valor "Torch__version__" para verificarla.

$ importación de importación
$ imprime (antorcha.__versión__)

Aquí está la salida para el siguiente comando, como se muestra en la figura anterior. Y ahora, nuestro entorno Pytorch se instala correctamente para nuestro uso.

Ciclo de vida del modelo de aprendizaje profundo de Pytorch

Los proyectos que involucran el aprendizaje automático no son simples; implican un ciclo continuo para mejorar los datos, el modelo y la evaluación. Este ciclo es esencial para crear un modelo de aprendizaje automático, ya que enfatiza el uso de la simulación y los resultados para mejorar su conjunto de datos.

Durante más de diez años, el aprendizaje profundo ha sido un tema importante y ha contribuido al mayor enfoque del mercado en ML. El desarrollo de muchas herramientas para ayudar en la producción de modelos ML ha causado que la industria de ML experimente.

5 pasos principales para el ciclo de vida del modelo de aprendizaje profundo son:

1. Preparación de datos
2. Definición modal
3. Entrenando el modal
4. Evaluación modal
5. Fabricación de predicciones

Ejemplo 1

En este ejemplo, utilizaremos la biblioteca TorchVision con un conjunto de datos "FashionMnist" precargado utilizando la Biblioteca TorchVision de Pytorch, que tiene objetos del mundo real.

Cuando se trata de trabajar con datos, Pytorch usa sus dos elementos principales, que son antorcha.tensiones.datos.Dataloader y antorcha.tensiones.datos.Conjunto de datos, lo que nos permite usar sus datos o conjuntos de datos precargados. El cargador de datos envuelve un iterable alrededor del conjunto de datos para facilitar la adquisición de las muestras, que el conjunto de datos utiliza para almacenar las muestras y sus etiquetas relacionadas.

Totensor se utiliza para mejorar las imágenes y la transformación, mientras que el paquete NN especifica una colección de funciones de pérdida práctica que generalmente se emplean. El conjunto de datos de FashionMnist funciona para imágenes con elementos que van desde 0 a 255. También puede escribir transformaciones personalizadas de acuerdo con sus necesidades. Veamos el código de este escenario en la siguiente imagen:

En el código superior, hemos asignado un conjunto de datos de FashionMnist a nuestro entrenamiento_data. Este conjunto de datos asignado a Training_Data consta de muchos datos de visión del mundo real, como CIFAR y Coco. Emplearemos el conjunto de datos FashionMnist en este caso. Todos los conjuntos de datos de Vision de Torce requieren dos parámetros. Uno se transforma y el otro es Target_Transform. Estos dos parámetros modifican las etiquetas y las muestras.

Los resultados que se muestran en la figura adjunta aparecen después de que se ejecuta el código. Comenzará a descargar el conjunto de datos de la biblioteca.

Ahora, el conjunto de datos se descarga después de la ejecución de nuestro código. Pasaremos el conjunto de datos como parámetro a DataLoader. Esto nos ayudará a muestrear, barajar, carga de datos de multiprocesos y lotes automáticamente. En nuestro caso, estamos asignando 64 a nuestro lote_size. Como resultado, estamos definiendo 64 tamaños de lotes. Cada elemento de dataLoader iterable podrá devolver una salida de un lote de 64 etiquetas y características.

Hemos establecido que el tren es verdadero porque establece el módulo. La descarga también está configurada en modo verdadero, porque tenemos que descargar el conjunto de datos para entrenar nuestro módulo con la ayuda de ese conjunto de datos. Hemos pasado datos a nuestro parámetro raíz porque pasaremos la información a nuestro módulo en forma de datos que descargaremos desde el paquete Totensor.

Después de ejecutar nuestro código, podemos ver en nuestra salida que ha imprimido las formas de X e Y de acuerdo con nuestros argumentos anteriores. Descargará las imágenes.

Ahora, avanzando hacia la creación modal, crearemos una clase llamada red neuronal que heredará nn. El módulo es un parámetro. Crearemos una función llamada Init; En esta función, definiremos las capas de la red. A continuación, crearemos una función con el nombre hacia adelante como el nombre aclara su propósito. Indicaremos cómo se transferirán los datos a través de la red en la función de avance.

Linear es una clase de biblioteca nn que aplica una transformación lineal a los datos que le pasamos a él. Pasamos 28*28 como el número de dimensiones a la clase lineal. Relu es una función en los paquetes nn, que maneja los elementos negativos reemplazándolos con 0. Para acelerar todo el proceso para la red neuronal, utilizamos los recursos de nuestra tarjeta gráfica si están disponibles para su utilización. Veamos el código de este escenario en la siguiente imagen fijada:

La función init es el método de inicialización en pytorch. Se requiere dejar que Pytorch obtenga los directorios que contienen bibliotecas. En esto, lo pasamos por autofunción. Mientras que en la función de avance, pasamos los tensores de entrada como parámetros, y la función de avance devuelve los tensores de salida calculando sus tensores de entrada. En esto, pasamos dos parámetros, "yo" y "x", a la función de avance. La función de avance también define cómo funcionará su módulo desde la entrada hasta la salida.

Después de eso, la salida del código anterior aparece en la siguiente captura de pantalla:

Después del proceso que realizamos en los pasos anteriores, capacitaremos a nuestro modelo. Debemos emplear un optimizador y una función de pérdida para lograr esto. Un procedimiento de función de pérdida determina la discrepancia entre la salida de corriente de un algoritmo y la salida anticipada. Optimizer ayuda al sistema a seleccionar la mejor opción de un conjunto de opciones posibles que son fáciles y no explotan las restricciones. Veamos el código de este escenario en la imagen fija que se muestra a continuación:

Epoch es un parámetro que especifica el número de veces que un algoritmo de aprendizaje se ejecutará a través del conjunto de datos que hemos proporcionado para la capacitación. En nuestro caso, lo hemos establecido en 5, lo que significa que pasará por nuestro conjunto de datos 5 veces durante la capacitación.

Después de inicializar las épocas, usaremos un bucle for, que ejecutará la cantidad de veces "t" que hemos declarado en épocas. En este bucle, ejecutará la función entrenada 5 veces y la ejecutará. Después de que se realice la ejecución "para bucle", imprimirá el texto "hecho".

El siguiente fragmento muestra la salida de la función entrenada de épocas:

Ejemplo 2

En este caso, resolver el problema de ajustar y = sin (x) con un polinomio de tercer orden.

Método 1

El paquete óptimo proporcionado por Pytorch se utilizará en esta técnica. "Antorcha.Optim ”es un paquete Pytorch responsable de implementar diferentes técnicas de optimización. La mayoría de las técnicas de uso frecuente ya se implementan, y la interfaz es suficientemente abierta para que la futura integración fácil de las más complejas también sea posible. Cambiando manualmente los tensores que contienen parámetros aprendices con antorcha.Sin graduado, se actualizan los pesos de nuestros modelos ().

También utilizaremos el paquete NN para declarar nuestro modal, pero utilizaremos RMSPOP para optimizar el modelo porque proporciona el paquete de antorcha proporcionado por Optim.

Pasemos a nuestro código para crear un tensor responsable de mantener los datos para la entrada y la salida. En nuestro caso, creamos dos variables, "A" y "B". A continuación, definiremos los tensores de entrada llamados "var" y "myvar", que son tensores de entrada x^, x^2 y x^3.

Después de eso, declararemos funciones modales y de pérdidas utilizando el paquete NN. Cree un optimizador utilizando el paquete óptimo para cambiar los pesos del modelo en nuestro nombre. RMSProp se utilizará en este caso; El paquete óptimo incluye muchas otras técnicas de optimización. La primera entrada del constructor RMSPROP instruye al optimizador en el que los tensores deben modificarse. Cree un optimizador utilizando el paquete óptimo para cambiar los pesos del modelo en nuestro nombre. RMSProp se utilizará en este caso; El paquete óptimo incluye muchas otras técnicas de optimización. El código para la explicación anterior se puede encontrar en la siguiente pantalla Spyder:

Luego, en el siguiente paso, calcularemos el y predicho pasándolo myvar:

$ y_pred = modal (myvar)

En él, y_predicat es la variable a la que asignamos la función modal a la que se pasa el valor "myvar". La pérdida se calculará y se mostrará. Esto es causado por el hecho de que los gradientes se recopilan dinámicamente en buffers siempre que.Backward () se invoca.

pérdida.Backward () determinará el gradiente de pérdida con consideración al modal. Cuando se invoca la función de paso de un optimizador, se actualizan sus parámetros. Las características de entrada de las capas lineales se multiplican por la matriz de peso para generar las características de salida. Las características de entrada se pasan a una capa lineal como un tensor unidimensional que ha sido demolido, y se multiplican por la matriz de peso. Al final del código, mostrará la salida como resultado en la forma de la ecuación.

Método 2

En el siguiente método, utilizaremos paquetes Tensor y Autograd. Primero, importe nuestras bibliotecas de antorcha y matemáticas para este programa y luego defina nuestras variables "dtype". Aquí, asignamos la antorcha de valor.Flotar como se realizó en el ejemplo anterior y definió la variable "dispositivo". Nuevamente asignamos la antorcha de valor.dispositivo ("CPU") que se utiliza para definir la plataforma que se utilizará.

Para mantener las entradas y salidas, cree tensores. Suponiendo que eso requiere Grad = falso, el pase hacia atrás no necesita calcular gradientes sobre estos tensores de forma predeterminada. Hacer pesas con tensores aleatorios. Requerimos cuatro pesos para un polinomio de tercer orden: y = a + b x + c x^2 + d x^3 Demandas de configuración. Deseamos calcular gradientes con respecto a estos tensores durante el pase hacia atrás, que se indica por el valor _grad = verdadero.

Calcular y mostrar pérdida de la pérdida de tensor. La pérdida se convierte en un tensor con la forma (1,) pérdida. El item () devuelve el valor escalar de la pérdida (). El código para la explicación anterior se puede encontrar en la siguiente pantalla Spyder:

En este caso, el pase hacia atrás de nuestra red neuronal debe administrarse manualmente. No es físicamente difícil para la red sencilla de dos capas hacerlo. Sin embargo, puede complicarse rápidamente para grandes redes complejas. Afortunadamente, podemos utilizar la diferenciación automática para mecanizar el proceso de un pase hacia atrás en las redes neuronales. La biblioteca Autograd en Pytorch da esta funcionalidad muy precisamente; Mientras usa Autograd, el pase hacia adelante de una red caracterizará un gráfico computacional. El gráfico tendrá nodos y bordes; Los tensores se representan utilizando nodos, y los bordes representan los métodos que devolverán los tensores de salida tomando tensores de entrada como argumentos.

Leer este gráfico ayuda a calcular los gradientes fácilmente. Esto parece una tarea difícil, pero en realidad, esta práctica es muy simple y directa. Si "x" es un tensor y el atributo "requiere graduación" se establece en verdadero. Por lo tanto, X es un tensor que aborda un nodo en un gráfico computacional. X.Grad es otro tensor que tiene una pendiente de "x" para un valor escalar. Aquí, demostramos ajustar una onda sinuso. Ahora, no hay necesidad de que ejecutemos manualmente la pausa hacia atrás a través de la red.

Método 3

En este ejemplo, usaremos el módulo Numpy. Numpy es una biblioteca de Python para el lenguaje de programación que admite matrices y matrices multidimensionales sustanciales. Además, una cantidad significativa de operaciones matemáticas de alto nivel para operar en estas matrices. Numpy es una plataforma genérica para calcular las operaciones científicas; no implica aprendizaje profundo o calculación de gráficos.

Usando operaciones numpy, podemos ajustar fácilmente un polinomio de tercer orden en una función de "pecado". Para hacerlo, primero importaremos bibliotecas numpy y matemáticas. Matemáticas es el paquete que se utiliza para importar operaciones matemáticas. Veamos el código de este escenario en la siguiente imagen:

Primero inicializamos dos variables llamadas "VAR1" y "VAR2" y asignamos sus funciones. Aquí, np.La función de Linspace es un método de Python que nos ayuda a crear secuencias numéricas. Nos ayuda a generar vectores espaciados lineales. Es lo mismo que el signo de colon, pero la única diferencia entre el signo de colon y es que nos proporciona un control directo sobre el número de puntos. A esta función, pasamos tres parámetros que son "-math.Pi "," Matemáticas.PI "y" 200 ", en los cuales 200 es el rango del cálculo se realizará. Y la segunda función que pasamos a VAR2 es "NP.sin (var1) ", que se usa para calcular el seno de los valores que se almacenarán en" Var1 ".

A continuación, inicializamos cuatro variables llamadas "A", "B", "C" y "D" a estas variables, pasamos valores aleatorios. A continuación, inicializamos un bucle for al que pasamos la variable "t", lo que indica el tiempo y el rango a 200.

Después de eso, defina otra variable, "var2_pred", a la que asignaremos la operación matemática para calcular el agregado y luego pasarla a la variable llamada "pérdida". La pérdida será responsable de calcular la pérdida de var "var2_pred".

Pasando al siguiente paso, donde utilizamos la instrucción IF, que será responsable de calcular el cálculo de "t%10 == 9", tomará el modo de "t" con el valor 10 y lo incrementará en 9. Imprimirá la pérdida de estos valores obtenidos de la declaración anterior si.

Después de todos estos cálculos donde finaliza el bucle for, resumirá los valores completos, y la última operación de impresión se calculará al final del bucle for y se mostrará como resultado, como se muestra en el fragmento a continuación:

Método 4

En este código, usaremos el paquete tensor. Una matriz numpy y un tensor Pytorch son teóricamente equivalentes porque un tensor es una matriz multidimensional, y Pytorch ofrece una variedad de métodos para trabajar con ellos. Los tensores son una herramienta de computación científica de uso general que puede monitorear los gradientes y los gráficos computacionales en segundo plano. Los tensores de Pytorch pueden usar GPU para acelerar sus operaciones numéricas, a diferencia de Numpy. Se puede ejecutar un tensor de pytorch en una GPU en algunos pasos fáciles.

En este código, importamos dos bibliotecas, antorcha y matemáticas. Como utilizaremos una antorcha en este código y funcionalidades matemáticas, definimos una variable llamada "dtype". Asignamos la antorcha de los tipos de datos.Flotar porque estamos realizando operaciones matemáticas que devolverán los valores en los puntos. Para almacenar valores decimales, usamos DataType Float.

Luego declaramos otra variable llamada "dispositivo" con asignación de antorcha de valor.Dispositivo ("CPU") porque seleccionamos CPU como nuestra plataforma en la instalación de Pytorch. Avanzando, hemos inicializado dos variables llamadas VAR1 "y" VAR2 "y les asignamos la misma función que asignamos en el ejemplo anterior. Luego, la creación de cuatro variables que son "A", "B", "C" y "D" se están utilizando para crear tensores aleatorios. Cada uno tiene su forma única; También hemos pasado el dispositivo de tipo de datos y DTYPE, que se inicializarán al comienzo de nuestro código. Por lo tanto, utilizará los recursos de nuestra CPU y tomará valores en forma de decimales. Se indica que tenemos la intención de calcular los gradientes sobre tales tensores durante el pase inverso al afirmar que requiere grader = verdadero. Veamos el código de este escenario en la siguiente imagen fijada:

Luego declaramos un aprendizaje_rate = 1e-6. La tasa de aprendizaje también es un hiperparámetro utilizado para la capacitación de redes neuronales. Tiene un valor muy pequeño que debe ser mayor que 0.0 y menos de 1.0, lo que significa que debe ser un valor positivo. El ritmo de aprendizaje aumenta con la tasa de aprendizaje creciente.

Después de eso, abriremos un bucle que se ejecutará 200 veces y realizará operaciones matemáticas en nuestras variables. Dondequiera que T%100 se vuelva igual a 99, el bucle imprimirá el número de veces que se ejecuta y se detendrá. Después de eso, el resultado se publicará a medida que termine nuestra iteración, como se muestra en la siguiente captura de pantalla:

Método 5

En este método, crearemos nuestra función Autograd usando las subclases Pytorch. Cada autogrado primario son dos métodos que operan en tensores. La función de avance toma tensores de entrada y calcula los tensores de salida de ellos. En Pytorch, sin duda podemos caracterizar a nuestro operador de Autogrado describiendo una subclase.autogrado.función y ejecución de los enfoques hacia adelante y hacia atrás.

Ahora, los tensores de salida se están obteniendo como parámetros para las funciones hacia atrás con algunos valores escalares. Pytorch nos facilita a definir nuestro operador de Autogrado al permitirnos crear una subclase que analice el gradiente de los tensores de entrada con alusión a los mismos valores escalares. Ahora, podemos usar nuestro operador Autograd inicializando un constructor y llamándolo un método. Luego pasaremos el tensor con los datos de entrada como parámetro a ese constructor.

En el siguiente ejemplo, especificamos nuestro modal como:

$ y = a+b p_3 (c+dx)
y = a+bp3 (c+dx)
en lugar de
y = a+bx+cx^2+dx^3
y = a+bx+cx2+dx3

Componemos nuestro método Autograd personalizado procesando el avance y el retroceso de P3 y utilizándolo para ejecutar nuestro modelo. El código para la siguiente explicación se puede encontrar en la pantalla Spyder.

Al subclasificar la antorcha, podemos implementar nuestras funciones únicas de Autograd.autogrado. Por lo tanto, funcionando y poniendo en práctica los pases hacia adelante y hacia atrás que usan tensores. Obtenemos un tensor que mantiene la entrada durante el pase hacia adelante y entregamos un tensor que contiene la salida hacia atrás. Se puede usar un objeto de contexto llamado CTX para almacenar datos para su uso en el cálculo hacia atrás.

Se pueden crear tensores para almacenar entrada y salida. Suponiendo que eso requiere Grad = falso, el pase hacia atrás no necesita calcular gradientes sobre estos tensores de forma predeterminada.

Hacer pesas con tensores aleatorios. Para garantizar la convergencia, los pesos para este ejemplo deben introducirse razonablemente cerca del resultado preciso: y = a + b * p3 (c + d * x). Se indica que tenemos la intención de generar un gradiente sobre estas asignaciones durante un pase hacia atrás mediante la configuración que requiere Grad = verdadero.

La siguiente imagen demuestra la salida que generó el código anterior:

Método 6

Aquí, usaremos en el módulo para resolver este problema. Después de importar nuestras bibliotecas deseadas, antorcha y matemáticas, declararemos tensores para asignar entradas y salidas. Este ejemplo puede considerarse una red neuronal de capa lineal ya que la salida resultante es una función lineal de (x, x2, x3). Vamos a ver el código de este escenario es la siguiente imagen fijada:

Vamos a preparar el tensor (x, x2, x3). Ya que p tiene forma (3) y x.Unsqueeze (-1) tiene estructura (200, 1), la semántica de transmisión se utilizará para producir un tensor de forma en esta situación (200, 3). Para construir nuestro modelo como una serie de capas, use el paquete NN. NN es un módulo que aplica otros módulos secuencialmente para obtener su salida, conocido como un módulo secuencial. El módulo lineal mantiene tensores internos para su sesgo y peso y utiliza una función lineal para calcular la salida de la entrada. Para calcular el pase hacia atrás, use Autograd.

a.Grad, B.Grad seguirá esta llamada. Los tensores que tienen el gradiente de una pérdida sobre las letras A, B, C y D se designan como C.Grad y D.Grad, respectivamente. Utilizamos el error medio cuadrado (MSE) como nuestra función de pérdida, que se define en el paquete NN junto con otras funciones de pérdida prominentes.

Pase hacia adelante: dando al Modelo X, calcule la anticipada Y. El operador __call__ se extiende por objetos de módulo, lo que le permite llamarlos como funciones. Al hacerlo, proporciona al módulo un tensor de los datos de entrada, y devuelve un tensor de la salida esperada. Duplicar e imprimir la función La función de pérdida proporciona un tensor que contiene la pérdida después de recibir tensores de nosotros que contienen los valores verdaderos y anticipados de y.

Calcule el gradiente de una pérdida sobre cada parámetro de modelo aprendible durante el pase hacia atrás. Debido al almacenamiento interno de las características de cada módulo en tensores que requieren un conjunto de graduación en verdadero, esta función calculará los gradientes para todos los parámetros del modelo aprendible. Puede acceder a la capa inicial del modelo seleccionando el primer elemento de una lista.

Por último, el resultado se muestra utilizando la función de impresión cuando toda la iteración se ejecuta correctamente.

Método 7

Antorcha.El módulo NN es generalmente el principal bloque de construcción de Pytorch. Primero, defina un nn.Objeto de módulo, y luego llame a su función de reenvío para ejecutarlo. Este método de operación está orientado a objetos. Una red Relu completamente conectada incluye una capa oculta entrenada para pronosticar y desde x reduciendo la distancia euclidiana al cuadrado.

En este caso, el modelo se define como una subclase de módulo específico. Debe definir su modelo de esta manera en cualquier momento que desee que sea más complejo que una lista directa de todos los módulos existentes actualmente. El código para la explicación anterior se puede encontrar en la siguiente pantalla Spyder:

Luego calcule el pase hacia atrás usando Autograd. El método determinaría el gradiente de pérdida para todos los tensores con graduación requerida = verdadero. A.Grad, B.Grad seguirá esta llamada. Los tensores que sostienen el gradiente de la pérdida sobre las letras A, B, C y D se designan como C.Grad y D.Grad, respectivamente. También podemos definir una función personalizada en Pytorch.

Después de crear class Polynomial3, declararemos tensores para mantener la entrada y la salida. Se crean y asignan cuatro argumentos como parámetros miembros en la función. Cuando se usa con módulos, la subclase de tensores conocidos como parámetro tiene una propiedad altamente única. Cuando se asigna como atributos del módulo, el parámetro se incluye automáticamente en la lista de los parámetros del módulo y aparecerá en la lista de parámetros del módulo, e.gramo., en parámetros () iterador. El método de parámetros () en cada nn.El módulo recupera las variables entrenables del módulo. Estas variables deben definirse explícitamente.

La función de reenvío requiere un tensor de datos de entrada y un tensor de datos de salida. Podemos aplicar operadores arbitrarios a los tensores y módulos definidos en el constructor. Construir un optimizador y nuestra función de pérdida. Los parámetros capacitables, que son miembros del modelo y se especifican con la antorcha.nn.El parámetro en el constructor SGD se incluiría en la llamada al modelo.Parámetros (). Luego, en el pase hacia adelante, calcule el predicho y (y_pred) y pase la variable "var".Al final, los gradientes cero realizarán automáticamente el pase hacia atrás y ejecutarán los pesos.

El descenso de gradiente estocástico (SGD) es un optimizador que pertenece a la familia de descenso de gradiente y es una técnica de optimización bien conocida utilizada en el aprendizaje profundo y el aprendizaje automático. El término "estocástico" se refiere a un sistema junto con una probabilidad aleatoria en el optimizador SGD.

En última instancia, calcularemos la pérdida e la imprimiremos asignándole la función de criterio responsable del cálculo de la pérdida. Pasamos la predicción y el modal que entrenamos. Luego, declare la declaración de IF que está calculando el modo por 10 de los valores variables "t". A continuación, lo incrementará en las 9, y el valor resultante de t se pasa a la función de impresión a la que se calculará la pérdida.

Al final del código, el resultado se ejecutará con éxito, como se muestra en la siguiente figura:

Conclusión

La aplicación de la API de Pytorch para actividades típicas de creación de modelos de aprendizaje profundo es el objetivo central del tutorial. La información que ha estudiado en este artículo debería hacer que sea más fácil poner los conceptos sofisticados de Pytorch en los que pueda haber pensado y aprender módulos de Pytorch de la instalación básica del Pytorch en Python a la capacitación compleja de un modelo. También hemos discutido las diferentes formas de implementar un solo ejemplo utilizando diferentes módulos, numpy, antorcha tensor, antorcha y autogrado, estableciendo una nueva función de autogrado, función óptima, módulos nn y también el módulo nn personalizado NN personalizado. La plataforma utilizada para ejecutar nuestro código es Spyder; Puede usar otras plataformas, como Conda, Júpiter y Linux.