Day70_Ai(6)

perceptronEx

import torch
import torch.nn as nn
import torch.optim as optim


torch.manual_seed(777)

x_data = torch.FloatTensor([[0,0],[0,1],[1,0],[1,1]])
y_data = torch.FloatTensor([[0],[1],[1],[1]])

model = nn.Sequential(              #층층이 객체생성할때 심플하게 만들기 위해
    nn.Linear(2,2),
    nn.Sigmoid(),
    nn.Linear(2,1),
    nn.Sigmoid()
)

loss_func = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=1)

for epoch in range(10000):
    hypothesis = model(x_data)
    loss = loss_func(hypothesis, y_data)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print(f'epoch: {epoch+1} loss:{loss.item():.4f}')

with torch.no_grad(): #기본적으로 값들을 미분할 수 있게 미분추적을 한다. 해당함수를 쓰면 그걸 하지말라고함
    hypothesis = model(x_data)
    prediction = (hypothesis > 0.5).float()
    accuracy = (prediction == y_data).float().mean()
    print('hypothesis:\n{}\nprediction:\n{}\ntarget:\n{}\naccuracy:{:.4f}'.format(
        hypothesis.numpy(), prediction.numpy(), y_data.numpy(), accuracy.item()
    ))

quiz2

import pandas as pd
import torch
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from torch.utils.data import Dataset, DataLoader
import torch.optim as optim
import torch.nn as nn

torch.manual_seed(777)

cancer = load_breast_cancer()
print(cancer.feature_names)

df = pd.DataFrame(cancer.data, columns=cancer.feature_names)
df['class'] = cancer.target
df.info()
print(df['class'].unique())


#==========내가한것===========
# x_train = torch.tensor(df.iloc[:,:30].values, dtype=torch.float32)
# y_train = torch.tensor(df['class'].values, dtype=torch.float32)
# print(x_train)
# print(y_train)
#
# model = nn.Sequential(
#     nn.Linear(30,30),
#     nn.Sigmoid(),
#     nn.Linear(30, 30),
#     nn.Sigmoid(),
#     nn.Linear(30, 30),
#     nn.Sigmoid(),
#     nn.Linear(30,1),
#     nn.Sigmoid()
# )
#=============================


data = torch.from_numpy(df.values).float()

x_train = data[:, :-1]
y_train = data[:, -1:]  #size 맞추기 위해

class LogisticModel(nn.Module):
    def __init__(self, input_size, output_size):
        super().__init__()
        self.linear = nn.Linear(input_size, output_size)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.linear(x)
        y = self.sigmoid(x)
        return y

model = LogisticModel(input_size=x_train.size(-1), output_size=y_train.size(-1))
loss_func = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.00005)
# lr 0.001 을 가장 기본으로 쓴다. 0.0001, 0.000001 까지도 씀

for epoch in range(200000):
    hypothesis = model(x_train)
    loss = loss_func(hypothesis, y_train)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 10000 == 0:
        print(f'epoch:{epoch+1} loss:{loss.item():.4f}')

correction_cnt = (y_train == (hypothesis > 0.5)).sum()
print('accuracy: {:2.1f}%'.format(correction_cnt / float(y_train.size(0))*100))