import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import StandardScaler
import pandas as pd
import numpy as np
import os
import mlflow
import mlflow.sklearn
import logging

logging.basicConfig(level=logging.WARN)
logger = logging.getLogger(__name__)
mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("s487194")

# Wczytanie danych
print(os.getcwd())
data = pd.read_csv("./Sales.csv")

# Przygotowanie danych
data["Profit_Category"] = pd.cut(data["Profit"], bins=[-np.inf, 500, 1000, np.inf], labels=[0, 1, 2])
bike = data.loc[:, ['Customer_Age', 'Customer_Gender', 'Country','State', 'Product_Category', 'Sub_Category', 'Profit_Category']]  
bikes = pd.get_dummies(bike, columns=['Country', 'State', 'Product_Category', 'Sub_Category', 'Customer_Gender'])
X = bikes.drop('Profit_Category', axis=1).values
y = bikes['Profit_Category'].values
X_train, X_test, y_train, y_test=train_test_split(X,y,test_size=0.2,random_state=0)
scaler = StandardScaler()
X = scaler.fit_transform(X)
#### Tworzenie tensorów
X_train = X_train.astype(np.float32)
X_test = X_test.astype(np.float32)
y_train = y_train.astype(np.float32)
y_test = y_test.astype(np.float32)
X_train=torch.FloatTensor(X_train)
X_test=torch.FloatTensor(X_test)
y_train=torch.LongTensor(y_train)
y_test=torch.LongTensor(y_test)

#### Model

class ANN_Model(nn.Module):
    def __init__(self,input_features=82,hidden1=20,hidden2=20,out_features=3):
        super().__init__()
        self.f_connected1=nn.Linear(input_features,hidden1)
        self.f_connected2=nn.Linear(hidden1,hidden2)
        self.out=nn.Linear(hidden2,out_features)
    def forward(self, x):
        x=F.relu(self.f_connected1(x))
        x=F.relu(self.f_connected2(x))
        x=self.out(x)
        return x


torch.manual_seed(20)
model=ANN_Model()

def calculate_accuracy(model, X, y):
    with torch.no_grad():
        outputs = model(X)
        _, predicted = torch.max(outputs.data, 1)
        total = y.size(0)
        correct = (predicted == y).sum().item()
        accuracy = correct / total * 100
    return accuracy

loss_function = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

epochs = 100
final_losses = []
accuracy_list = []

with mlflow.start_run() as run:
    # Logowanie parametrów modelu
    mlflow.log_param("hidden_layer_1", 20)
    mlflow.log_param("hidden_layer_2", 20)
    mlflow.log_param("output_layer", 3)
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_param("epochs", epochs)

    for i in range(epochs):
        i = i + 1
        y_pred = model(X_train)
        loss = loss_function(y_pred, y_train)
        final_losses.append(loss)

        train_accuracy = calculate_accuracy(model, X_train, y_train)
        test_accuracy = calculate_accuracy(model, X_test, y_test)

        # Logowanie metryk po każdej epoce
        mlflow.log_metric("train_loss", loss.item(), step=i)
        mlflow.log_metric("train_accuracy", train_accuracy, step=i)
        mlflow.log_metric("test_accuracy", test_accuracy, step=i)

        print(f"Epoch: {i}, Loss: {loss.item()}, Train Accuracy: {train_accuracy}%, Test Accuracy: {test_accuracy}%")
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

torch.save(model,"classificationn_model.pt")