registro de instalación del entorno de la versión CUDA del marco de aprendizaje profundo de pytorch - exagerado - resuelve una ecuación no lineal

I. Introducción

En el mundo del aprendizaje profundo, cada vez más personas usan el marco pytorch. Ya sea que se trate de visión artificial CV, NLP o procesamiento de lenguaje natural, muchos modelos grandes convencionales, como los modelos GPT, también usan pytorch. Por ejemplo, el modelo GPT independiente chatGLM de la Universidad de Tsinghua utiliza la versión GPU de pytorch. Cuando usé keras antes, instalé pytorch por primera vez y registré los pasos de instalación para futuras referencias.

2. Pasos de instalación

paso 1. Instalar el controlador de gráficos

La tarjeta gráfica es principalmente una tarjeta gráfica Nvidia. Según el modelo de la tarjeta gráfica, vaya al sitio web oficial de NVIDIA para descargar e instalar

paso 2. Instalar cuda

Este paso también es el mismo, vaya a la página relacionada con cuda del sitio web oficial para descargar la tarjeta gráfica correspondiente y la versión del sistema operativo:

descargué 12.1
e hice doble clic para instalarlo después de la descarga, al igual que el software normal.

paso 3. Instalar cuDNN

Este paso también es el mismo, vaya a la página correspondiente de cuDNN en el sitio web oficial para descargar la versión de la tarjeta gráfica y el sistema operativo correspondientes:

la primera vez que ingrese aquí, es posible que deba registrar una cuenta personal, que es un poco laborioso, solo siga la guía para registrarse.
Después del registro, elija la versión del sistema operativo que más le convenga para descargar.
Después de la descarga, descomprima algunas carpetas:

busque el directorio de instalación de cuda y reemplace la carpeta correspondiente.

Verifique que cuDNN esté instalado, abra cmd, ingrese

cd C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\extras\demo_suite
y ejecuta el comando:
widthTest.exe

aparece PASS, lo que significa éxito

paso 4. Instalar el entorno pytorch

Si la velocidad de la red es rápida, puede instalar el sitio web oficial de pytorch para explicar la instalación (no recomendado):

debido a que el tamaño de la antorcha es un poco grande, debido a la red y otras razones, la descarga a través del comando pip puede agotarse, lo mejor es ir a la página web correspondiente para descargar manualmente el módulo correspondiente, que involucra principalmente tres módulos Three: torch, torchvision, torchaudio.
Se deben seleccionar las versiones compatibles correspondientes de estos tres módulos. A continuación se muestra la relación correspondiente entre la versión de torch y torchvision y torchaudio respectivamente: el


método de instalación más seguro es descargar estos tres archivos sin conexión primero. La URL es: enlace de descarga sin conexión
aquí, Lo descargué arriba La versión de cuda es 12.1, y no hay una versión igual, así que descargué la versión más alta 11.8 (es decir, la que comienza con cu118): por ejemplo: cu118/torch-2.0.0%2Bcu118-
cp39- cp39-win_amd64.whl
cu118— —representa la versión de cuda 11.8
torch-2.0.0—representa la versión 2.0.0
cp39—representa la versión de python 3.9
win_amd64—representa Windows de 64 bits

Las versiones de torchvision y torchaudio correspondientes a la tabla de búsqueda son: 0.15.1 y 2.0.1

Después de descargar los tres archivos sin conexión, ingrese al directorio donde se encuentran los archivos e instálelos a través del comando pip install ( pip install torch-2.0 .0+cu118-cp39-cp39- win_amd64.whl torchaudio-2.0.1+cu118-cp39-cp39-win_amd64.whl torchvision-0.15.1+cu118-cp39-cp39-win_amd64.whl), la instalación se completa en un Poco:

3. Usar pytorch para resolver un sistema de ecuaciones no lineales

Usando el marco de computación gráfica de pytorch y el mecanismo de retropropagación, es fácil resolver ecuaciones no lineales. Por supuesto, aquí hay un mazo:

import torch

# Define the equations as functions
def f1(x, y):
    return x**2 + y**2 - 1

def f2(x, y):
    return x - y**2

# Define the variables
x = torch.tensor([1.0], requires_grad=True)
y = torch.tensor([1.0], requires_grad=True)

# Define the optimizer
optimizer = torch.optim.Adam([x, y], lr=0.1)

# Define the loss function
def loss_fn(x, y):
    return f1(x, y)**2 + f2(x, y)**2

# Train the model
for i in range(1000):
    optimizer.zero_grad()
    loss = loss_fn(x, y)
    loss.backward()
    optimizer.step()

# Print the results
print("x: ", x.item())
print("y: ", y.item())

Siento que esto se puede diseñar, siempre que se enumeren las ecuaciones, se pueden resolver mediante un método similar al anterior.
Funciona de la siguiente manera (error muy pequeño):