273 lines
4.3 KiB
Python
273 lines
4.3 KiB
Python
#!/usr/bin/env python
|
|
# coding: utf-8
|
|
|
|
# In[2]:
|
|
|
|
|
|
import pandas as pd
|
|
import sklearn.model_selection
|
|
from datasets import load_dataset
|
|
|
|
|
|
# In[3]:
|
|
|
|
|
|
dataset = load_dataset("mstz/wine", "wine")
|
|
|
|
|
|
# In[4]:
|
|
|
|
|
|
dataset["train"]
|
|
|
|
|
|
# In[5]:
|
|
|
|
|
|
wine_dataset = pd.DataFrame(dataset["train"])
|
|
|
|
|
|
# In[6]:
|
|
|
|
|
|
wine_dataset.head()# podgląd danych
|
|
|
|
|
|
# In[7]:
|
|
|
|
|
|
wine_dataset.describe(include='all')
|
|
|
|
|
|
# In[8]:
|
|
|
|
|
|
wine_dataset["is_red"].value_counts().plot(kind="bar")
|
|
|
|
|
|
|
|
|
|
# In[9]:
|
|
|
|
|
|
wine_dataset["fixed_acidity"].std()
|
|
|
|
|
|
# In[10]:
|
|
|
|
|
|
import numpy as np
|
|
np.where(pd.isnull(wine_dataset))## sprawdzanie czy istnieją puste wartości
|
|
|
|
|
|
# In[11]:
|
|
|
|
|
|
for column in wine_dataset.columns:
|
|
wine_dataset[column] = wine_dataset[column] / wine_dataset[column].abs().max() # normalizacja
|
|
|
|
|
|
# In[12]:
|
|
|
|
|
|
wine_dataset.describe(include='all') # sprawdzanie wartości po znormalizowaniu
|
|
|
|
|
|
# In[13]:
|
|
|
|
|
|
wine_dataset["fixed_acidity"].nlargest(10) #sprawdza czy najwyższe wartości mają sens
|
|
|
|
|
|
# In[14]:
|
|
|
|
|
|
from sklearn.model_selection import train_test_split
|
|
wine_train, wine_test = sklearn.model_selection.train_test_split(wine_dataset, test_size=0.1, random_state=1, stratify=wine_dataset["is_red"])
|
|
wine_train["is_red"].value_counts()
|
|
# podzielenie na train i test
|
|
|
|
|
|
# In[15]:
|
|
|
|
|
|
wine_test["is_red"].value_counts()
|
|
|
|
|
|
# In[16]:
|
|
|
|
|
|
wine_test, wine_val = sklearn.model_selection.train_test_split(wine_test, test_size=0.5, random_state=1, stratify=wine_test["is_red"]) # podzielenie na test i validation
|
|
|
|
|
|
# In[17]:
|
|
|
|
|
|
wine_test["is_red"].value_counts()
|
|
|
|
|
|
# In[18]:
|
|
|
|
|
|
wine_val["is_red"].value_counts()
|
|
|
|
|
|
# In[19]:
|
|
|
|
|
|
import seaborn as sns
|
|
sns.set_theme()
|
|
|
|
|
|
# In[20]:
|
|
|
|
|
|
len(wine_dataset.columns)
|
|
|
|
|
|
# In[ ]:
|
|
|
|
|
|
|
|
|
|
|
|
# In[21]:
|
|
|
|
|
|
#sns.pairplot(data=wine_dataset, hue="is_red")
|
|
|
|
|
|
# In[22]:
|
|
|
|
|
|
wine_test.describe()
|
|
|
|
|
|
# In[23]:
|
|
|
|
|
|
wine_train.describe()
|
|
|
|
|
|
# In[24]:
|
|
|
|
|
|
wine_val.describe()
|
|
|
|
|
|
# In[25]:
|
|
|
|
|
|
import torch
|
|
from torch import nn
|
|
from torch.utils.data import DataLoader, Dataset
|
|
|
|
|
|
# In[26]:
|
|
|
|
|
|
class TabularDataset(Dataset):
|
|
def __init__(self, data):
|
|
self.data = data.values.astype('float32')
|
|
|
|
def __getitem__(self, index):
|
|
x = torch.tensor(self.data[index, :-1])
|
|
y = torch.tensor(self.data[index, -1])
|
|
return x, y
|
|
|
|
def __len__(self):
|
|
return len(self.data)
|
|
|
|
|
|
# In[27]:
|
|
|
|
|
|
batch_size = 64
|
|
train_dataset = TabularDataset(wine_train)
|
|
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
|
|
test_dataset = TabularDataset(wine_test)
|
|
test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
|
|
|
|
|
|
# In[ ]:
|
|
|
|
|
|
|
|
|
|
|
|
# In[28]:
|
|
|
|
|
|
class TabularModel(nn.Module):
|
|
def __init__(self, input_dim, hidden_dim, output_dim):
|
|
super(TabularModel, self).__init__()
|
|
self.fc1 = nn.Linear(input_dim, hidden_dim)
|
|
self.relu = nn.ReLU()
|
|
self.fc2 = nn.Linear(hidden_dim, output_dim)
|
|
self.softmax = nn.Softmax(dim=1)
|
|
|
|
def forward(self, x):
|
|
out = self.fc1(x)
|
|
out = self.relu(out)
|
|
out = self.fc2(out)
|
|
out = self.softmax(out)
|
|
return out
|
|
|
|
|
|
# In[29]:
|
|
|
|
|
|
input_dim = wine_train.shape[1] - 1
|
|
hidden_dim = 32
|
|
output_dim = 2
|
|
model = TabularModel(input_dim, hidden_dim, output_dim)
|
|
criterion = nn.CrossEntropyLoss()
|
|
optimizer = torch.optim.Adam(model.parameters())
|
|
|
|
|
|
# In[30]:
|
|
|
|
|
|
model = TabularModel(input_dim=len(wine_train.columns)-1, hidden_dim=32, output_dim=2)
|
|
criterion = nn.CrossEntropyLoss()
|
|
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
|
|
|
|
|
|
# In[31]:
|
|
|
|
|
|
num_epochs = 10
|
|
for epoch in range(num_epochs):
|
|
running_loss = 0.0
|
|
for i, data in enumerate(train_dataloader, 0):
|
|
inputs, labels = data
|
|
labels = labels.type(torch.LongTensor)
|
|
optimizer.zero_grad()
|
|
outputs = model(inputs)
|
|
loss = criterion(outputs, labels)
|
|
loss.backward()
|
|
optimizer.step()
|
|
running_loss += loss.item()
|
|
|
|
# Print the loss every 1000 mini-batches
|
|
if (epoch%2) == 0:
|
|
print(f'Epoch {epoch + 1}, loss: {running_loss / len(train_dataloader):.4f}')
|
|
|
|
print('Finished Training')
|
|
|
|
|
|
# In[32]:
|
|
|
|
|
|
correct = 0
|
|
total = 0
|
|
with torch.no_grad():
|
|
for data in test_dataloader:
|
|
inputs, labels = data
|
|
outputs = model(inputs.float())
|
|
_, predicted = torch.max(outputs.data, 1)
|
|
total += labels.size(0)
|
|
correct += (predicted == labels).sum().item()
|
|
print('Accuracy on test set: %d %%' % (100 * correct / total))
|
|
|