¡Ayuda al desarrollo del sitio, compartiendo el artículo con amigos!
Introducción a la GPU PyTorch
Como PyTorch ayuda a crear muchos marcos de aprendizaje automático donde los cálculos científicos y de tensor se pueden realizar fácilmente, es importante usar la Unidad de procesamiento de gráficos o GPU en PyTorch para habilitar el aprendizaje profundo donde los trabajos se pueden completar de manera eficiente. Además, la memoria en el sistema se puede manipular y modificar fácilmente para almacenar varios cálculos de procesamiento y, por lo tanto, los gráficos computacionales se pueden dibujar fácilmente con una interfaz bastante simple.
¿Qué es la GPU PyTorch?
GPU ayuda a realizar una gran cantidad de cálculos en un formato paralelo para que el trabajo se complete más rápido. Las operaciones se llevan a cabo en forma de cola para que los usuarios puedan ver operaciones síncronas y asíncronas donde los datos se copian simultáneamente entre la CPU y la GPU o entre dos GPU. La cola garantiza que las operaciones se realicen de forma síncrona y que se realicen operaciones paralelas. Las operaciones de GPU cruzadas no se pueden realizar en PyTorch.
¿Cómo usar la GPU PyTorch?
El paso inicial es verificar si tenemos acceso a la GPU.
importar antorcha
antorcha.cuda.is_disponible()
El resultado debe ser verdadero para trabajar en GPU. Entonces, el siguiente paso es asegurarse de que las operaciones estén etiquetadas en GPU en lugar de trabajar con CPU.
Un_tren=antorcha.FloatTensor((4., 5., 6.)) A_tren.is_cuda Podemos usar una API para transferir tensores de la CPU a la GPU, y esta lógica también se sigue en los modelos.
A_train=A_train.to(device) A_train.is_cuda Model_trial=MyModel(args) Model_trial.to(device) El dispositivo es una variable inicializada en PyTorch para que pueda usarse para mantener el dispositivo donde se realiza el entrenamiento en CPU o GPU.
"device=torch.device(cuda:4 if torch.cuda.is_available() else cpu) print(device) El paquete torch.cuda admite tipos de tensor CUDA pero funciona con cálculos de GPU. Por lo tanto, si se usa GPU, es común usar CUDA. torch.cuda.current_device() torch.cuda.device_count() torch.cuda.get_device_name(0) "
Ejemplo de GPU PyTorch
Se prefieren las GPU a las numpy debido a la velocidad y la eficiencia computacional donde se pueden calcular varios datos junto con gráficos en unos pocos minutos. Si tenemos el dispositivo adecuado, es fácil vincular GPU y trabajar en el mismo. Los pases hacia adelante y hacia atrás deben implementarse en la red para que los cálculos se realicen más rápido.
"importar antorcha importar tipo_datos matemáticos=antorcha.flotador dispositivo=antorcha.dispositivo(cpu) dispositivo=antorcha.dispositivo(cuda:0) x=antorcha.linspace(-math.pi, math.pi, 1500, dispositivo=dispositivo, dtipo=tipo_datos) y=antorcha.sin(x) a=antorcha.randn((), dispositivo=dispositivo, dtipo=tipo_datos) b=antorcha.randn((), dispositivo=dispositivo, dtipo=tipo_datos) c=antorcha.randn((), dispositivo=dispositivo, dtipo=tipo_datos) d=antorcha.randn((), dispositivo=dispositivo, dtipo=tipo_datos) tasa_aprendizaje=1e-6 para i en rango(1500): y_pred=a + bm + cm2 + dm3 pérdida=(y_pred - y).pow(2).sum().item() si i % 100==99: print(i, pérdida ) grad_a=grad_y_pred.sum() grad_b=(grad_y_predm).sum() grad_c=(grad_y_predm 2).sum() grad_d=(grad_y_predm3).sum() a -=tasa_de_aprendizajegrad_a b -=tasa_de_aprendizajegrad_b c -=tasa_de_aprendizajegrad_c d -=tasa_de_aprendizajegrad_d print(f&39;Result: y={a.item()} + {b.item()} x + {c.item ()} x^2 + {d.elemento()} x^3&39;) "
GPU para aprendizaje profundo
GPU ayuda a entrenar modelos a un ritmo más rápido porque todos los modelos se ejecutan en paralelo y, por lo tanto, no hay tiempo de espera. Primero, echemos un vistazo a las GPU que admiten el aprendizaje profundo.
- NVIDIAGeForce RTX 2060
NVIDIA asegura que las operaciones se ejecutan a un ritmo más rápido con la arquitectura Turing involucrada en el sistema donde RTX realiza la operación con una velocidad 6 veces mayor en comparación con sus versiones anteriores. RTX es conocido por admitir todo tipo de juegos con sus efectos visuales también.
- NVIDIAGeForce GTX 1080
GTX 1080 tiene arquitectura Pascal, lo que ayuda al sistema a concentrarse en la potencia y la eficiencia del sistema. Además, hay un enfriamiento de cámara de vapor disponible, lo que reduce los problemas de calentamiento mientras se juega o se realizan experimentos de aprendizaje profundo.
- ZOTAC GeForce GTX 1070
Esto también sigue la arquitectura Pascal, donde se prometen alto rendimiento, memoria mejorada y eficiencia energética.
- NVIDIATesla K80
GPU dual se ofrece en el sistema donde se aumenta el rendimiento con una confiabilidad mejorada y un ancho de banda de memoria agregado. Además, Tesla K80 también gestiona la optimización del servidor.
Otras GPU incluyen NVIDIA GeForce RTX 2080, NVIDIA GeForce RTX 3060, NVIDIA Titan RTX, NVIDIA Tesla v100, NVIDIA A100 y ASUS ROG Strix Radeon RX 570.
Idea de GPU PyTorch
Es importante que tanto los datos como la red coexistan en la GPU para que los cálculos se puedan realizar fácilmente. Esto también se aplica a la CPU. Tanto la CPU como la GPU son dispositivos informáticos y, por lo tanto, si se van a realizar cálculos de datos en la red, deben estar dentro del dispositivo.
El primer paso es hacer los cálculos de tensor, y aquí debemos dar el dispositivo como CPU o GPU según nuestros requisitos. Si vemos CPU como el dispositivo, podemos cambiarlo a CUDA, la GPU. También podemos hacer el mismo proceso en redes neuronales, donde se prefiere GPU más que CPU.
Red GPU PyTorch
El parámetro de la red debe trasladarse al dispositivo para que funcione en la GPU. Tenemos peso y sesgo en los parámetros de convolución y funciones donde se debe aplicar, y el sistema debe inicializarse con los valores de los parámetros. La GPU inicializa estos parámetros y debe tenerse en cuenta que los tensores dentro de las redes son importantes para un dispositivo. Se debe mantener la coherencia entre los módulos de red y los sensores PyTorch.
Todas las nuevas redes serán CPU por defecto, y deberíamos moverlas a GPU para que funcionen.
intentar: pred=network(sample.to('cuda')) print(pred) excepto Exception as e: print(e) tensor(((-0.0576, 0.0138, 0.1393, 0.2895, 0.1378, 0.0111, -0.0250, -0.0088, -0.0632, 0.0940)) , dispositivo='cuda:0' , grad_fn=) Podemos escribir un código agnóstico para el dispositivo donde el código no dependerá de ningún dispositivo y funcionará de forma independiente.
Conclusión
Con más experiencia, podemos mejorar la precisión probando con diferentes condiciones de época, y podemos probar con diferentes modelos donde los datos de entrenamiento y prueba se pueden dar en diferentes condiciones. Siempre es innecesario entrenar los modelos para conocer los resultados y poder visualizarlos fácilmente.