Ciencia de los datos

Tutorial de PyTorch con regresión lineal

Tutorial de PyTorch con regresión lineal
PyTorch es un paquete científico basado en Python que reemplaza los ndarrays de NumPy como tensores y aprovecha al máximo las GPU. Otro punto positivo sobre el marco de PyTorch es la velocidad y flexibilidad que proporciona durante la informática. PyTorch es una alternativa eficiente de trabajar con tensores usando Tensorflow que estudiamos anteriormente.

PyTorch tiene algunas grandes ventajas como paquete de cálculo, como:

PyTorch es adoptado principalmente por la comunidad de ciencia de datos debido a su capacidad para definir convenientemente redes neuronales. Veamos este paquete computacional en acción en esta lección.

Instalación de PyTorch

Solo una nota antes de comenzar, puede usar un entorno virtual para esta lección que podemos realizar con el siguiente comando:

python -m virtualenv pytorch
fuente pytorch / bin / activar

Una vez que el entorno virtual está activo, puede instalar la biblioteca PyTorch dentro del entorno virtual para que los ejemplos que creamos a continuación se puedan ejecutar:

pip instalar pytorch

Usaremos Anaconda y Jupyter en esta lección. Si desea instalarlo en su máquina, consulte la lección que describe “Cómo instalar Anaconda Python en Ubuntu 18.04 LTS ”y comparta sus comentarios si tiene algún problema. Para instalar PyTorch con Anaconda, use el siguiente comando en la terminal de Anaconda:

conda install -c pytorch pytorch

Vemos algo como esto cuando ejecutamos el comando anterior:

Una vez que todos los paquetes necesarios están instalados y listos, podemos comenzar a usar la biblioteca PyTorch con la siguiente declaración de importación:

antorcha de importación

Comencemos con ejemplos básicos de PyTorch ahora que tenemos los paquetes de requisitos previos instalados.

Introducción a PyTorch

Como sabemos que las redes neuronales se pueden estructurar fundamentalmente como Tensors y PyTorch se construye alrededor de tensores, tiende a haber un aumento significativo en el rendimiento. Comenzaremos con PyTorch examinando primero el tipo de tensores que proporciona. Para comenzar con esto, importe los paquetes necesarios:

antorcha de importación

A continuación, podemos definir un tensor no inicializado con un tamaño definido:

x = antorcha.vacío (4, 4)
print ("Tipo de matriz: ".formato (x.tipo)) # tipo
print ("Forma de matriz: ".formato (x.forma)) # forma
imprimir (x)

Vemos algo como esto cuando ejecutamos el script anterior:

Acabamos de crear un tensor no inicializado con un tamaño definido en el script anterior. Para reiterar de nuestra lección de Tensorflow, Los tensores se pueden denominar matriz n-dimensional que nos permite representar datos en dimensiones complejas.

Ejecutemos otro ejemplo en el que inicializamos un tensor Torched con valores aleatorios:

random_tensor = antorcha.rand (5, 4)
imprimir (tensión_aleatoria)

Cuando ejecutamos el código anterior, veremos un objeto tensor aleatorio impreso:

Tenga en cuenta que la salida para el tensor aleatorio anterior puede ser diferente para usted porque, bueno, es aleatorio !

Conversión entre NumPy y PyTorch

NumPy y PyTorch son completamente compatibles entre sí. Por eso, es fácil transformar matrices NumPy en tensores y viceversa. Además de la facilidad que proporciona la API, probablemente sea más fácil visualizar los tensores en forma de matrices NumPy en lugar de tensores, o simplemente llámelo mi amor por NumPy!

Por ejemplo, importaremos NumPy en nuestro script y definiremos una matriz aleatoria simple:

importar numpy como np
matriz = np.aleatorio.rand (4, 3)
transformado_tensor = antorcha.from_numpy (matriz)
imprimir (" \ n".formato (tensión_transformada))

Cuando ejecutamos el código anterior, veremos el objeto tensor transformado impreso:

Ahora, intentemos convertir este tensor nuevamente en una matriz NumPy:

numpy_arr = transform_tensor.numpy ()
imprimir (" \ n".formato (tipo (numpy_arr), numpy_arr))

Cuando ejecutamos el código anterior, veremos la matriz NumPy transformada impresa:

Si miramos de cerca, incluso la precisión de conversión se mantiene al convertir la matriz en un tensor y luego volver a convertirla en una matriz NumPy.

Operaciones de tensor

Antes de comenzar nuestra discusión sobre las redes neuronales, debemos conocer las operaciones que se pueden realizar en los tensores mientras entrenamos las redes neuronales. También haremos un uso extensivo del módulo NumPy.

Cortar un tensor

Ya hemos visto cómo hacer un nuevo tensor, hagamos uno ahora y rodaja eso:

vector = antorcha.tensor ([1, 2, 3, 4, 5, 6])
imprimir (vector [1: 4])

El fragmento de código anterior nos proporcionará el siguiente resultado:

tensor ([2, 3, 4])

Podemos ignorar el último índice:

imprimir (vector [1:])

Y también recuperaremos lo que se esperaba con una lista de Python:

tensor ([2, 3, 4, 5, 6])

Hacer un tensor flotante

Hagamos ahora un tensor flotante:

float_vector = antorcha.FloatTensor ([1, 2, 3, 4, 5, 6])
imprimir (float_vector)

El fragmento de código anterior nos proporcionará el siguiente resultado:

tensor ([1., 2., 3., 4., 5., 6.])

El tipo de este tensor será:

imprimir (float_vector.dtype)

Devuelve:

antorcha.float32

Operaciones aritméticas sobre tensores

Podemos agregar dos tensores como cualquier elemento matemático, como:

tensor_1 = antorcha.tensor ([2, 3, 4])
tensor_2 = antorcha.tensor ([3, 4, 5])
tensor_1 + tensor_2

El fragmento de código anterior nos dará:

Podemos multiplicar un tensor con un escalar:

tensor_1 * 5

Esto nos dará:

Podemos realizar un producto escalar entre dos tensores también:

d_product = antorcha.punto (tensor_1, tensor_2)
d_product

El fragmento de código anterior nos proporcionará el siguiente resultado:

En la siguiente sección, veremos una dimensión superior de tensores y matrices.

Multiplicación de matrices

En esta sección, veremos cómo podemos definir métricas como tensores y multiplicarlas, tal como solíamos hacer en matemáticas de secundaria.

Definiremos una matriz para comenzar con:

matriz = antorcha.tensor ([1, 3, 5, 6, 8, 0]).ver (2, 3)

En el fragmento de código anterior, definimos una matriz con la función tensorial y luego la especificamos con ver función que debe hacerse como un tensor bidimensional con 2 filas y 3 columnas. Podemos proporcionar más argumentos a la vista función para especificar más dimensiones. Solo tenga en cuenta que:

recuento de filas multiplicado por recuento de columnas = recuento de elementos

Cuando visualicemos el tensor bidimensional anterior, veremos la siguiente matriz:

Definiremos otra matriz idéntica con una forma diferente:

matrix_b = antorcha.tensor ([1, 3, 5, 6, 8, 0]).ver (3, 2)

Finalmente podemos realizar la multiplicación ahora:

antorcha.matmul (matriz, matriz_b)

El fragmento de código anterior nos proporcionará el siguiente resultado:

Regresión lineal con PyTorch

La regresión lineal es un algoritmo de aprendizaje automático basado en técnicas de aprendizaje supervisado para realizar análisis de regresión en variables independientes y dependientes. Confundido ya? Definamos la regresión lineal en palabras simples.

La regresión lineal es una técnica para averiguar la relación entre dos variables y predecir cuánto cambio en la variable independiente causa cuánto cambio en la variable dependiente. Por ejemplo, el algoritmo de regresión lineal se puede aplicar para averiguar cuánto aumenta el precio de una casa cuando su área aumenta en un cierto valor. O, cuántos caballos de fuerza hay en un automóvil en función del peso del motor. El segundo ejemplo puede sonar extraño, pero siempre puede probar cosas raras y quién sabe si puede establecer una relación entre estos parámetros con Regresión lineal!

La técnica de regresión lineal generalmente usa la ecuación de una línea para representar la relación entre la variable dependiente (y) y la variable independiente (x):

y = m * x + c

En la ecuación anterior:

Ahora que tenemos una ecuación que representa la relación de nuestro caso de uso, intentaremos configurar algunos datos de muestra junto con una visualización de la gráfica. Aquí están los datos de muestra para los precios de la vivienda y sus tamaños:

house_prices_array = [3, 4, 5, 6, 7, 8, 9]
house_price_np = np.matriz (matriz_precios_casa, dtype = np.float32)
house_price_np = house_price_np.remodelar (-1,1)
house_price_tensor = Variable (antorcha.from_numpy (house_price_np))
house_size = [7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
house_size_np = np.array (tamaño_casa, dtype = np.float32)
house_size_np = house_size_np.remodelar (-1, 1)
house_size_tensor = Variable (antorcha.from_numpy (house_size_np))
# visualicemos nuestros datos
importar matplotlib.pyplot como plt
plt.dispersión (matriz_precios_casa, tamaño_casa_np)
plt.xlabel ("Precio de la casa $")
plt.ylabel ("Tamaños de la casa")
plt.title ("Precio de la casa en $ VS Tamaño de la casa")
plt

Tenga en cuenta que hicimos uso de Matplotlib, que es una excelente biblioteca de visualización. Lea más sobre esto en el tutorial de Matplotlib. Veremos el siguiente gráfico una vez que ejecutemos el fragmento de código anterior:

Cuando hacemos una línea a través de los puntos, puede que no sea perfecta, pero aún así es suficiente para el tipo de relación que tienen las variables. Ahora que hemos recopilado y visualizado nuestros datos, queremos hacer una predicción de cuál será el tamaño de la casa si se vendiera por $ 650,000.

El objetivo de aplicar la regresión lineal es encontrar una línea que se ajuste a nuestros datos con un error mínimo. Aquí están los pasos que realizaremos para aplicar el algoritmo de regresión lineal a nuestros datos:

  1. Construir una clase para regresión lineal
  2. Definir el modelo de esta clase de regresión lineal
  3. Calcular el MSE (error cuadrático medio)
  4. Realice la optimización para reducir el error (SGD i.mi. descenso de gradiente estocástico)
  5. Realizar retropropagación
  6. Finalmente, haz la predicción

Comencemos a aplicar los pasos anteriores con las importaciones correctas:

antorcha de importación
de la antorcha.variable de importación autograd
antorcha de importación.nn como nn

A continuación, podemos definir nuestra clase de regresión lineal que hereda del módulo de red neuronal PyTorch:

clase LinearRegression (nn.Módulo):
def __init __ (self, input_size, output_size):
# super función hereda de nn.Módulo para que podamos acceder a todo desde nn.Módulo
super (LinearRegression, self).__en eso__()
# Función lineal
uno mismo.lineal = nn.Lineal (input_dim, output_dim)
def adelante (yo, x):
Regresar.lineal (x)

Ahora que estamos listos con la clase, definamos nuestro modelo con un tamaño de entrada y salida de 1:

input_dim = 1
output_dim = 1
modelo = LinearRegression (input_dim, output_dim)

Podemos definir el MSE como:

mse = nn.MSELoss ()

Estamos listos para definir la optimización que se puede realizar en la predicción del modelo para obtener el mejor rendimiento:

# Optimización (encuentre parámetros que minimicen el error)
tasa_de_aprendizaje = 0.02
optimizador = antorcha.optim.SGD (modelo.parámetros (), lr = tasa_de_aprendizaje)

Finalmente podemos hacer un gráfico para la función de pérdida en nuestro modelo:

loss_list = []
iteration_number = 1001
para iteración en rango (iteration_number):
# realizar optimización con gradiente cero
optimizador.zero_grad ()
resultados = modelo (house_price_tensor)
loss = mse (resultados, house_size_tensor)
# calcular la derivada retrocediendo
pérdida.hacia atrás()
# Actualizando parámetros
optimizador.paso()
# pérdida de tienda
lista_perdidas.añadir (pérdida.datos)
# pérdida de impresión
si (iteración% 50 == 0):
print ('época , pérdida '.formato (iteración, pérdida.datos))
plt.plot (rango (número_de_ iteración), lista_pérdidas)
plt.xlabel ("Número de iteraciones")
plt.ylabel ("Pérdida")
plt

Realizamos optimizaciones varias veces en la función de pérdida e intentamos visualizar cuánto aumentó o disminuyó la pérdida. Aquí está la trama que es la salida:

Vemos que a medida que aumenta el número de iteraciones, la pérdida tiende a cero. Esto significa que estamos listos para hacer nuestra predicción y trazarla:

# predecir el precio de nuestro coche
predicted = model (house_price_tensor).datos.numpy ()
plt.scatter (house_prices_array, house_size, label = "datos originales", color = "rojo")
plt.scatter (house_prices_array, predicted, label = "predicted data", color = "blue")
plt.leyenda()
plt.xlabel ("Precio de la casa $")
plt.ylabel ("Tamaño de la casa")
plt.título ("Valores originales frente a valores previstos")
plt.show()

Aquí está la trama que nos ayudará a hacer la predicción:

Conclusión

En esta lección, analizamos un excelente paquete de cálculo que nos permite hacer predicciones más rápidas y eficientes y mucho más. PyTorch es popular por la forma en que nos permite gestionar las redes neuronales de forma fundamental con Tensors.

El botón central del mouse no funciona en Windows 10
La botón central del ratón le ayuda a desplazarse por páginas web largas y pantallas con una gran cantidad de datos. Si eso se detiene, bueno, termina...
Cómo cambiar los botones izquierdo y derecho del mouse en una PC con Windows 10
Es una norma que todos los dispositivos de mouse de computadora estén diseñados ergonómicamente para usuarios diestros. Pero hay dispositivos de mouse...
Emule los clics del mouse colocando el mouse con Clickless Mouse en Windows 10
El uso excesivo de un mouse o teclado en una postura incorrecta puede provocar muchos problemas de salud, como tensión, síndrome del túnel carpiano y ...