##
Introdução ao PyTorch Etapa 1:configuração do ambiente *
Instale Python e crie um ambiente virtual - Python 3.6 ou superior é recomendado.
- Crie um ambiente virtual usando `python -m venv venv` (ou `virtualenv venv` para versões mais antigas do Python) e ative-o com `source venv/bin/activate` no Linux/macOS ou `venv\Scripts\activate` no Windows .
*
Instale o PyTorch - Use `pip` para instalar o PyTorch:`pip install torch torchvision`.
- Para suporte a GPU, instale `torch` com a opção `-c pytorch`.
Etapa 2:Exemplo Simples - Criando um Tensor ```píton
importar tocha
Crie um tensor a partir de uma lista
tensor =tocha.tensor([1, 2, 3])
Imprima o tensor
imprimir (tensor)
Imprima a forma do tensor
imprimir(tensor.forma)
Imprima o tipo do tensor
imprimir(tensor.dtype)
```
Saída:
```
tensor([1, 2, 3])
tocha.Size([3])
tocha.int64
```
Etapa 3:Operações matemáticas básicas ```píton
Adição de elemento
tensor =tocha.tensor([1, 2, 3])
tensor2 =tocha.tensor([4, 5, 6])
resultado =tensor + tensor2
imprimir (resultado)
Saída:tensor([ 5, 7, 9])
Multiplicação de matrizes
matriz1 =tocha.tensor([[1, 2], [3, 4]])
matriz2 =tocha.tensor([[5, 6], [7, 8]])
resultado =tocha.mm(matriz1, matriz2)
imprimir (resultado)
Saída:tensor([[19, 22], [43, 50]])
```
Etapa 4:usar GPU para computação mais rápida ```píton
Verifique se CUDA está disponível
se torch.cuda.is_available():
# Mova os tensores para GPU
dispositivo =tocha.device("cuda")
tensor =tensor.to(dispositivo)
tensor2 =tensor2.to(dispositivo)
# Executar operações na GPU
resultado =tensor + tensor2
# Mova o resultado de volta para a CPU se necessário
resultado =resultado.to("cpu")
imprimir (resultado)
```
Trabalhando com dados
Etapa 1:conjunto de dados PyTorch fornece uma maneira conveniente de trabalhar com conjuntos de dados usando sua classe `Dataset`. Aqui está um exemplo:
```píton
classe MeuDataset(torch.utils.data.Dataset):
def __init__(self, dados, rótulos):
self.data =dados
self.labels =rótulos
def __getitem__(self, índice):
retornar self.data[index], self.labels[index]
def __len__(auto):
retornar len(self.dados)
Crie uma instância do conjunto de dados
conjunto de dados =MeuConjunto de Dados(dados, rótulos)
```
Etapa 2:DataLoader Use `DataLoader` para carregar dados em lotes com eficiência durante o treinamento.
```píton
Definir tamanho do lote
tamanho_do_lote =32
Crie um carregador de dados
data_loader =torch.utils.data.DataLoader(conjunto de dados, batch_size=batch_size)
Iterar os lotes
para lote em data_loader:
# Aqui, batch seria uma tupla de `(data, rótulos)`
```
Construindo uma Rede Neural
Etapa 1:inicialize sua rede ```píton
importar torch.nn como nn
Defina uma rede neural simples com 3 camadas
classe MinhaNeuralNetwork(nn.Module):
def __init__(self):
super(MinhaRedeNeural, self).__init__()
self.layer1 =nn.Linear(784, 256) # Camada de entrada
self.layer2 =nn.Linear(256, 128) # Camada oculta
self.layer3 =nn.Linear(128, 10) # Camada de saída
def para frente(self, x):
x =x.view(x.shape[0], -1) # Achatar entrada
x =F.relu(self.layer1(x)) # Função de ativação (ReLU)
x =F.relu(self.layer2(x)) # Função de ativação (ReLU)
x =F.log_softmax(self.layer3(x)) # Camada de saída com softmax
retornar x
Inicializar a rede
rede =MinhaRedeNeural()
```
Etapa 2:Definir função de perda e otimizador ```píton
importar torch.optim como optim
Defina a função de perda (aqui usamos perda de entropia cruzada)
perda_fn =nn.CrossEntropyLoss()
Definir otimizador (aqui usamos gradiente descendente estocástico)
otimizador =optim.SGD(network.parameters(), lr=0,001)
```
Etapa 3:treinar a rede ```píton
Treine a rede por 10 épocas
para época no intervalo (10):
para lote em data_loader:
# Obtenha entradas e rótulos
entradas, rótulos =lote
# Gradientes claros
otimizador.zero_grad()
#Passe para frente
saídas =rede (entradas)
# Perda de cálculo
perda =loss_fn(saídas, rótulos)
# Retrocesso e atualização de pesos
perda.backward()
otimizador.step()
print(f"Época {época + 1}:Perda:{perda.item()}")
```
Etapa 4:avaliar a rede ```píton
Avalie a precisão da rede no conjunto de dados de teste
com torch.no_grad():
correto =0
total =0
para lote em test_data_loader:
entradas, rótulos =lote
#Passe para frente
saídas =rede (entradas)
# Obtenha previsões
_, previsto =torch.max(outputs.data, 1)
# Atualizar contagem de precisão
total +=rótulos.tamanho(0)
correto +=(previsto ==rótulos).sum().item()
# Calcule a precisão
precisão =correto / total
print(f"Precisão nos dados de teste:{precisão * 100}%")
```
