<jupyter_start><jupyter_text>Projeto 10: Regressão Venda de Vídeo Games Etapa 01: Importação das Bibliotecas<jupyter_code>import pandas as pd
from torch import nn, optim
import torch.nn.functional as F
import torch
import seaborn as sns
import matplotlib.pyplot as plt<jupyter_output><empty_output><jupyter_text>Etapa 02: Base de Dados<jupyter_code>torch.manual_seed(123)
base = pd.read_csv('/content/games.csv')
base.head()
base.shape
# Apagar o other_sales e o global_sales, developer
base = base.drop('Other_Sales', axis=1)
base = base.drop('Global_Sales', axis=1)
base = base.drop('Developer', axis=1)
base.shape
sns.heatmap(base.isnull());  # Visualizar dados faltantes
# Para fazer o tratamento dos dados, apagaremos os valores faltantes (não é uma boa alternativa)
base = base.dropna(axis=0)  # Acessa todos os valores faltantes e os apaga
sns.heatmap(base.isnull());
base.shape  # Perdeu-se quase 10000 registros
base.loc[base['NA_Sales'] > 1]  # Busca as vendas em que o valor é maior que 1
# Filtro para buscar as vendas em que o valor é maior que 1
base = base.loc[base['NA_Sales'] > 1]
base.shape
base.loc[base['EU_Sales'] > 1]
base = base.loc[base['EU_Sales'] > 1]
base.shape
base['Name'].value_counts()  # Mostra a quantidade de vezes em que o nome de um jogo aparece
base = base.drop('Name', axis = 1)
base.shape
previsores = base.iloc[:, [0,1,2,3,7,8,9,10,11]].values
vendas = base.iloc[:, 4:7].values
previsores
vendas
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
onehotencoder = ColumnTransformer(transformers=[("OneHot", OneHotEncoder(), [0,2,3,8])], remainder = 'passthrough')
previsores = onehotencoder.fit_transform(previsores).toarray()
previsores.shape<jupyter_output><empty_output><jupyter_text>Etapa 03: Construção do Modelo<jupyter_code># 61 -> 32 -> 32 -> 3
class regressor_torch(nn.Module):
    def __init__(self):
        super().__init__()
        self.dense0 = nn.Linear(61, 32)
        self.dense1 = nn.Linear(32, 32)
        self.activation = nn.Sigmoid()
        self.output = nn.Linear(32, 3)
    
    def forward(self, X):  # Ligando as camadas
        X = self.dense0(X)
        X = self.activation(X)
        X = self.dense1(X)
        X = self.activation(X)
        X = self.output(X)
        
        return X
regressor = regressor_torch()
criterion = nn.MSELoss()
optimizer = optim.Adam(regressor.parameters())
type(previsores)
previsores = torch.tensor(previsores, dtype=torch.float)
vendas = torch.tensor(vendas, dtype=torch.float)
type(previsores)
dataset = torch.utils.data.TensorDataset(previsores, vendas)
train_loader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True)<jupyter_output><empty_output><jupyter_text>Etapa 04: Treinamento do Modelo<jupyter_code>device = 'cuda' if torch.cuda.is_available() else 'cpu'
device
regressor.to(device)
for epoch in range(2000):
    running_loss = 0.  # erro geral da rede
    running_mse_0 = 0.
    running_mse_1 = 0.
    running_mse_2 = 0.

    for i, data in enumerate(train_loader):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = regressor.forward(inputs)

        # Erro para cada um dos atributos
        mse_0 = F.mse_loss(outputs[:, 0], labels[:, 0]).item()
        mse_1 = F.mse_loss(outputs[:, 1], labels[:, 1]).item()
        mse_2 = F.mse_loss(outputs[:, 2], labels[:, 2]).item()

        running_mse_0 += mse_0 * len(inputs)
        running_mse_1 += mse_1 * len(inputs)
        running_mse_2 += mse_2 * len(inputs)

        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        loss = loss.item()
        running_loss += loss * len(inputs)

        print('\rÉpoca {:4d} - Loop {:3d} de {:3d}: erro_0 {:6.4f} | erro_1 \ {:6.4f} | erro_2 {:6.4f} - custo {:6.4f}'.format(epoch + 1,
                                                                                                                         i+1,
                                                                                                                         len(train_loader),
                                                                                                                         mse_0,
                                                                                                                         mse_1,
                                                                                                                         mse_2,
                                                                                                                         loss), end = '\r')
        
    print('\rÉpoca {:4d} finalizada: erro_0 {:6.4f} | erro_1 {:6.4f} | \ erro_2 {:6.4f} - custo {:6.4f}     '.format(epoch + 1,
                                                                                                                 running_mse_0/len(dataset),
                                                                                                                 running_mse_1/len(dataset),
                                                                                                                 running_mse_2/len(dataset),
                                                                                                                 running_loss/len(dataset)))<jupyter_output>Época    1 - Loop   1 de  26: erro_0 4.6990 | erro_1 \ 7.0545 | erro_2 0.0828 - custo 3.9454

Época    1 - Loop   2 de  26: erro_0 47.7745 | erro_1 \ 18.3392 | erro_2 1.3986 - custo 22.5041

Época    1 - Loop   3 de  26: erro_0 18.2606 | erro_1 \ 15.3541 | erro_2 1.7665 - custo 11.7938

Época    1 - Loop   4 de  26: erro_0 13.2448 | erro_1 \ 9.0967 | erro_2 1.4246 - custo 7.9220

Época    1 - Loop   5 de  26: erro_0 5.6786 | erro_1 \ 6.8323 | erro_2 0.0945 - custo 4.2018

Época    1 - Loop   6 de  26: erro_0 18.8380 | erro_1 \ 11.1298 | erro_2 2.1223 - custo 10.6967

Época    1 - Loop   7 de  26: erro_0 11.7255 | erro_1 \ 10.6743 | erro_2 0.1189 - custo 7.5062

Época    1 - Loop   8 de  26: erro_0 181.5972 | erro_1 \ 96.7730 | erro_2 1.3650 - custo 93.2451

Época    1 - Loop   9 de  26: erro_0 39.6023 | erro_1 \ 26.7936 | erro_2 1.3704 - custo 22.5888

Época    1 - Loop  10 de  26: erro_0 6.7845 | erro_1 \ 8.9935 | erro_2 1.8855 - custo 5.8879

Época    1 - Loop  11 de  26: erro_0 19.[...]<jupyter_text>Etapa 05: Avaliação do Modelo<jupyter_code>regressor.eval()
previsores = previsores.to(device)
previsoes = regressor.forward(previsores)
previsoes
previsoes = previsoes.cpu().detach().numpy()
previsoes
previsoes.mean(axis=0)
vendas.mean(axis=0)
fig, ax = plt.subplots(1, 3, figsize=(10,5))
for i in range(3):
    ax[i].plot(vendas[:, i])
    ax[i].plot(previsoes[:,i])
    ax[i].legend(['Valores reais', 'Previsões'])
    ax[i].set_title(base.columns[4+i])<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup