Paso 1:Configuración del entorno
* Instalar Python y crear un entorno virtual
- Se recomienda Python 3.6 o superior.
- Cree un entorno virtual usando `python -m venv venv` (o `virtualenv venv` para versiones anteriores de Python) y actívelo con `source venv/bin/activate` en Linux/macOS o `venv\Scripts\activate` en Windows .
* Instalar PyTorch
- Utilice `pip` para instalar PyTorch:`pip install torch torchvision`.
- Para compatibilidad con GPU, instale `torch` con la opción `-c pytorch`.
Paso 2:Ejemplo simple:creación de un tensor
```pitón
importar antorcha
Crear un tensor a partir de una lista
tensor =antorcha.tensor([1, 2, 3])
Imprimir el tensor
imprimir (tensor)
Imprimir la forma del tensor
imprimir (tensor.forma)
Imprimir el tipo de tensor
imprimir (tensor.dtype)
```
Producción:
```
tensor([1, 2, 3])
antorcha.Tamaño([3])
antorcha.int64
```
Paso 3:Operaciones matemáticas básicas
```pitón
Suma por elementos
tensor =antorcha.tensor([1, 2, 3])
tensor2 =antorcha.tensor([4, 5, 6])
resultado =tensor + tensor2
imprimir (resultado)
Salida:tensor([ 5, 7, 9])
Multiplicación de matrices
matriz1 =antorcha.tensor([[1, 2], [3, 4]])
matriz2 =antorcha.tensor([[5, 6], [7, 8]])
resultado =antorcha.mm(matriz1, matriz2)
imprimir (resultado)
Salida:tensor([[19, 22], [43, 50]])
```
Paso 4:uso de GPU para un cálculo más rápido
```pitón
Comprueba si CUDA está disponible
si torch.cuda.is_available():
# Mover los tensores a GPU
dispositivo =antorcha.dispositivo ("cuda")
tensor =tensor.to(dispositivo)
tensor2 =tensor2.to(dispositivo)
# Realizar operaciones en GPU
resultado =tensor + tensor2
# Mueve el resultado de regreso a la CPU si es necesario
resultado =resultado.to("cpu")
imprimir (resultado)
```
Trabajar con datos
Paso 1:conjunto de datos
PyTorch proporciona una forma conveniente de trabajar con conjuntos de datos utilizando su clase "Dataset". He aquí un ejemplo:
```pitón
clase MyDataset(torch.utils.data.Dataset):
def __init__(self, datos, etiquetas):
self.datos =datos
self.labels =etiquetas
def __getitem__(self, índice):
devolver self.data[índice], self.labels[índice]
def __len__(yo):
devolver len(self.data)
Crear una instancia del conjunto de datos
conjunto de datos =MyDataset(datos, etiquetas)
```
Paso 2:Cargador de datos
Utilice `DataLoader` para cargar datos en lotes de manera eficiente durante el entrenamiento.
```pitón
Definir tamaño de lote
tamaño_lote =32
Crear un cargador de datos
data_loader =torch.utils.data.DataLoader(conjunto de datos, tamaño_lote=tamaño_lote)
Iterar a través de los lotes
para lotes en data_loader:
# Aquí, lote sería una tupla de `(datos, etiquetas)`
```
Construyendo una red neuronal
Paso 1:inicializa tu red
```pitón
importar torch.nn como nn
Definir una red neuronal simple con 3 capas
clase MyNeuralNetwork(nn.Module):
def __init__(yo):
super(MyNeuralNetwork, self).__init__()
self.layer1 =nn.Linear(784, 256) # Capa de entrada
self.layer2 =nn.Linear(256, 128) # Capa oculta
self.layer3 =nn.Linear(128, 10) # Capa de salida
def adelante(yo, x):
x =x.view(x.shape[0], -1) # Aplanar entrada
x =F.relu(self.layer1(x)) # Función de activación (ReLU)
x =F.relu(self.layer2(x)) # Función de activación (ReLU)
x =F.log_softmax(self.layer3(x)) # Capa de salida con softmax
volver x
Inicializar la red
red =MiRedNeural()
```
Paso 2:Definir la función de pérdida y el optimizador
```pitón
importar torch.optim como optim
Definir la función de pérdida (aquí usamos pérdida de entropía cruzada)
loss_fn =nn.CrossEntropyLoss()
Definir optimizador (aquí usamos descenso de gradiente estocástico)
optimizador =optim.SGD(network.parameters(), lr=0.001)
```
Paso 3:Capacitar a la red
```pitón
Entrena la red durante 10 épocas
para la época en el rango (10):
para lotes en data_loader:
# Obtener entradas y etiquetas
entradas, etiquetas =lote
# Borrar gradientes
optimizador.zero_grad()
# Pase hacia adelante
salidas =red (entradas)
# Calcular la pérdida
pérdida =pérdida_fn (salidas, etiquetas)
# Pasar hacia atrás y actualizar pesos
pérdida.hacia atrás()
optimizador.paso()
print(f"Época {época + 1}:Pérdida:{pérdida.item()}")
```
Paso 4:Evaluar la red
```pitón
Evaluar la precisión de la red en el conjunto de datos de prueba
con antorcha.no_grad():
correcto =0
total =0
para lote en test_data_loader:
entradas, etiquetas =lote
# Pase hacia adelante
salidas =red (entradas)
# Obtener predicciones
_, previsto =antorcha.max(salidas.datos, 1)
# Actualizar el recuento de precisión
total +=etiquetas.tamaño(0)
correcto +=(previsto ==etiquetas).sum().item()
# Calcular la precisión
precisión =correcto / total
print(f"Precisión de los datos de prueba:{precisión * 100}%")
```