• LSTM의 핵심은 '셀 상태'(cell state)라는 내부 메커니즘을 통해 정보를 장기간 저장하고, 필요한 정보만을 선택적으로 통과시키거나 수정할 수 있는 구조

#1.예제 생성
X = []
Y = []
for i in range(3000):
    lst = np.random.rand(100)
    idx = np.random.choice(100, 2, replace=True)
    zeros = np.zeros(100)
    zeros[idx] = 1
    X.append(np.array(list(zip(zeros, lst))))
    Y.append(np.prod(lst[idx]))

print(X[0], Y[0])
# 출력결과
[[0.         0.67267919]
 [0.         0.85503857]
 [0.         0.27878153]
 [0.         0.34400342]
 [0.         0.07751136]
 [0.         0.3449192 ]
 [0.         0.96053807]
 [0.         0.31499018]






 #2. FNN으로 풀어보기
# RNN으로 한 번 풀어보자
model = tf.keras.Sequential([
    tf.keras.layers.SimpleRNN(units=30, return_sequences=True, input_shape =[100,2]),
    tf.keras.layers.SimpleRNN(units=30),
    tf.keras.layers.Dense(1)
])

model.compile(optimizer='adam', loss ='mse')
model.summary()
# 출력
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 simple_rnn_6 (SimpleRNN)    (None, 100, 30)           990       

 simple_rnn_7 (SimpleRNN)    (None, 30)                1830      

 dense_2 (Dense)             (None, 1)                 31      



 #3. 훈련 (epochs)
 # 훈련
X = np.array(X)
Y = np.array(Y)

history = model.fit(X[:2560], Y[:2560], epochs=100, validation_split = 0.2)


#4. 결과 엉망
 import matplotlib.pyplot as plt
%matplotlib inline

plt.plot(history.history['loss'], 'b-', label = 'loss')
plt.plot(history.history['val_loss'], 'r--', label = 'val_loss')
plt.xlabel('Epoch')
plt.legend()
plt.show()

동일하게 훈련 해보기

X = np.array(X)
Y = np.array(Y)

history = model.fit(X[:2560], Y[:2560], epochs=100, validation_split = 0.2)




#시각화
# 다시 시각화
plt.plot(history.history['loss'], 'b-', label='loss')
plt.plot(history.history['val_loss'], 'r--', label = 'val_loss')
plt.xlabel('Epoch')
plt.legend()
plt.show()

• 시퀀스 데이터를 처리하기 위해 개발된 가장 기본적인 형태의 순환 신경망
• 시퀀스 데이터를 처리하기 위해 개발된 가장 기본적인 형태의 순환 신경망
• Simple RNN은 자연어 처리(Natural Language Processing, NLP), 시계열 예측(Time Series Forecasting), 음성 인식(Speech Recognition)과 같이 입력 데이터가 시간적 순서를 가지고 있는 문제를 해결하는 데 사용
• RNN의 핵심 아이디어는 과거의 정보를 현재의 결정에 활용
• 시퀀스가 길어질수록 시간적으로 멀리 떨어진 정보를 현재 의사 결정에 효과적으로 반영하는 데 어려움
• 순환 신경망(RNN)의 발전된 형태인 LSTM(Long Short-Term Memory) 네트워크에서 사용되는 주요 구성 요소 중 하나
• 메모리 셀은 정보를 장기간 저장하는 데 사용됩니다. 이는 RNN의 장기 의존성 문제를 해결
• 각 메모리 셀에는 입력, 출력, 그리고 망각 게이트가 포함되어 있어, 셀이 저장하는 정보의 양을 조절
• 모리 셀은 각 시간 단계마다 정보를 전달함으로써 네트워크가 이전의 입력을 "기억"하고 이를 기반으로 새로운 결정을 내릴 수 있게 해준다.
• 계열 데이터나 자연어 처리와 같이 시간적으로 연결된 정보가 중요한 작업에 매우 유용
• sequence-to-sequence 형태
• 시퀀스를 다른 시퀀스로 변환하는 데 사용되는 신경망 아키텍처
• 모델은 주로 머신 번역, 질문 응답 시스템, 텍스트 요약과 같이 입력과 출력이 시퀀스 형태인 문제에 적용

• sequence-to-vector
• 시퀀스 데이터를 고정된 크기의 벡터로 변환하는 신경망 모델
• 이러한 아키텍처는 일반적으로 시퀀스 데이터의 전체 내용을 요약하여 단일 벡터 표현을 생성할 때 사용
• 이 벡터는 시퀀스의 중요한 특징을 포착하고, 시퀀스 내의 다양한 요소 간의 관계를 반영

  1.텍스트 분류: 문장이나 문서 같은 텍스트 데이터를 입력으로 받아, 해당 텍스트의 의미를 요약하는 벡터로 변환한 후, 이 벡터를 사용하여 텍스트를 하나 또는 여러 범주로 분류

2.감성 분석: 사용자 리뷰나 의견 등의 텍스트 시퀀스로부터 긍정적, 중립적, 또는 부정적 감성을 표현하는 벡터를 생성 3.음성 인식: 오디오 신호 시퀀스를 벡터로 변환하여, 오디오의 의미나 중요 특징을 요약

• 인코더-디코더(Encoder-Decoder) 아키텍처는 시퀀스 처리 작업에 널리 사용되는 신경망 구조
• Encoder: 입력 시퀀스를 받아들여 고정된 길이의 컨텍스트 벡터(context vector)로 변환
• Decoder:인코더로부터 받은 컨텍스트 벡터를 사용하여 출력 시퀀스를 생성 디코더는 각 시간 단계에서의 출력을 이전 시간 단계의 출력(또는 입력)과 결합하여 다음 출력을 생성

1.
import tensorflow as tf
import numpy as np



2.
# time stamp 데이터를 만들어보자
X = []
Y = []
for i in range(6):
    lst = list(range(i, i+4))

    X.append(list(map(lambda c: [c/10], lst)))
    Y.append((i+4)/ 10)

X = np.array(X)
Y = np.array(Y)
for i in range(len(X)):
    print(X[i], Y[i])

# 출력 형태
[[0. ]
 [0.1]
 [0.2]
 [0.3]] 0.4
[[0.1]
 [0.2]
 [0.3]
 [0.4]] 0.5






3.# simple RNN 구성
model = tf.keras.Sequential([
    tf.keras.layers.SimpleRNN(units=10, return_sequences= False, input_shape =[4, 1]),
    #input_shape 4,1뜻은   timesteps4,  input_dim 1
    #units: simpleRNN 레이어에 존재하는 뉴런의 수
    #return_sequences는 출력으로 시퀀스 전체를 출력할지 여부
    tf.keras.layers.Dense(1)
])

#출력
model.compile(optimizer='adam', loss='mse')
model.summary()
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 simple_rnn (SimpleRNN)      (None, 10)                120       

 dense (Dense)               (None, 1)                 11        


4.# 학습
model.fit(X, Y, epochs= 100, verbose=0)



5.예측결과 확인
# 예측 결과 - 좋지 않다.
model.predict(np.array([[[0.6], [0.7], [0.8], [0.9]]]))
# 출력 array([[0.7918824]], dtype=float32)

model.predict(np.array([[[-0.1], [0.0], [0.1], [0.2]]]))
# 출력 array([[0.34469157]], dtype=float32)







6. 모델 복잡하게
# 모델을 복잡하게
model = tf.keras.Sequential([
    tf.keras.layers.SimpleRNN(units=10, return_sequences=True, input_shape = [4,1]),
    tf.keras.layers.SimpleRNN(units=10, return_sequences=True, input_shape = [4,1]),
    tf.keras.layers.SimpleRNN(units=10, return_sequences=True, input_shape = [4,1]),
    tf.keras.layers.SimpleRNN(units=10, return_sequences=False, input_shape = [4,1]),
    tf.keras.layers.Dense(1)

])
model.compile(optimizer='adam', loss = 'mse')
model.summary()
# 출력
Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 simple_rnn_1 (SimpleRNN)    (None, 4, 10)             120       

 simple_rnn_2 (SimpleRNN)    (None, 4, 10)             210       

 simple_rnn_3 (SimpleRNN)    (None, 4, 10)             210       

 simple_rnn_4 (SimpleRNN)    (None, 10)                210       

 dense_1 (Dense)             (None, 1)                 11        



7. 다시훈련
 model.fit(X, Y, epochs=100, verbose=1)


8. 결과 확인(이전보다 좋아졌다.)
# 결과 출력
model.predict(np.array([[[0.6],[0.7],[0.8],[0.9]]]))
#출력 array([[0.9083353]], dtype=float32)



                                                         # simple RNN의 단점
# 입력 데이터가 길어지면 학습 능력이 덜어진다. -Long-Term Dependency
# 현재의 답을 얻기 위해 과거의 정보에 의존해야 하는 RNN이지만  과거 시점이 현재와 너무 멀어지면 문제를 풀기 어렵다.    

• 설치 참고링크 https://eunji7267.tistory.com/6

#텐서x가 성공적으로 생성
#requires_grad 속성이 True로 설정
#이 텐서에 대한 연산이 추적되며, 기울기 계산이 가능
x = torch.tensor(3.5, requires_grad= True) # grad는 gradient 기울기
print(x)
#출력
# tensor(3.5000, requires_grad=True)




y = (x-1) * (x-2) * (x-3)
print(y)
#출력
# tensor(1.8750, grad_fn=<MulBackward0>)




#잡한 신경망에서 기울기를 계산할 때 매우 유용
y.backward()# y에 대한 역전파(backpropagation)를 수행  모든 텐서에 대한 기울기가 계산

x.grad # y.backward()가 호출되기 전까지는 None이며, y.backward() 호출 후에는 x에 대한 y의 기울기 값이 저장


#요약 backward는 y에 대한 기울기 계산하는 명령어
#grad는 x의 기울기 값을 조회
#출력 tensor(5.7500)


-------------------------------



a = torch.tensor(2.0, requires_grad= True)
b = torch.tensor(1.0, requires_grad= True)

x = 2*a + 3*b
y = 5*a*a + 3*b*b*b
z = 2*x + 3*y


z.backward() #a.grad는 z를 a로 편미분한 값
print(a.grad)
#tensor(64.)


print(b.grad)#b.grad는 z를 b
#출력 tensor(33.)

2. pytorch를 이용한 mnist 데이터 분류

1. 임폴트
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim  # 수정된 부분
from torchvision import datasets, transforms
import matplotlib.pyplot as plt







2. 컴퓨팅 디바이스를 설정
is_cuda = torch.cuda.is_available() #CUDA가 사용 가능한 GPU가 있는지 확인
device = torch.device('cuda' if is_cuda else 'cpu')

print(device)





3.딥러닝 모델을 학습시키기 위해 필요한 하이퍼파라미터들을 설정
batch_size = 50#한 번의 학습(iteration)에 사용될 데이터의 수를 설정합니다. 즉, 네트워크를 통해 한 번에 50개의 데이터 샘플이 전파
learning_rate = 0.0001 #습률은 옵티마이저가 모델의 가중치를 업데이트할 때 얼마나 큰 단계를 밟을지를 결정
#옵티마이저는 딥러닝에서 모델의 가중치를 업데이트하는 방법을 정의하는 컴포넌트

epoch_num = 15






4.PyTorch의 torchvision 라이브러리를 사용하여 MNIST 데이터셋을 다운로드
train_data = datasets.MNIST(root = './data',
                            train = True,
                            download = True,
                            transform = transforms.ToTensor())

test_data = datasets.MNIST(root = './data',
                           train = False,
                           download = True,
                           transform = transforms.ToTensor())



5. 길이 확인
len(train_data), len(test_data)
# 결과 (60000, 10000)



6. 이미지 출력
image, label = train_data[0]#첫 번째 이미지와 레이블을 가져 가져온다.
plt.imshow(image.squeeze().numpy(), cmap = 'gray')
#imshow 함수는 이미지를 화면에 출력
#image.squeeze()는 차원이 1인 축을 제거하여 이미지 텐서의 차원을 줄인다.
#축을 제거하는 이유는 데이터의 형태를 간소화하고, 시각화나 다른 연산을 수행

#데이터가 배치 크기, 높이, 너비, 채널 수를 포함하는 4차원 텐서로 저장되어 있을 때,
#단일 이미지를 선택하면 그 결과는 [1, 높이, 너비, 채널 수]와 같은 4차원 텐서가 된다.. 여기서 첫 번째 차원의 크기는 1



plt.title('Label : %s'% label)
plt.show()




7.DataLoader 클래스를 사용하여 train_data와 test_data 데이터셋을 위한 데이터 로더
train_loader = torch.utils.data.DataLoader(dataset = train_data,
                                           batch_size = batch_size,#한 번에 로드할 데이터의 수를 지정, 변수의 값을 사용
                                           shuffle = True)#데이터를 로드할 때 데이터셋을 무작위로 섞을지 여부를 결정

test_loader = torch.utils.data.DataLoader(dataset = test_data,
                                          batch_size = batch_size,
                                          shuffle = True)


 8.train_loader에서 첫 번째 배치를 가져오는 과정
#train_loader는 PyTorch의 DataLoader 객체이며, 이터레이터로 변환한 후 __next__() 메서드를 사용하여 첫 번째 배치를 가져온다,.
first_batch = train_loader.__iter__().__next__()



9.len(train_loader)
#출력 1200


10. 타입확인
type(first_batch[0])
# 출력 torch.Tensor

11.len(first_batch[0])
#출력 50



12.레이블의 차원과 크기를 확인
first_batch[0].shape, first_batch[1].shape

#텐서는 배치 내의 이미지 데이터
#50은 배치 크기를 의미하며, 한 번에 로드된 이미지의 수
#1은 이미지의 채널 수
#28, 28은 각 이미지의 높이와 너비




13.PyTorch를 사용하여 Convolutional Neural Network (CNN) 모델을 정의하는 예제
import torch
import torch.nn as nn
import torch.nn.functional as F


class CNN(nn.Module):
    def __init__(self): #모델의 구조를 정의
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1, padding='same')
        # 1개의 채널을 입력으로 받고, 32개의 필터를 가진 3x3 커널을 사용하는 convolutional layer

        self.conv2 = nn.Conv2d(32, 64, 3, 1, padding = 'same')
        #32개의 채널을 입력으로 받고, 64개의 필터를 가진 3x3 커널을 사용하는 또 다른 convolutional layer 패딩은 역시 'same'

        self.dropout = nn.Dropout2d(0.25)
        #드롭아웃을 적용하는 레이어로, 오버피팅을 방지하기 위해 사용

        self.fc1 = nn.Linear(3136, 1000)
        #Fully connected layer로, 입력 뉴런의 수는 3136개, 출력 뉴런의 수는 1000개

        self.fc2 = nn.Linear(1000, 10)
        #또 다른 fully connected layer로, 입력 뉴런의 수는 1000개, 출력 뉴런의 수는 10개


    def forward(self, x):#경망에서 입력 데이터를 받아 순방향으로 처리하여 최종 출력
        x = self.conv1(x)
        x = F.relu(x)
        #는 첫 번째 convolutional layer self.conv1를 통과. 이후, ReLU 활성화 함수

        x = F.max_pool2d(x, 2)
        #공간 차원을 줄이기 위해 2x2 크기의 max pooling을 적용


        x = self.conv2(x)
        x = F.relu(x)
        #Convolutional Layer: 데이터는 두 번째 convolutional layer self.conv2를 통과하고, 다시 ReLU 활성화 함수를 적용


        x = F.max_pool2d(x, 2)
           #다시 2x2 크기의 max pooling을 적용하여 공간 차원을 줄인다.

        x = self.dropout(x)
        #  #Dropout: 드롭아웃을 적용하여 오버피팅을 방지

        x = torch.flatten(x, 1)
        #Flatten: 데이터를 1차원으로 펼친다. 이는 fully connected layer에 입력하기 위한 준비 단계

        x = self.fc1(x)
        x = F.relu(x)
        #첫 번째 Fully Connected Layer: 데이터는 첫 번째 fully connected layer self.fc1를 통과하고, ReLU 활성화 함수를 적용

        x = self.fc2(x)

        output = F.log_softmax(x, dim = 1)
        # 마지막으로 log softmax 함수를 적용하여 클래스에 대한 로그 확률을 계산

        return output



14. PyTorch를 사용하여 신경망 모델을 초기화하고, 학습에 필요한 설정
model = CNN().to(device)
#CNN()은 위에서 정의한 신경망 모델의 인스턴스를 생성
#.to(device)는 모델의 모든 파라미터와 버퍼를 지정된 디바이스(device)로 이동
#device는 "cuda" (GPU를 사용) 또는 "cpu"일 수 있다  나는 GPU cuda 사용

optimizer = optim.Adam(model.parameters(), lr = learning_rate)
#ptim.Adam은 Adam 최적화 알고리즘을 사용하는 옵티마이저를 생성
#. Adam은 모멘텀과 RMSProp의 아이디어를 결합하여 효율적인 경사 하강 알고리즘을 제공
#lr=learning_rate는 학습률을 설정

criterion = nn.CrossEntropyLoss()
#nn.CrossEntropyLoss()는 크로스 엔트로피 손실 함수를 생성 이는 분류 문제에서 주로 사용되며, 모델의 출력과 실제 레이블 간의 차이를 계산



15. PyTorch를 사용하여 신경망 모델을 학습하는 과정을 구현. 주요 목적은 모델의 파라미터를 업데이트하여 손실 함수의 값을 최소화
model.train()
i = 1

for epoch in range(epoch_num):#외부 루프(for epoch in range(epoch_num):)는 에포크를 반복
    for data, target in train_loader:#내부 루프(for data, target in train_loader:)는 데이터 로더에서 배치를 반복

        data = data.to(device)
        #data와 target을 지정된 디바이스(device)로 이동

        target = target.to(device)
        optimizer.zero_grad()
        #옵티마이저의 기울기 버퍼를 0으로 초기화

        output = model(data)
        #모델을 통해 data를 전달하여 출력을 계산

        loss = criterion(output, target)
        #손실 함수를 사용하여 출력과 타겟 간의 손실을 계산
        loss.backward()
        #손실에 대한 기울기를 계산
        optimizer.step()
        #옵티마이저를 사용하여 모델의 파라미터를 업데이트

        if i%1000 ==0:
            print(i, loss.item())

        i +=1

        #1000 0.19806066155433655는 1000번째 배치에서의 손실 값이 약 0.198
        #2000 0.037925850600004196는 2000번 째 배치에서의 손실 값이 약 0.037925



16.PyTorch를 사용하여 학습된 신경망 모델의 성능을 테스트하는 과정
model.eval()#model.eval()은 모델을 평가 모드로 설정

correct = 0

for data, target in test_loader:
    data = data.to(device)#data와 target을 지정된 디바이스(device)로 이동
    target = target.to(device)
    output = model(data) #모델을 통해 data를 전달하여 출력을 계산
    prediction = output.data.max(1)[1] #모델 출력에서 가장 높은 값을 가진 인덱스를 반환
    # 1은 이 연산이 행(차원 1)을 따라 수행되어야 함을 의미
    #[1]은 인덱스를 선택

    correct += prediction.eq(target.data).sum() #변수는 총 맞은 예측의 수를 저장
    #eq는 "equal"의 줄임말로, 텐서의 각 요소가 다른 텐서의 해당 요소와 동일한지 여부를 나타내는 새로운 텐서를 반환

print(correct / 10000)



#출력 
#tensor(0.9918, device='cuda:0')

• 인공지능: 기계가 사람의 행동을 모방하는 기술
• 기계 학습: 기계가 일일이 코드로 명시하지 않은 동작을 데이터로부터 학습하여 실행할 수 있도록 하는 알고리즘을 개발하는 연구 분야
• 딥러닝: 기계 학습의 한 분야인 인공 신경망에 기반하여, 많은 양의 데이터를 학습해 뛰어난 성능을 이끌어내는 연구 분야

• 딥러닝은 빅데이터를 다루지 않는다.

• 영상을 분할하고 영상 해상도 조절

• 여기서 퍼셉트론은 지금의 딥러닝의 뉴런을 뜻한다.
• 잠깐 딥러닝의 XOR을 증명하지 못하는 암흑기가 존재했다.
• 역전파의 등장으로 XOR을 오류를 해결했다.
• gradient vanishing문제가 있었는데 이것을 해결하기 위한 여러 가지 방법들이 있다.

1. ReLU (Rectified Linear Unit): ReLU는 음수를 0으로 만들고, 양수는그대로 둔다. 이로 인해 비선형성을 도입하면서도 기울기 소실 문제를 완화

• 뉴런은 인공 신경망(ANN)의 기본 구성 요소이다.
• 뉴런은 신경망에서 다양한 패턴과 관계를 학습하는 역할
• 뉴런은 입력 데이터의 특정 특징에 반응하도록 학습되며, 신경망 전체에서 복잡한 패턴과 관계를 모델링

1 입력(Inputs): 뉴런에 들어오는 신호 이들은 다른 뉴런의 출력이거나, 외부 소스에서 온 데이터 2 가중치(Weights): 각 입력에 대해 할당된 가중치. 이 가중치는 해당 입력의 중요도 3 활성화 함수(Activation Function): 가중치가 적용된 입력의 합을 받아들여, 뉴런의 출력을 결정하는 함수 4 바이어스(Bias): 뉴런의 활성화 임계값을 조정하는 역할 5 출력(Output): 뉴런의 최종 출력 신호

• 레이어: 레이어는 딥러닝 모델에서 데이터를 처리하는 한 단계를 의미 각 레이어는 여러 개의 뉴런으로 구성되어 있으며, 이 뉴런들은 입력 데이터를 받아 가중치와 활성화 함수를 통해 변환된 후 다음 레이어로 전달
• 딥러닝 모델은 여러 레이어를 쌓아서 구성. 이를 "딥(Deep)"이라고 부르는 이유는 모델에 여러 층의 레이어가 존재
• Dense 레이어:완전 연결 레이어(Fully Connected Layer)는 가장 기본적인 레이어 유형, 이 레이어에서는 모든 입력 뉴런이 모든 출력 뉴런과 연결
• 모든 요소에 대한 가중치를 가지며, 이를 통해 입력 데이터의 선형 변환을 수행 그 후 활성화 함수를 적용하여 비선형성을 도입
• 얕은 신경망(Shallow Neural Network): 딥러닝 모델 중에서 비교적 적은 수의 은닉층을 가지고 있는 모델을 일반적으로 얕은 신경망은 입력층, 하나 또는 소수의 은닉층, 그리고 출력층으로 구성
• 과적합 위험이 낮다 파라미터가 적기 때문
• 얕은 신경망은 주로 간단한 문제나 데이터가 복잡하지 않을 때 사용

• Fully-conmnected layer(완전 연결 계층) 또는 Dense layer은 신경망에서 가장 기본적인 레이어이다.

• Fully-connected layer는 입력 데이터가 1차원 배열로 표현될 수 있는 경우에 적합

• 장점: 간단하고 범용적이며 복잡한 관계와 패턴을 학습

• 단점: 많은 파라미터를 가지고 있어서 모델의 크기가 커지고, 과적합의 위험이 있다. 입력 데이터의 크기가 클 때 비효율적

• 예를 들어, 28x28 픽셀의 이미지를 입력으로 사용하는 경우, 입력 계층에는 784(28x28)개의 뉴런

• 가중치와 바이어스: 입력 계층의 뉴런은 가중치와 바이어스를 가지고 있지 않다

• 활성화 함수: 입력 계층에는 활성화 함수가 적용되지 않는다.

• 입력 계층은 외부 세계로부터 데이터를 받아들이고, 이를 신경망 내부로 전달

• 신경망의 입력 계층과 출력 계층 사이에 위치하는 계층, 이 계층들은 신경망이 복잡한 패턴과 관계를 학습하는 데 도움을 주며, 모델의 예측 능력을 향상

• 은닉 계층의 뉴런 수는 사용자가 정의

• 은닉 계층의 각 뉴런은 가중치와 바이어스를 가지며, 이를 통해 입력 데이터를 변환

• 은닉 계층에는 비선형 활성화 함수가 적용되어, 모델이 복잡한 비선형 관계를 학습

• 무 많은 은닉 뉴런이나 계층을 사용하면 과적합(overfitting)이 발생할 위험이 있으며, 학습 시간이 길어진다.

• 모델의 최종 예측 결과를 생성

• 회귀 문제에서는 일반적으로 선형 활성화 함수를 사용하고, 분류 문제에서는 softmax 또는 sigmoid 활성화 함수를 사용

• 예측 생성: 출력 계층은 모델의 최종 예측 결과를 생성

• 손실 계산: 출력 계층의 예측과 실제 레이블 간의 차이를 계산하여 손실을 도출

• 이진 분류: 출력 계층에는 하나의 뉴런이 있고, 활성화 함수로는 sigmoid를 사용

• 다중 클래스 분류: 출력 계층에는 클래스의 수만큼 뉴런이 있고, 활성화 함수로는 softmax를 사용

• 회귀: 출력 계층에는 하나의 뉴런이 있고, 활성화 함수로는 선형 함수(또는 아무 함수도 사용하지 않음)를 사용

• MSE(Mean Squared Error) :회귀 문제에서 주로 사용되는 손실 함수

• MSE는 모델의 예측값과 실제값의 차이를 제곱하여 평균을 내는 방식으로 계산

• MSE는 모델의 예측 오차를 정량화하는 데 사용되며, 이 값을 최소화하는 것이 모델 학습의 목표

• MSE는 항상 0 이상의 값을 가집니다. MSE가 0에 가까울수록 모델의 예측이 실제값에 가깝다

• MSE는 제곱을 포함하기 때문에, 큰 오차에 대해서는 작은 오차보다 더 큰 벌칙을 부과

• MSE는 미분 가능하므로, 경사 하강법과 같은 최적화 알고리즘을 사용하여 모델의 가중치를 업데이트하는 데 유용

• 벡터의 내적(dot product):두 벡터의 상응하는 요소들을 곱한 후 그 결과를 모두 더하는 연산

• 내적은 벡터의 방향과 크기에 대한 정보를 포함하며, 두 벡터 간의 각도를 계산

• 신경망에서 내적은 입력 벡터와 가중치 벡터 간의 선형 결합을 계산하는 데 사용

• 얕은 신경망을 사용한 회귀에서는 선형 회귀보다 더 복잡한 패턴을 학습할 수 있는 능력이 있다

• 은닉 계층을 통한 비선형 변환 덕분

• 출력 계층 자체는 선형 회귀와 유사한 선형 변환을 수행합니다.

• 범주형? 두 개 이상의 범주(카테고리)로 나눌 수 있는 데이터 유형을 말한다. 이러한 데이터는 수치적이지 않고, 각 범주는 명확하게 구분
• 범주형 데이터는 명목형, 순서형으로 나눈다.
• 명목형 데이터(Nominal Data): 범주 간에 순서나 등급이 없는 경우 (예: 국가 이름, 성별)
• 순서형 데이터(Ordinal Data): 범주 간에 순서나 등급이 있는 경우 (예: 학점 (A, B, C, D, F), 서비스 만족도 (매우 만족, 만족, 보통, 불만족, 매우 불만족))
• 머신러닝 모델은 주로 수치 데이터를 입력으로 받기 때문에, 범주형 데이터를 사용하기 전에 적절한 전처리
• 처리 방법에는 원-핫 인코딩(One-Hot Encoding), 레이블 인코딩(Label Encoding)

• 손실 함수는 모델의 예측이 실제 레이블과 얼마나 잘 일치하는지를 측정

• Softmax다중 클래스 분류 문제에서 사용되는 활성화 함수

• softmax 함수는 신경망의 원시 출력(또는 로짓)을 입력으로 받아, 각 클래스에 대한 확률을 타나내는 값으로 변환한다.

• Softmax 함수는 로짓 벡터의 최댓값에 가장 높은 확률을 할당하며, 다른 값들은 상대적으로 낮은 확률을 할당

• 두 함수는 모두 하나의 입력을 받아 0과 1 사이의 값을 출력
• 그러나 Sigmoid 함수는 하나의 출력만 생성하는 반면, 2-클래스 Softmax 함수는 두 개의 출력을 생성
• Sigmoid 함수는 출력값이 0.5보다 크면 클래스 1, 작으면 클래스 0으로 분류
• 2-클래스 Softmax 함수는 두 출력 중 더 큰 값을 가진 클래스를 선택
• 요약:두 함수는 수학적으로 동일한 결과를 낼 수 있지만, 구현과 출력 방식에서 차이

import numpy as np
import pandas as pd
import os
import glob
import matplotlib.pyplot as plt
import seaborn as sns

import tensorflow as tf
from tensorflow.keras import Sequential, models
from tensorflow.keras.layers import Flatten, Dense, Conv2D, MaxPool2D
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix


import zipfile
content_zip = zipfile.ZipFile('./data/archive (31).zip')
content_zip.extractall("./data")

content_zip.close()



1.특정 디렉토리 구조를 가진 이미지 데이터셋을 탐색하여, 이미지의 경로, 마스크 착용 상태, 이미지가 있는 위치를 저장한다.
path = "./data/Face Mask Dataset/"

#변수 초기화
dataset = {"image_path": [], "mask_status": [], "where": []}

for where in os.listdir(path):# path 디렉토리 내의 모든 하위 디렉토리를 순회한다. 각 하위 데렉토리는 where를 나타낸다.
    for status in os.listdir(path + "/" + where):
        for image in glob.glob(path + "/" + where + "/" + status + "/" + "*.png"):
            #디렉토리 내의 모든 PNG 이미지 파일을 찾아서 순회한다. 여기서 glob.glob 함수를 사용하여 특정 패턴에 맞는 파일 경로를 찾는다.

            dataset["image_path"].append(image)
            dataset["mask_status"].append(status)
            dataset["where"].append(where)


 2. 추가하기
for where in os.listdir(path):  # Train, Validation, Test
    where_path = os.path.join(path, where)
    if os.path.isdir(where_path):
        for status in ['WithMask', 'WithoutMask']:
            status_path = os.path.join(where_path, status)
            if os.path.isdir(status_path):
                for image in glob.glob(status_path + "/*.png"):
                    dataset["image_path"].append(image)
                    dataset["mask_status"].append(status)
                    dataset["where"].append(where)



 3. 데이터 프레임
 dataset = pd.DataFrame(dataset)
dataset.head()



 4. With Mask와 Without Mask 갯수 확인
 print('With Mask:', dataset.value_counts("mask_status")[0])
print('Without Mask:', dataset.value_counts("mask_status")[1])

sns.countplot(x=dataset["mask_status"]);       
#출력 개수
#With Mask: 11818
#Without Mask: 11766

• WithMask와 WithoutMask

Mask man2

• 어떤 이미지들이 존재하는지 확인해보자

1. 이미지 확인
# 랜덤하게 어떤 그림들이 있느지 보자
import cv2
plt.figure(figsize=(15, 10))
for i in range(9):
    random = np.random.randint(1, len(dataset))
    plt.subplot(3, 3, i + 1)# 3*3 격자의 i +1 번쨰 위치에 서브플롯 생성
    plt.imshow(cv2.imread(dataset.loc[random, "image_path"]))#OpenCV의 imread 함수를 사용하여 데이터셋에서 무작위로 선택된 이미지를 읽어온다.
    plt.title(dataset.loc[random, "mask_status"], size=15)
    #제목은 데이터셋에서 무작위로 선택된 행으 ㅣmask_status컬럼 값을 사용한다.

    plt.xticks([])
    plt.yticks([])
plt.show()

• 데이터 프레임

  Train / test / validation으로 나눌 필요는 없다.

  train_df = dataset[dataset["where"] =="Train"] test_df = dataset[dataset["where"]== 'Test'] valid_df = dataset[dataset['where']=='Validation'] train_df.head(5)

• Train, Test, Validation 갯수 확인

  plt.figure(figsize=(15,5))
  plt.subplot(1, 3, 1)# 1행 3열 첫번째
  sns.countplot(x=train_df['mask_status'])
  plt.title('Training Dataset', size=10)
  

plt.subplot(1, 3, 2)#1행 3열 2번째 sns.countplot(x= test_df["mask_status"]) plt.title("Test Dataset", size=10)

plt.subplot(1, 3, 3) sns.countplot(x=valid_df["mask_status"]) plt.title("Validation Dataset", size=10)

plt.show()

![](https://velog.velcdn.com/images/vitamin_penguin/post/517c911b-63c1-4bb2-b1f1-a595a22d3593/image.png)

- 인덱스 정리
train_df = train_df.reset_index().drop('index', axis=1)
train_df.head()
![](https://velog.velcdn.com/images/vitamin_penguin/post/26e62e11-b649-4368-87a7-08e70d271ade/image.png)

```python
1. 데이터 전처리
#이미지 데이터 전처리를 한다.
#주어진 학습 데이터 세트 train_df 내의 모든 이미지에 대해 다음과 같은 작업을 수행한다.

data=  []
image_size =150

for i in range(len(train_df)):
    img_array = cv2.imread(train_df['image_path'][i], cv2.IMREAD_GRAYSCALE) # i는 현재 처리중인 이미지의 위치를 나타낸다.
    #OpenCV의 cv2.imread 함수를 사용하여 이미지를 읽는다.
    #옵션은 이미지를 그레이스케일로 읽어들인다.
    #읽어들인 이미지의 크기를 가로세로 조정
    #150임으로 150*150 픽셀의 크기로 조정

#     train_df['image_path'][i]
#      image_path 컬럼의 i 즉  이미지를 가져온다
    new_image_array = cv2.resize(img_array, (image_size, image_size))
    #이미지 크기를 조정하는 역할을 한다.
    #cv2.resize는 OpenCV의 함수로 첫 번째 인자로 주어진 이미지으 ㅣ크기를 두번째 인자로 주어진 크기로 조정한다.
    #image_size, image_size)) 조정할 이미지의 새로운 크기를 나타낸다.




    if train_df['mask_status'][i] == "WithMask":
     #i번째 이미지가 마스크를 착용하고 있다면 라발 1을 data리스트에 추가
        data.append([new_image_array, 1])

    else:
        data.append([new_image_array, 0])




 2.data(이미지)를 한개 숫자로 출력해보자       
 data[0]

 #출력
 [array([[238, 238, 238, ..., 199, 199, 199],
        [238, 238, 238, ..., 197, 197, 197],
        [237, 237, 238, ..., 194, 194, 195],
        ...,
        [236, 236, 236, ..., 151, 151, 152],
        [235, 235, 235, ..., 151, 152, 152],
        [235, 235, 235, ..., 151, 152, 152]], dtype=uint8),
 1]






 3. data 이미지를 무작위로 섞고 섞인리스트의 첫 번째 요소를 출력
np.random.shuffle(data)
data[0]

#출력
[array([[254, 254, 254, ...,  93, 147, 194],
        [254, 254, 254, ...,  78, 129, 176],
        [254, 254, 254, ...,  63, 108, 152],
        ...,
        [249, 249, 250, ..., 111, 159, 197],
        [249, 250, 250, ...,  59, 105, 146],
        [250, 250, 250, ...,  22,  61, 101]], dtype=uint8),
 0]




 #4. 이미지가 섞여있는지 확인해보자
 #저장된 이미지 데이터를 시각화하기 위한 것

fig, ax = plt.subplots(2, 3, figsize=(10, 6))

for row in range(2):
    for col in range(3):
        #2행 3열의 서브플롯 순회한다.  row는 행인덱스, col은 열 인덱스

        image_index = row * 100 + col# 사용할 이미지 인덱스 계산 이경우 행마다 100개씩 건너뛰어 이미지를 선택한다.

        ax[row, col].axis('off')# 현재 서브플롯의 축을 끈다. 틱 레이블과 테두리를 제거하기위함
        ax[row, col].imshow(data[image_index][0], cmap = 'gray')# 현재서브플롯에 이미지 표시 (인덱스 0에 해당하는 원소를 가져온다.)

        if data[image_index][1] == 0:
            ax[row, col].set_title("Without Mask")
        else:
            ax[row, col].set_title("With Mask")

• X,y 데이터로 저장 X = [] y = []

for image in data: X.append(image[0]) y.append(image[1]) X = np.array(X) y = np.array(y)

• 트레인 데이터로 다시 나누기 #트레인 데이터로 다시 나누기 X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2,

                                             random_state= 13)

mask man 3

1.Convolutional Neural Network (CNN) 모델을 구축
from tensorflow.keras import layers, models


#Convolutional Neural Network (CNN) 모델을 구축
model = models.Sequential(
    [
        layers.Conv2D( #Conv2D Layer: 32개의 필터와 5x5 크기의 커널을 사용하는 convolutional layer
            32, kernel_size=(5,5), strides= (1,1), padding = "same",
            activation = "relu", input_shape = (150, 150, 1)),
        #strides=(1, 1)은 컨볼루션 연산 시 필터의 이동 간격
        #padding="same"은 입력 이미지의 크기를 유지하기 위해 패딩을 추가
        #activation="relu"는 ReLU 활성화 함수
        #input_shape=(150, 150, 1)는 모델이 받아들일 수 있는 입력 이미지의 크기와 채널 수를 지정

        layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)),
        #MaxPooling2D Layer: 또 다른 최대 풀링 레이어로, 2x2 크기의 풀링 윈도우를 사용


        layers.Conv2D(64, (2, 2), activation = "relu", padding="same"),
        #Conv2D Layer: 64개의 필터와 2x2 크기의 커널을 사용하는 또 다른 convolutional layer입니다. activation="relu"와 padding="same"는 이전과 동일

        layers.MaxPooling2D(pool_size=(2,2)),
        #MaxPooling2D Layer: 또 다른 최대 풀링 레이어로, 2x2 크기의 풀링 윈도우를 사
        layers.Dropout(0.25),

        Dropout Layer:# 과적합을 방지하기 위해 뉴런의 일부를 무작위로 비활성화하는 드롭아웃 레이어

        layers.Flatten(),
        #Flatten Layer: 다차원의 피처맵을 1차원으로 변환하여 완전 연결된 레이어에 전달

        layers.Dense(1000, activation = 'relu'),
        #Dense Layer: 1000개의 뉴런을 가지는 완전 연결된 레이어입니다. 활성화 함수로는 ReLU
        layers.Dense(1, activation = 'sigmoid'),
        #Dense Layer: 1개의 뉴런을 가지는 완전 연결된 레이어로, 활성화 함수로는 시그모이드가 사용
        #이 레이어는 최종 출력을 생성하며, 시그모이드 함수를 사용함으로써 출력값은 0과 1

    ]
)




#2. 컴파일
#신경망 모델을 컴파일 최적화 알고리즘, 손실 함수, 평가 지표를 설정
model.compile(
    optimizer="adam", loss = tf.keras.losses.BinaryCrossentropy(),
    #optimizer: 최적화 알고리즘을 설정합니다. 여기서는 "adam" 최적화 알고리즘을 사용
    #Adam은 경사 하강법의 변형으로, 학습률을 조정하면서 모델의 가중치를 업데이트
    #loss: 손실 함수를 설정 이진 분류 문제에 적합한 BinaryCrossentropy 손실 함수를 사용

    metrics= ["accuracy"]
#     metrics: 모델의 성능을 평가하는 데 사용할 지표를 설정. 여기서는 "accuracy" (정확도)를 사용하여 모델의 예측이 얼마나 정확한지 평가

)






3.신경망 모델을 학습시키기 전 데이터를 전처리하고 그 다음 모델을 학습시키는 과정
X_train = X_train.reshape(len(X_train), X_train.shape[1], X_train.shape[2], 1)
#X_train은 훈련 데이터의 피처(이미지)를 담고 있는 넘파이 배열
#reshape 함수는 배열의 형태를 변경합니다. 이 경우, 각 이미지의 형태를 (높이, 너비, 채널)로 변경
#흑백 이미지의 경우 채널 수는 1이므로 마지막 차원을 1로 설정
#len(X_train)은 훈련 데이터의 샘플 수를 나타냅니다.
#X_train.shape[1]과 X_train.shape[2]는 각각 이미지의 높이와 너비

X_val = X_val.reshape(len(X_val), X_val.shape[1], X_val.shape[2], 1)
history = model.fit(X_train, y_train, epochs=4, batch_size=32)




4. 모델 성능 평가 확인
# Validation accuracy가 나쁘지 않다.
# model.evaluate 함수는 신경망 모델의 성능을 평가하는 데 사용
# 모델이 얼마나 잘 예측하는지를 측정하기 위해 손실 함수의 값을 계산하고, 추가로 설정된 평가 지표(예: 정확도)를 계산

model.evaluate(X_val, y_val)
#X_val: 검증 데이터 세트의 피처(이미지)
#y_val: 검증 데이터 세트의 실제 라벨
#첫 번째 요소는 모델의 손실값으로, 낮을수록 좋다
#두 번째 요소는 모델의 정확도로, 0에서 1 사이의 값이며 높을수록 좋다
#출력
[0.31497207283973694, 0.8675000071525574]






5.precision, recall, f1-score support 확인
#상대적으로 0에 대한 recall이 조금 떨어진다.
#이 코드는 훈련된 신경망 모델을 사용하여 검증 데이터 세트 X_val에 대한 예측을 수행하고, 이 예측의 성능을 평가

prediction = (model.predict(X_val) > 0.5).astype("int32")
#model.predict(X_val)은 X_val에 있는 각 이미지에 대해 모델이 마스크를 착용하고 있다고 예측하는 확률을 반환
#확률이 0.5보다 큰 경우를 True (1)로, 그렇지 않으면 False (0)로 변환

print(classification_report(y_val, prediction))
#모델의 성능을 평가하기 위해 주로 사용되는 여러 지표를 계산하여 출력

print(confusion_matrix(y_val, prediction))
#confusion_matrix는 모델의 성능을 평가하기 위한 혼동 행렬을 계산하여 출력
#혼동 행렬은 실제 라벨과 예측 라벨의 관계를 나타낸다.

#출력
125/125 [==============================] - 10s 82ms/step
              precision    recall  f1-score   support

           0       0.98      0.75      0.85      2010
           1       0.80      0.98      0.88      1990

    accuracy                           0.87      4000
   macro avg       0.89      0.87      0.87      4000
weighted avg       0.89      0.87      0.87      4000

[[1516  494]
 [  36 1954]]






6. 틀린것 추리기
 #틀린것만 추리기
#위 X_val 코드를 실행하지 않아서 강의와 결과값이 다르다.

wrong_result = []

for n in range(0, len(y_val)):
    if prediction[n] != y_val[n]:
        wrong_result.append(n)

len(wrong_result)
# 530이 나오는데 이것슨 정답이 아니다.





7. 이미지 시각화
import random

samples = random.choices(population = wrong_result, k = 6)
plt.figure(figsize=(14,12))

for idx, n in enumerate(samples):
    plt.subplot(3, 2, idx + 1)
    plt.imshow(X_val[n].reshape(150, 150), interpolation = "nearest")
    plt.title(prediction[n])
    plt.axis("off")

plt.show()

1. Mnist 데이터 가져오기
import tensorflow as tf 
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
X_train, X_test = x_train/255, x_test/255 #이미지 데이저 정규화  픽셀 값을 0~255 사이의 정수에서 0~1 사이의 부동소수점 숫자로 변환

    #이미지 데이터의 형태로 변환한다.
    #흑백 이미지 사용위해 채널 1로 설정
X_train = X_train.reshape((60000, 28, 28, 1))
X_test = X_test.reshape((10000, 28, 28, 1))





2. 구조를 간단히 가지고 오기
구조를 간단히 가지고 오기
#텐서플로 사용하여 (Convolutional Neural Network, CNN)모델 정의 한다.
from tensorflow.keras import layers, models

model = models.Sequential([
    #CConv2D: 2D 컨볼루션 레이어
    layers.Conv2D(3, kernel_size = (3,3), strides=(1,1),       
                 padding='same', activation = 'relu',
                 input_shape =(28,28,1)),
     #이 레이어는 입력 이미지에 3*3 크기의 필터 적용한다.
    #3은 필터(커널)의 개수로, 이는 모델이 학습할 특징의 개수이다.
    #strides(1,1)는 필터가 이미지 위를 이동할 때의 간격을 나타낸다.
   #padding은 입,출 크기를 동이랗게 유지하기 위해 입력 주변에 패딩을 추가한다.
   #activation은 활성화 함수로 ReLU를 사용한다.


    layers.MaxPool2D(pool_size=(2,2), strides=(2,2)),
    #최대 풀링 레이어
    #이 레이어는 2*2 영역에서 최댓값을 선택하여 특징 맵의 크기를 줄인다.
    #pool_size는 풀링 영역 크기를 나타낸다.
    #strides는 풀링 영역이 이동할 때의 간격을 나타낸다.

    layers.Dropout(0.25),
    #드롭아웃 레이어 : 이 레이어는 모델을 학습할 때 무작위로 뉴런의 일부를 끊어 과적합을 방지한다.
    #0.25는 드롭아웃 비율로ㅡ 각 업데이트에서 25%의 뉴런을 무작위로 끊는다.

    layers.Flatten(),
    #이 레이어는 다차원 특징 맵을 1차원으로 변환하여 완전 연결 레이어에 전달

    layers.Dense(1000, activation='relu'),
    layers.Dense(10, activation = 'softmax')
    #Dense: 완전 연결 레이어
    #첫 연결 레이어는 1000개의 뉴런을 가지고 있고 ReLU 활성화 함수 사용
    #두 번째 완전 연결 레이어는 10개의 뉴런을 가지고 있고 softmax 활성화 함수 사용

])






3. 모델 구조 요약 

model.summary()


#출력결과
Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_1 (Conv2D)           (None, 28, 28, 3)         30        

 max_pooling2d_1 (MaxPoolin  (None, 14, 14, 3)         0         
 g2D)                                                            

 dropout_1 (Dropout)         (None, 14, 14, 3)         0         

 flatten_1 (Flatten)         (None, 588)               0         

 dense_2 (Dense)             (None, 1000)              589000    

 dense_3 (Dense)             (None, 10)                10010     


#출력 결과 요약
#1. conv2d_1 (Conv2D)           (None, 28, 28, 3)         30     
# 이 레이어는 입력 이미지에 3*3 크기의 3개 필터 적용한다. 바비어스 항이 있으므로 총 파라미터 개수는 3*3*1*3+3 = 30개


#2. max_pooling2d_1 (MaxPooling2D)
#2*2 영역에서 최대값을 선택하여 크기를 줄인다. 출력의 크기는 입력의 절반이다.

#3. dropout_1 (Dropout)         (None, 14, 14, 3)         0
# 학습중에 뉴런을 무작위로 끊어 과적합을 방지한다.

#4. flatten_1 (Flatten)
#이 레이어는 다차원 입력을 1차원으로 평탄화한다. 14 *14 *3 =588


# 5.dense_2 (Dense)             (None, 1000)              589000    
# 이 완전 연결 레이어는 588개 입력과 1000개의 출력 뉴런을 가지고 있다.
# 파라미터 개수는 588*1000 + 1000 =589000개


#6. dense_3 (Dense)             (None, 10)                10010     
#1000개의 입력과 10개의 출력 뉴런을 가지고 있다. 파라미터는 1000*10+10 = 10010개




4. 구성한 레이더 확인
model.layers
[<keras.src.layers.convolutional.conv2d.Conv2D at 0x2354b439790>,
 <keras.src.layers.pooling.max_pooling2d.MaxPooling2D at 0x2354b439c40>,
 <keras.src.layers.regularization.dropout.Dropout at 0x2354a934d30>,
 <keras.src.layers.reshaping.flatten.Flatten at 0x2354b44b160>,
 <keras.src.layers.core.dense.Dense at 0x2354b44b430>,
 <keras.src.layers.core.dense.Dense at 0x2354b44b550>]





 5. 가중치 평균, 표준 편차 계산
 #아직 학습하지 않은 conv 레이어의 웨이트의 평균
#컨볼루션 뉴럴 네트워크 모델의 첫 번째 레이어의 가중치를 분석하는 코드이다.
#이 코드는 모델이 아직 학습되지 않았을때, 평균과 펴준편차를 계산한다.

conv = model.layers[0]# 모델의 첫 레이어 가져온다.
conv_weights = conv.weights[0].numpy()# 컨볼루션 레이어의 가중치를 넘파이 배열로 변환
#weights[0]는 가중치 텐서, [1]은 바이어스 텐서를 반환한다.


#가중치 평균, 표준 편차 계산
conv_weights.mean(), conv_weights.std()
#평균 0.093, 가중치 0.23
(0.09303552, 0.23132293)



6. 가중치시각화


import matplotlib.pyplot as plt

plt.hist(conv_weights.reshape(-1,1))
plt.xlabel('weights')
plt.ylabel('count')
plt.show()



7. 가중치 시각화
fig, ax = plt.subplots(1,3, figsize=(15,5))
for i in range(3):
    ax[i].imshow(conv_weights[:,:,0,i], vmin=-0.5, vmax=0.5)
    ax[i].axis('off')
plt.show()

8. 컨볼루션 네트워크 모델 컴파일하고 학습하기
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
              #최적화 알고리즘으로 Adam을 사용한다. adam은 경사 하강법의 변형으로 학습률을 자동으로 조정한다.
             metrics= ['accuracy'])
            #학습 과정에서 정확도를 평가 지표로 사용한다.

hist = model.fit(X_train, y_train, epochs=5, verbose=1,
                 #verbose=1 학습 과정을 상세하게 출력, 0은 출력하지 않음, 1은 진행 막대와 함께 출력, 2는 에포크당 한 줄씩 출력을 의미

                validation_data = (X_test, y_test))




9. 학습 후 convfilte의 변화
#컨볼루션 레이어의 필터 가중치 시각화
fig, ax = plt.subplots(1,3, figsize=(15,5))
for i in range(3):
    ax[i].imshow(conv_weights[:,:,0,i], vmin = -0.5, vmax = 0.5)
    #imshow 함수는 2D 배열 압력으로 받아서 이미지 표시한다.
    #ax[i]는 matplotlib의 subplot을 의미하며, i는 필터 인덱스이다.
    #conv_weights[:, :, 0, i]: 컨볼루션 레이어의 가중치에서 i번째 필터를 선택합
    #가중치는 (가로, 세로, 입력 채널, 필터 개수) 형태의 4차원 배열 
    ax[i].axis('off')

plt.show()

• 0번 데이터 5 plt.imshow(X_train[0], cmap='gray')

10. Conv 레이어에서 출력을 뽑는다.
inputs = X_train[0].reshape(-1, 28,28, 1)
conv_layer_output = tf.keras.Model(model.input, model.layers[0].output)
conv_layer_output.summary()
#출력
Model: "model"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_1_input (InputLayer  [(None, 28, 28, 1)]       0         
 )                                                               

 conv2d_1 (Conv2D)           (None, 28, 28, 3)         30        

=================================================================




11. 입력에 대한 feature map을 뽑는다.
feature_maps = conv_layer_output.predict(inputs)
feature_maps.shape
#출력
1/1 [==============================] - 0s 19ms/step
(1, 28, 28, 3)



12.
feature_maps[0,:,:, 0].shape
# 출력(28, 28)



13.Feature map이 본 숫자 5
fig, ax = plt.subplots(1,3, figsize=(15,5))
for i in range(3):
    ax[i].imshow(feature_maps[0, :, :, i])
    ax[i].axis('off')
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm_notebook



# 벡터 x에 대해 소프트맥스 함수를 계산한다.
def Softmax(x):
    x = np.subtract(x, np.max(x))
    #입력 벡터 x에서 최댓값을 빼서 값을 정규화 한다. 이는 수치적 안정성을 개선하기 위한것

    ex = np.exp(x)
    #지수 함수 적용: 정규화된 입력 벡터의 각 요소에 지수 함수를 적용한다.

    return ex / np.sum(ex)







# 3차원 넘파이 배열 X를 생성하고 특정 패턴으로 채운다. 
# 배열의 차원은 (5,5,5)이다.
# 각 2차원 슬라이스 (X[:,:,i])는 5*5 크기의 행렬로 초기화

X  = np.zeros((5,5,5))

X[:, :, 0] = [[0,1,1,0,0], [0,0,1,0,0], [0,0,1,0,0], [0,0,1,0,0], [0,1,1,1,0]]
X[:, :, 1] = [[1,1,1,1,0], [0,0,0,0,1], [0,1,1,1,0], [1,0,0,0,0], [1,1,1,1,1]]
X[:, :, 2] = [[1,1,1,1,0], [0,0,0,0,1], [0,1,1,1,0], [0,0,0,0,1], [1,1,1,1,0]]
X[:, :, 3] = [[0,0,0,1,0], [0,0,1,1,0], [0,1,0,1,0], [1,1,1,1,1], [0,0,0,1,0]]
X[:, :, 4] = [[1,1,1,1,1], [1,0,0,0,0], [1,1,1,1,0], [0,0,0,0,1], [1,1,1,1,0]]



 # 시각화
plt.figure(figsize=(12,4))
for n in range(5):
    plt.subplot(1, 5, n+1)
    plt.imshow(X[:,:,n])
plt.show()

예제2(ReLU 이용한 정방향 계산)

1. ReLU 함수 정의
import numpy as np
from tqdm.notebook import tqdm

# ReLU 함수 정의
def ReLU(x):
    return np.maximum(0, x)

# Softmax 함수 정의
def Softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum(axis=0)





2.ReLU를 이용한 정방향 계산
# 4개의 신경망 출력 계산한다.
# 각 층은 선형 변환후 ReLU 활성화 함수를 적용하고 마지막층은 softmax 활성화 함수를 적용한다.

def calcOutput_ReLU(W1, W2, W3, W4, x): # W1,2,3,4는 각 층의 가중치 행렬이다.
    v1 = np.matmul(W1, x) # v1을 구하기 위해 입력 x에 가중치 W1을 곱한다.
    y1 = ReLU(v1)# y1을 계산하기 위해 v1에 ReLU활성화 함수를 적용한다.
    v2 = np.matmul(W2, y1)# 
    y2 = ReLU(v2)
    v3 = np.matmul(W3, y2)
    y3 = ReLU(v3)
    v = np.matmul(W4, y3)
    y = Softmax(v)#마지막으로 y를 계산하기위해 v에 소프트맥스 활성화 함수를 적용

    return y,v1, v2, v3, y1, y2, y3




3. 역전파
# 4층 신경망을 통한 역전파를 수행하여 오차 기울기를 계산한다.
# ReLU 활성화 함수를 사용하기 때문에, 오차 기울기를 계산할 때 해당 뉴런의 입력이 0보다 클 때만 기울기를 전파한다.
# 이 함수는 역전파 과정에서 각 층의 오차 기울기를 계산하여, 가중치를 업데이트 하는 데 사용될 수 있다.

# d: 목표 출력 값(원-핫 인코딩 벡터)
# y: 신경망의 최종 출력(소프트맥스 활성화 함수를 통과한 값)
# W2, W3, W4: 각 층의 가중치 행렬.
# v1, v2, v3: 각 층의 가중합.

def backpropagation_ReLU(d, y, W2, W3, W4, v1, v2, v3):
    e = d - y # 출력 오차 계산
    delta = e# 출력 층의 오차 기울기 delta 계산(가중치 W4 의 전치와 delta의 행렬 곱)

    e3 = np.matmul(W4.T, delta)# 세번째 층의 오차 계산(가중치 W4의 전치와 delta의 행렬곱)
    delta3 = (v3 > 0)*e3# 세번째 층의 오차 기울기 delta3 계산(e3와 ReLU 미분 결과의 요소별 곱)

    e2 = np.matmul(W3.T, delta3)# 두 번째 층의 오차 e2를 계산한다. (가중치 W3 의 전치와 delta3의 행렬곱)
    delta2  = (v2 > 0) *e2# 두번쨰  층의 오차 기울기 delta2(e2와 ReLU미분 결과의 요소별곱)

    e1 = np.matmul(W2.T, delta2)
    delta1 = (v1 > 0)*e1

    return delta, delta1, delta2, delta3




4. 가중치 계산
# 함수 기능은 역전파 알고리즘을 사용하여 계산된 오차 기울기를 사용하여 신경망의 가중치를 업데이트 한다.
#이 함수는 신경망 학습 과정에서 각 에포크마다 호출되어 가중치를 업데이트하고, 신경망 성능을 향상시키는 데 사용된다.

# alpha: 학습률, 가중치 업데이트의 크기를 조절합니다.
# delta, delta1, delta2, delta3: 각 층의 오차 기울기.
# y1, y2, y3: 각 층의 출력.
# x: 입력 데이터.
# W1, W2, W3, W4: 각 층의 가중치 행렬.


def calcWs(alpha, delta, delta1, delta2, delta3, y1, y2, y3, x, W1, W2, W3, W4):
    dW4 = alpha * delta * y3.T# dW4는 오차 기울기 delta와 이전 층의 출력 y3의 전치와의 곱에 학습률을 곱한 값
    W4 = W4 + dW4

    dW3 = alpha * delta3 * y2.T
    W3 = W3 + dW3

    dW2 = alpha * delta2 * y1.T
    W2 = W2 + dW2

    dW1 = alpha * delta1 * x.T
    W1 = W1 + dW1

    return W1, W2, W3, W4





 5. 가중치 업데이트
 # 깊은 신경망에 대해 역전파 알고리즘을 사용하여 가중치를 업데이트하는 과정을 구현한다.
#이 신경망은 ReLU 활성화 함수와 Softmax출력층을 사용

#입력 데이터 X
#목표 출력 D
#학습률 alpha

#가중치 행렬 W1, W2, W3, W4
# W1, W2, W3, W4: 각 층의 가중치 행렬.
# X: 입력 데이터 (5x5x5 크기의 3D 배열).
# D: 목표 출력 (5x5 크기의 2D 배열).
# alpha: 학습률, 가중치 업데이트의 크기를 조절합니다.


def DeepReLU(W1, W2, W3, W4, X, D, alpha):
    for k in range(5):
        x = np.reshape(X[:,:,k], (25,1))
        d = D[k, :][:,np.newaxis]

        y, v1, v2, v3, y1, y2, y3 = calcOutput_ReLU(W1, W2, W3, W4, x)
        #신경망의 출력y  각층의 가중합(v1,v2,v3) 각 층의 활성화 출력(y1, y2, y3)계산


        delta, delta1, delta2, delta3 = backpropagation_ReLU(d, y, W2, W3, W4, v1, v2, v3)
        #오차 기울기(delta,delta1,delta2,delta3)계산

        W1, W2, W3, W4 = calcWs(alpha, delta, delta1, delta2, delta3, y1, y2, y3, x, W1, W2, W3, W4)
        #가중치 행렬(W1,W2,W3,W4)행렬을 업데이트한다.

    return W1, W2, W3, W4






 6. 학습하기
# 가중치 랜덤하게 뽑은후 학습 시작하기
# 4층 신경망을 학습시키기 위한 코드 
#각 층에는 여러 개의 뉴런이 있고, 각 뉴런은 가중치를 가지고 있다.
#학습을 위해 무작위로 초기화된 가중치로 시작하여, 예측 오차를 줄이기 위해 반복적으로 가중치 조정한다.

import tqdm
W1 = 2 * np.random.random((20,25)) - 1 # 가중치 크기 (20,25)이며  -1과 1 사이의 균등 분포에서 무작위로 선택된 값으로 초기화
W2 = 2 * np.random.random((20,20)) - 1
W3 = 2 * np.random.random((20,20)) -1
W4 = 2 * np.random.random((5,20)) - 1

alpha = 0.01
for epoch in tqdm.tqdm_notebook(range(10000)):
    W1, W2, W3, W4 = DeepReLU(W1, W2, W3, W4, X, D, alpha)
    #입력 데이터 X와 목표 출력 D를 사용하여 학습을 진항하게 된다. 
    #1만번의 에포크가 끝나면, 신경망의 가중치 W1, W2, W3, W4는 훈련 데이터에 더 잘 맞도록 조정





 7. 훈련 데이터 검증
 def verify_algorithm(x, W1, W2, W3, W4):
    v1 = np.matmul(W1, x)
    y1 = ReLU(v1)

    v2 = np.matmul(W2, y1)
    y2 = ReLU(v2)

    v3 = np.matmul(W3, y2)
    y3 = ReLU(v3)

    v = np.matmul(W4, y3)
    y = Softmax(v)

    return y







  8. 결과

N = 5
for k in range(N):
    x = np.reshape(X[:,:,k], (25,1))
    y = verify_algorithm(x, W1, W2, W3, W4)

    print("Y = {}:".format(k+1))
    print(np.argmax(y, axis=0) + 1)
    print(y)
    print('--------')
#결과
Y = 1:
[1]
[[9.99961397e-01]
 [1.39639399e-08]
 [2.81797726e-05]
 [7.19283051e-10]
 [1.04086870e-05]]
--------
Y = 2:
[2]
[[6.85400057e-06]
 [9.99975499e-01]
 [9.74599451e-06]
 [7.90080899e-06]
 [5.09081220e-12]]
--------
Y = 3:
[3]
[[1.90029615e-05]
 [7.06403933e-06]
 [9.99942559e-01]
 [3.13728426e-05]
 [1.40261217e-09]]
--------
Y = 4:
[4]
[[3.94499217e-08]
 [1.86645168e-05]
 [1.98764111e-05]
 [9.99961411e-01]
 [8.48558374e-09]]
--------

1. 데이터 준비
import numpy as np

#행렬 X 정의
X = np.array([
    [0, 0, 1],
    [0, 1, 1],
    [1, 0, 1],
    [1, 1, 1]
])

#시그모이드 함수 정의
#시그모이드는 0과 1사이의 값으로 변환, 주로 로지스틱 회귀나 신경망에서 활성화 함수로 사용된다.
def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))

#가중치 행렬 W를 초기화 한다.
#1*3 크기의 행렬을 생성하고 각 원소는 0과 1사이의 무작위 값으로 채운다.
W = 2*np.random.random((1,3)) - 1    #2를곱하고 -1을 뺴야한다.  마이너스 랜덤값을 출력하기 위함이다.
W
# 출력 array([[ 0.8177835 ,  0.88612231, -0.88451088]])


# X 의 한줄과 위애 W 3개의 값을 곱하는것이다.
# 가중치 행렬 W와 입력 행렬 X의 첫 번째 행을 곱한다.
np.matmul(W, X[0])
#출력 array([-0.88451088])

#0*0.8177835 + 0*0.86612231 + 1 * (-0.8845)



#추론 결과
# 데이터가 4개

#X는 4*3 행렬로, 4개의 다른 입력 벡터 포함
#N은 반복 횟수를 나타내며 여기서는 4로 설정 이는 X의 행 수와 일치
# 결과값이 말도 안되게 틀린 값이 출력된다. 실제 참값은 0011

N  = 4
for k in range(N): # 0,1,2,3,
    x = X[k, :].T# X 행렬에서 k-번째 행을 선택
    v = np.matmul(W, x)
    y = sigmoid(v)

    print(v)

 #결과
 [-0.88451088]
[0.00161143]
[-0.06672738]
[0.81939493]

위 결과 오류를 가중치로 정답을 맞추도록 학습 시키기(지도학습)

일단 정답을 주자 - AND
D = np.array([
    [0], [0], [1], [1] # 위 실습에서 나온  [-0.88451088][0.00161143][-0.06672738][0.81939493] 값들은 틀린값들이며  각각 0,0,1,1 수치가 정답이다.

])
![](https://velog.velcdn.com/images/vitamin_penguin/post/f3d3fec3-a19f-4bd4-bbde-e159ad523ee2/image.png)

#일반 모델의 출력 계산하는 함수
#일단 모댈의 출력 계산하는 함수
#이 함수는 신경망 모델 출력을 계산하는 역할을 한다.
#입력 x 와 가중치 W를 받아서 모델 출력 계산
def calc_output(W, x): # 가중치와 X값 을 받는다.
    #W; 가중치 행렬 1*3 행렬
    #x: 입력 벡터 이 경우 3*1 행렬

    v = np.matmul(W, x)
    #선형 변환: 가중치 W와 입력 x의 행렬 곱을 계산

    y = sigmoid(v)
    #비선형 변환: 계산된 선형 변환 결과v를 시그모이드 함수에 통과시켜 비선형 변환을 수행 시그모이드 함수는 결과를 0과 1사이로 스케일링
    #하여 활성화 함수로 자주 사용
    return y







 # 오차 계산   
 #신경망 예측 오차와 그에 따른 오차 기울기를 계산하는 역할
# d: 실제 값 또는 목표 출력 값이며 신경망이 예측해야 하는 정답을 나타낸다.
#y: 신경망의 예측 값. 이 값은 calc_output 함수를 통해 계산된 출력

def calc_error(d,y): # y는 추론값 d는 정답
    e = d - y 
    #오차 계산: 실제 값과 예측 값 사이의 오차를 계산 오차는 신경망의 예측이 얼마나 정확한지를 나타내며 학습 과정에서 이 오차 최소화

    delta = y * (1-y) * e #에러와 활성화 함수의 미분값
    #오차 기울기 계산: 오차에 대한 가중치의 기울기 계산한다. 이 표현식은 시그모이드 활성화 함수의 미분 사용

    #y * (1-y)는 시그모이드 함수의 미분값이며 출력 값에 대한 변화에 따른 오차의 변화율
    # 이 값을 오차 e와 곱하면 가중치를 조정하기 위 한 기울기가 된다.

    return delta   






# 한 epoch에 수행된는 W의 계산
# delta_GD 함수는 경사 하강법(Gradient Descent) 사용하여 한 에폭 동안 신경망의 가중치 W를 업데이트  하는 역할을 한다.

def delta_GD(W, X, D, alpha):
    #W: 가중치 행렬 1*3 행렬
    #X: 입력 데이터 4*3 행렬
    #D: 실제 값 또는 목표 출력 값. 4*1 행렬
    #alpha: 학습률 이 값은 가중치 업데이트 크기 조절

    for k in range(4):
        x = X[k, :].T # X의 K-번째 행 선택
        d = D[k]# D의 k-번째 값 선택

        y = calc_output(W,x)# 현재 가중치와 입력을 사용하여 모델의 출력 계산
        delta = calc_error(d, y)# 실제 값과 모델의 출력 사이의 오차와 그에 따른 오차 기울기 계산

        #가중치 업데이트
        dW = alpha * delta *x # 가중치 업데이트를 위한 기울기 계산
        W = W + dW# 학습률과 계산된 기울기를 사용하여 가중치 업데이트

    return W    






가중치를 랜덤하게 초기화하고 학습 시작
# 경사 하강법 사용하여 가중치 W를 업데이트하기 위한 학습 과정
alpha = 0.9# 매우 큰 학습률 설정
for epoch in range(10000):
    W = delta_GD(W, X, D, alpha)
    # delta_GD 함수를 호출하고 그 결과로 반환된 업데이트된 가중치 W로 기존의 가중치 대체한다.
#     입력:
#     W: 현재 가중치 행렬 (1x3 행렬)
#     X: 입력 데이터 (4x3 행렬)
#     D: 목표 출력 값 (4x1 행렬)
#     alpha: 학습률
#     출력: 업데이트된 가중치 행렬W
    print(W)




#    
 N = 4
for k in range(N):
    x = X[k, :].T
    v = np.matmul(W, x)
    y = sigmoid(v)

    print(y)

  #출력결과  0,0,1,1 정답이 나왔다.
  [0.01018983]
[0.00829532]
[0.99323968]
[0.9916928]




X값
array([[0, 0, 1],
       [0, 1, 1],
       [1, 0, 1],
       [1, 1, 1]])



D값
array([[0],
       [0],
       [1],
       [1]])

오차의 역전파

실습

1. 신경망 모델을 위한 초기 설정 수행
import numpy as np

#행렬 X 정의
X = np.array([ #4*3 행렬
    [0, 0, 1],
    [0, 1, 1],
    [1, 0, 1],
    [1, 1, 1]
])



D = np.array([# 4*1 행렬
    [0], [1], [1], [0] 

])


W = 2*np.random.random((1,3)) - 1    #2를곱하고 -1을 뺴야한다.  마이너스 랜덤값을 출력하기 위함이다.
                                    # 1*3 행렬







2. 경사 하강법 사용하여 신경망 가중치 W 학습하기  
alpha = 0.9 #학습률
for epoch in range(10000):
    W = delta_GD(W, X, D, alpha) # 함수를 호출하여 가중치 W 업데이트





3. 가중치 W 사용하여 4 개의 입력 샘플 각각에 대한 신경망의 예측 계산하고 결과 출력
N = 4 #샘플 4개
for k in range(N):
    x = X[k, :].T
    v = np.matmul(W, x) #가중치 W와 입력 x의 행렬 곱을 계산하여 v에 저장
    y = sigmoid(v)

    print(y)
#결과 
[0.52965337]
[0.5]
[0.47034663]
[0.44090112]





4. 함수 calc_output는 두 층을 가진 신경망 출력을 계산하는 함수
#입력 x,  첫번째 층 가중치 W1  두번쨰 층 가중치 W2를 매개변수로 받는다.


def calc_output(W1, W2, x):
    v1 = np.matmul(W1, x)
    # 입력 x와 첫 번쨰 층의 가중치 W1의 행렬 곱을 계산하여 v1에 저장

    y1 = sigmoid(v1)
    #계산된 가중합 v1에 시그모이드 활성화 함수를 적용하여 첫 번쨰 층의 출력 y1 계산

    v2 = np.matmul(W2, y1)
     #첫번째 층의 출력 y1과 두번쨰 층의 가중치 W2의 행렬 곱을 계산하여 v2에 저장 이 값은 두번쨰 층의 가중합이다.

    y = sigmoid(v2)
    #계산된 가중합 v에 시그모이드 활성화 함수를 적용하여 신경망의 최종 출력 y를 계산한다.
    return y, y1




5.신경망 학습 과정에서 오차 역전파를 위해 사용된다.
# 이 함수는 실제값d와 신경망의 예측 값y를 입력으로 받아, 그래디언트를 계산한다.

def calc_delta(d, y):
    e = d - y #오차 계산  실제값 d와 예측 값 y사이의 오차 계산 오차는 실제 값과 예측 값의 차이를 나타낸다.
    delta = y * (1 - y) * e # 그래디언트 계산: 시그모이드 활성화 함수의 미분과 계산된 오차를 사용하여 그래디언트 계산
                            #이 그래디언트는 가중치를 어떻게 업데이트해야 할지를 결정하는 데 사용된다.

    return delta





 6.   calc_delta1는 두층 신경망에서 오차 역전파 과정 일부로 사용된다.
 #calc_delta1는 두층 신경망에서 오차 역전파 과정 일부로 사용된다.
# 이 함수는 두번쨰 층의 가중치 W2, 두번 째 층의 오차 그래디언트, 
#첫 번쨰 층의 출력y1을 입력으로 받아, 첫번째층의 오차 그래디언트 계산

def calc_delta1(W2, delta, y1):
    #오차 역전파
    e1 = np.matmul(W2.T, delta)
    #두번째 층의 가중치 W2의 전치와 두번째 층의 오차 그래디언트(delta)의 행렬 곱을 계산하여 첫 번째 층의 오차 e1을 계산한다.
    #이는 오차를 첫 번째 층으로 역전파하는 과정이다.

    #첫번째 층의 오차 그래디언트 계산
    delta1 = y1*(1-y1)* e1
    #첫번째 층의 출력 y1과 시그모이드 활성화 함수의 미분을 사용하여 첫 번째 층의 오차 그래디언트 계산한다.

    return delta1       




7. XOR 문제를 해결하기 위해 설계된 두 층 신경망에 대한 역전파 알고리즘 구현    
def backprop_XOR(W1, W2, X, D, alpha):
    # W1: 첫 번째 층의 가중치 행렬
    # W2: 두번째 층의 가중치 행렬
    # x: 입력 데이터 행렬
    # d: 목표 출력 값 행렬
    # alpha:학습률 가중치 업데이트 크기 조절

    for k in range(4):
        x = X[k, :].T #입력 데이터에서 k번쨰 샘플 추출후 전치하여 열 벡터 형태로 만든다.
        d = D[k]#해당하는 목표 출력 값 추출

        #순방향 전파
        y, y1 = calc_output(W1, W2, x)# calc_ouput함수를 사용하여 신경망 출력 계산 y1은 첫번쨰 층의 출력, y는 신경망의 최종 출력

        #그래디언트 계산
        delta = calc_delta(d, y)#신경망 출력에 대한 오ㅗ차 함수의 그래디언트를 계산
        delta1 = calc_delta1(W2, delta, y1)# 첫번쨰 층의 출력에 대한 오차 함수의 그래디언트 계산

        #가중치 업데이트
        dW1 = (alpha*delta1).reshape(4,1) * x.reshape(1,3) # 첫 번쨰 층의 가중치 업데이트 계산
        W1 = W1 + dW1# 첫번쨰 층의 가중치를 업데이트
        dW2 = alpha * delta * y1 # 두번쨰 층의 가중치 업데이트 계산
        W2 = W2 + dW2# 두번쨰 ㅊ층의 가중치 업데이트

    return W1, W2





 8. 가독성을 위해 다시 코드사용
 X = np.array([ #4*3 행렬
    [0, 0, 1],
    [0, 1, 1],
    [1, 0, 1],
    [1, 1, 1]
])



D = np.array([# 4*1 행렬
    [0], [1], [1], [0] 

])






9.XOR 문제 해결위해 두 층 신경망을 훈련시키는 과정 구현
W1 = 2*np.random.random((4,3)) -1
W2 = 2*np.random.random((1,4)) - 1
alpha = 0.9
for epoch in range(10000):
    W1, W2 = backprop_XOR(W1, W2, X, D, alpha)






10. 훈련된 두 층 신경망 모델을 사용하여 입력 X의 각 샘플에 대한 예측 수행하고, 결과 출력하기   
N = 4
for k in range(N):
    x = X[k, :].T
    v1 = np.matmul(W1, x)
    y1 = sigmoid(v1)
    v = np.matmul(W2, y1)
    y = sigmoid(v)

    print(y)
  #결과
  [0.00442485]
[0.99214491]
[0.99409696]
[0.00932415]

크로스엔트로피

• Cross-Entropy: 두 확률 분포 간 차이를 측정하는 데 사용되는 지표이다. 딥러닝에서 분류 문제를 해결할떄 손실 함수로 자주 사용된다.
• 크로스 엔트로피 값이 낮을수록 모델의 예측이 실제 레이블에 더 가까워진다는 것을 의미한다. 즉 성능이 좋다는 것을 의미한다.
• 신경망 학습에서 크로스 엔트로피 손실을 최소화하기 위해 경사 하강법 이 사용된다.
• 크로스 엔트로피 손실 함수의 그래디언트는 모델의 파라미터에 대해 계산되며, 이를 사용하여 가중치를 업데이트

#크로스 엔트로피 오차 함수 기반으로 역전파 과정에서 오차 그래디언트를 계산한다.
# 크로스 엔트로피는 분류 문제에서 주로 사용되는 오차 함수이다. 
#모델 예측이 실제 값에 얼마나 가까운지 측정한다.
def calcDelta_ce(d, y): # d: 실제값, y는 모델의 예측 값
    e = d - y# 크로스 엔트로피 미분 결과는 (y-d)  실제 업데이트 과정에서 학습률과 곱해지므로 부호가 반전된다. (y - d)
    delta = e

    return e






#엔트로피 오차 함수를 사용하는 두 층 신경망에서 오차 역전파 과정의 일부를 구현한다.


def calcDelta1_ce(W2, delta, y1):# 두번째층 가중치W2, 두번째 층의 오차 그래디언트 델타, 첫번째 층의 출력 y1 입력받아
                                # 첫번째 층의 오차 그래디언트 delta를 계산한다.
    e1 = np.matmul(W2.T, delta)
    #첫 번째 층의 출력y1에 대한 시그모이드 활성화 함수의 미분 계산 이를 역전파된 e1와 요소별로 곱한다.
    # 이결과는 첫 번째 층의 오차 그래디언트 delta1이된다.

    delta1 = y1*(1 - y1) * e1
    return delta1










 # 다시 역전파

#크로스 엔트로피 오차 함수 사용후 두 층 신경망 가중치 업데이트 하는 역전파 알고리즘 구현
def BackpropCE(W1, W2, X, D, alpha):
    #X: 입력 데이터
    #D: 목표 출력 값 행렬


    for k in range(4):
        x = X[k, :].T # 현재 샘플을 선택하고 전치하여 열 벡터로 만든다.
        d = D[k] # 현재 샘플 목표 출력 값 선택

        #순방향 전파:
        y, y1 = calc_output(W1, W2, x)# 현재 가중치(W1, W2)와 입력을 사용하여 모델 출력 계산

        #역전파 및 그래디언트 계산
        delta = calcDelta_ce(d, y) # 출력 오차에 대한 그래디언트 계산
        delta1 = calcDelta1_ce(W2, delta, y1)# 첫번째 층의 출력에 대한 오차 그래디언트 계산

        #가중치 업데이트
        dW1 = (alpha*delta1).reshape(4,1) * x.reshape(1,3) # 첫번째 층의 가중치 업데이트를 위한 그래디언트 계산
        W1 = W1 + dW1# 첫 번째 층의 가중치 업데이트

        dW2 = alpha * delta * y1 # 두 번째 층의 가중치 업데이트를 위한 그래디언트 곗산
        W2 = W2 + dW2# 두번째 층의 가중치 업데이트

    return W1, W2






  # 학습
W1 = 2*np.random.random((4,3)) -1
W2 = 2*np.random.random((1,4)) - 1
alpha = 0.9
for epoch in range(10000):
    W1, W2 = BackpropCE(W1, W2, X, D, alpha)





# 순방향 추론
N = 4
for k in range(N):
    x = X[k, :].T
    v1 = np.matmul(W1, x)
    y1 = sigmoid(v1)
    v = np.matmul(W2, y1)
    y = sigmoid(v)

    print(y) # 0,1,1,0   XOR 출력 성공!
#출력
[3.45859987e-05]
[0.99989487]
[0.99976413]
[0.00035296]

1.mnist 데이터셋을 불러오기
import tensorflow as tf

mnist = tf.keras.datasets.mnist #TensorFlow 의 Keras API를 사용하여  MNIST 데이터셋을 로드하기 위한 준비

#훈련 데이터와 테스트 데이터로 분할한다.  (x_train,x_Test)이미지 데이터        (y_train,y_test)는 해당 이미지의 레이블 포함
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train/255, x_test/255 #이미지 데이터는 0~255까지의 픽셀을 가지고 있으며 이 값을 255나누어 0,1 사이의 값으로 정규화

2. TensorFlow를 사용하여 간단한 신경망 모델 구성
#TensorFlow를 사용하여 간단한 신경망 모델을 구성
# MNIST 데이터셋의 손글씨 숫자 이미지를 분류하기 위해 사용될 수 있다.

model = tf.keras.models.Sequential([#층을 순차적으로 쌓아 올릴 수 있는 모델을 만든다. 각 층은 입력 데이터를 받아 처리한 후 결과를 다음 층으로 전달

    tf.keras.layers.Flatten(input_shape=(28,28)),# 이 층은 입력 이미지를 1차원 배열로 변환한다. MNIST 이미지는 28*28 픽셀이므로, 784개의 값을 가진 1차원 배열로 평탄화
    tf.keras.layers.Dense(1000, activation = 'relu'),#이 층은 완전 연결(또는 밀집)층이다. 1000개의 뉴런 있으며 각 뉴런은 이전 층의 모든 뉴런과 연결
    tf.keras.layers.Dense(10, activation = 'softmax')#이 층도 완전 연결 층 이층에는 10개의 뉴런이 있으며, MNIST 데이터셋의 10개 클래스(0~9까지의 숫자)해당
                                                    #활성화 함수로는 softmax가 사용되어 10개 클래스 각각에 대한 확률 분포를 출력한다.
])


model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
#앞서 정의한 신경망 모델 컴파일 한다. 컴파일은 훈련을 ㅅ시작하기 전에 필요한 설정을 수행하는 단계

#optimizer:모델 훈련시 사용할 최적화 알고리즘을 지정한다. adam은 매우 효율적이고 계산 비용이 적으며, 별도의
#파라미터 조정 없이도 좋은 결과를 낼 수 있는 인기 있는 최적화 알고리즘

#loss 모델 오차 측정하는 손실 함수 지정 sparse_categorical_crossentropy는 다중 클래스 분류 문제에 사용되며, 레이블이 정수 형태로 제공될떄 사용
#이 손실 함수는 모델의 예측이 실제 레이블과 얼마나 차이가 나는지 측정한다.


#결론: 이코드는 MNIST 손글씨 숫자를 분류할 수 있는 신경망 모델이 생성된다. 이모델은 28*28 픽셀의 이미지를 입력으로 받아, 해당 이미지가
#어떤 숫자를 나타내는지에 대한 확률분포를 출력한다.


3.입력 데이터와 레이블을 받아, 주어진 에포크 동안 모델을 훈련시키면서 가중치를 업데이트한다.
hist = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=10, batch_size=100, verbose=1)

#validation_data: 모델을 훈련할 떄 동시에 검증할 데이터 세트를 지정  에포크 마다 모델의 성능을 검증 데이터 세트에서도 평가
#batch_size: 한번에 처리할 샘플의 수 지정
#verbose: 훈련 진행 상황을 어떻게 표시할지 지정  verbose=1은 진행 막대와 함께 에포크마다 손실 지표 출력 설정


4. 시각화
#좋은 결과가 나왔다.
#이상적인 수렴 상황 그래프
import matplotlib.pyplot as plt

plot_target = ['loss','val_loss', 'accuracy','val_accuracy']

plt.figure(figsize=(12,5))

for each in plot_target:
    plt.plot(hist.history[each], label=each)
plt.legend()
plt.grid()
plt.show()

5. 모델 예측 수행
predicted_result = model.predict(x_test)
predicted_labels = np.argmax(predicted_result, axis=1) # 각 샘플에 대한 예측된 클래스를 찾기 위해 np.argmax 함수 사용
                                                       # axis=1 매개변수는 각 샘플의 10개 클래스에 대한 확률중 가장 높은 확률을 가진인덱스 찾도록 지시
predicted_labels[:10]
출력
array([7, 2, 1, 0, 4, 1, 4, 9, 5, 9], dtype=int64)


#라벨과 예측값 확인해보기
y_test[:10]
array([7, 2, 1, 0, 4, 1, 4, 9, 5, 9], dtype=uint8)


6. 예측에 실패한 갯수
wrong_result = []

for n in range(0, len(y_test)):
    if predicted_labels[n] != y_test[n]:
        wrong_result.append(n)


len(wrong_result)


7. 실패한 예측 시각화 해보기
plt.figure(figsize=(14,3))

for idx, n in enumerate(samples):
    plt.subplot(4, 4, idx+1)
    plt.imshow(x_test[n].reshape(28,28), cmap = 'Greys')
    plt.title('Label: '+ str(y_test[n]) + ' | Predict: ' + str(predicted_labels[n]))
    plt.axis('off')

2. CNN

• Convolutional Nerual Network은 딥러닝에서 이미지 처리, 비디오 인식, 이미지 분류 등의 컴퓨터 비전 작업에 사용되는 신경망
• CNN은 구조가 입력 데이터의 형태를 고려하여 특별히 설계되었으며, 이미지와 같은 2차원 데이터를 처리할 때효과

• Convolutional Layer(합성곱 계층): 이미지의 지역적인 부분을 인식하기 위해 사용
• 작은 필터(혹은 커널) 사용하여 이미지 전체를 스캔하며, 필터와 이미지 간의 합성곱 연산 수행
• 이 과정을 통해 특징 맵(feature map)생성되며, 이미지에서 특정 패턴이나 특징을 강조한다.

• Pooling Layer(풀링 계층)Convolutional Neural Network 에서 사용되며 특징 맵의 크기를 줄이고 중요한 정보를 유지하여 계산량을 감소시키고 과적합을 방지
• Max Pooling(최대 풀링): 입력 영역에서 가장 큰 값을 선택하여 출력한다.
• 중요한 특징을 강조하고 덜 중요한 정보를 제거한다.

• Zero padding은 Convolutional Neural Network(CNN)에서 합성곱 계층(Convolutional Layer)을 적용할 때, 입력 데이터 주변을 0으로 채우는 기법이다.
• 공간적 차원을 유지: 합성곱 연산을 수행할 때 입력 데이터의 크기가 축쇠되는 것을 방지하며 이를 통해 네트워크 깊이가 깊어져도 공간적 차원(너비와 높이)을 유지할 수 있다.
• 경계 정보 활용: 입력 데이터의 가장자리 부분에 있는 정보도 중앙 부분과 동일하게 활용하며 이는 이미지의 가장자리에 중요한 정보가 위치할 때 중요하다.

• Droput 딥러닝 모델을 훈련할 때 과적합을 방지하기 위해 사용되는 기법 중 하나이다. 이방법은 훈련 과정에서 네트워크의 일부 뉴런을 무작위로 비활성화함으로 모델이 특정 뉴런에 지나치게 의존하는 것을 방지한다.

3. CNN 실습

1.데이터 받고정리
import tensorflow as tf

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
X_train, X_test = x_train/255, x_test/255

X_train = X_train.reshape((60000,28,28,1)) #6만개의 훈련 이미지를 (28,28) 크기의 2D 배열에서(28,28,1) 
                                            #크기의 3D 배열로 변환 여기서 1은 흑백 이미지를 나타내는 채널수
X_test = X_test.reshape((10000,28,28,1))





2. Convolutional Neural Network 모델 구축 예시
#CNN은 주로 이미지 분류, 객체 감지 등 태스크에 사용
from tensorflow.keras import layers, models

model = models.Sequential([
    layers.Conv2D(32, kernel_size=(5, 5), strides=(1, 1), padding='same', activation='relu', input_shape=(28, 28, 1)),
    #32개의 필터와(5,5)크기의 커널을 가진 합성곱 레이어, padding='same'는 입력과 출력의 크기를 동일하게 유지한다.
    #input_shape=(28,28,1)은 입력 이미지의 크기를 (28,28) 흑백(1채널)설정
    #

    layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2)),
    #2,2크기의 풀링 윈도우를 사용하는 최대 풀링 레이어. 
    #strides2,2는 풀링 윈도우를 2픽셀씩 이동

    layers.Conv2D(64, (2, 2), activation='relu', padding='same'),
    #64개의 필터와 2,2 크기의 커널을 가진 또 다른 합성곱 레이어

    layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2)),
    #두번쨰 최대 풀링 레이어

    layers.Dropout(0.25),
    #25%의 드롭아웃 비율을 가진 드롭아웃 레이어 이는 과적합 방지하기 위해 사용

    layers.Flatten(),#다차원 입력을 1차원 배열로 평탄화  이것은 합성곱/풀링 레이어와 완전 연결 게리어 사이의 연결을 돕는다.
    layers.Dense(1000, activation='relu'),
    #1000개의 유닛을 가진 연결 레이어
    layers.Dense(10, activation='softmax')
    #10개의 유닛(클래스 수와 일치)을 가진 출력 레이어
    #activation='softmax'는 다중클래스 분류를 위해 사용되며, 출력 값의 총합이 1이 되도록 활률을 반환
])

#요약: 이모델은 28*28 픽셀 크기의 흑백 이미지를 입력으로 받아, 10개의 다른 클래스 중 하나로 분류하는데 사용
#xe) MNIST 손글씨 숫자 분류




3. 모델 정보확인
model.summary()
Model: "sequential_2"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_4 (Conv2D)           (None, 28, 28, 32)        832       

 max_pooling2d_4 (MaxPoolin  (None, 14, 14, 32)        0         
 g2D)                                                            

 conv2d_5 (Conv2D)           (None, 14, 14, 64)        8256      

 max_pooling2d_5 (MaxPoolin  (None, 7, 7, 64)          0         
 g2D)                                                            

 dropout_2 (Dropout)         (None, 7, 7, 64)          0         

 flatten_2 (Flatten)         (None, 3136)              0         

 dense_4 (Dense)             (None, 1000)              3137000   

 dense_5 (Dense)             (None, 10)                10010     

=================================================================
Total params: 3156098 (12.04 MB)
Trainable params: 3156098 (12.04 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________



4. CNN 모델 컴파일
#최적화 알고리즘 Adam 사용 학습률을 자동으로 조절하는 기능을 가진 효율적인 최적화 알고리즘이다.
#loss 손실함수
#평가지표로 Accuracy 사용
model.compile(optimizer='adam', loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])



5.훈련 과정에서 발생한 여러 이벤트에 대한 정보를 담은 History 객체 반환
#이객체를 사용하면 훈련과 검증 손실, 정확도 등의 값을 시각화하고 분석할수있다.
#validation_data: 검증 데이터셋 X_test, y_test (과적합되지 않고 일반화된 성능을 가지는지 확인하기 위함)
hist = model.fit(X_train, y_train, epochs=5, verbose=1, validation_data=(X_test, y_test))




6.시각화
#좋은 결과가 나왔다.
#이상적인 수렴 상황 그래프
import matplotlib.pyplot as plt

plot_target = ['loss','val_loss', 'accuracy','val_accuracy']

plt.figure(figsize=(12,5))

for each in plot_target:
    plt.plot(hist.history[each], label=each)
plt.legend()
plt.grid()
plt.show()

8. 샘플 예측
predicted_result = model.predict(x_test)
predicted_labels = np.argmax(predicted_result, axis=1) # 각 샘플에 대한 예측된 클래스를 찾기 위해 np.argmax 함수 사용
                                                       # axis=1 매개변수는 각 샘플의 10개 클래스에 대한 확률중 가장 높은 확률을 가진인덱스 찾도록 지시
predicted_labels[:10]
#결과
array([7, 2, 1, 0, 4, 1, 4, 9, 5, 9], dtype=int64)


9. 잘못 예측 수 확인
wrong_result = []

for n in range(0, len(y_test)):
    if predicted_labels[n] != y_test[n]:
        wrong_result.append(n)


len(wrong_result)
#결과 110개



10. 시각화
samples = random.choices(population =wrong_result, k=16)
plt.figure(figsize=(14,3))

for idx, n in enumerate(samples):
    plt.subplot(4, 4, idx+1)
    plt.imshow(x_test[n].reshape(28,28), cmap = 'Greys')
    plt.title('Label: '+ str(y_test[n]) + ' | Predict: ' + str(predicted_labels[n]))
    plt.axis('off')

11. Accuracy 확인
score = model.evaluate(X_test, y_test)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#출력
Test loss: 0.033526815474033356
Test accuracy: 0.9894999861717224

텐서플로는 구글에서 만든 딥러닝 프로그램을 쉽게 구현할 수 있도록 다양한 기능을 제공해주는 라이브러리이다.

• Tensor: 벡터나 행렬을 의미

• Graph: 텐서가 흐르는 경로(혹은 공간)

• Tensor Flow: 텐서가 Graph를 통해 흐른다.

  텐서는 데이터를 저장하는 방법 중 하나로, 여러 차원을 가진 배열이다.

  1. 회색조 이미지: 흑과 백만으로 이루어진 이미지. 이런 이미지는 2차원 배열로 표현할 수 있다 즉, 행과 열이 있고, 각 칸에는 밝기를 나타내는 숫자가 들어있다. 예를 들어, 밝은 부분은 높은 숫자로, 어두운 부분은 낮은 숫자로 표현
  2. RGB 이미지: 이것은 컬러 이미지 이다. 이런 이미지는 적색(Red), 녹색(Green), 청색(Blue) 세 가지 색을 조합해서 만들어집니다. 각 색깔은 2차원 배열로 표현되고, 이 세 개의 배열이 합쳐져서 하나의 3차원 배열, 즉 텐서를 만든다. 요약하자면, 텐서는 데이터를 다차원 배열로 저장하는 방식이며, 이미지와 같은 복잡한 데이터를 컴퓨터가 이해할 수 있는 형태로 변환하는데 사용

  

2. Blood Fat

1. 데이터 가지고 오기
raw_data = np.genfromtxt(r'C:\Users\edgar\Desktop\딥러닝\x09.txt', skip_header=36)
raw_data


2. raw_data의 2,3,4 열의 모든 데이터 추출하기
xs = np.array(raw_data[:,2], dtype=np.float32)# raw_data의 세 번째 열의 모든 데이터를 추출
ys = np.array(raw_data[:,3], dtype=np.float32)
zs = np.array(raw_data[:,4], dtype=np.float32)

3. 추출한 데이터로 시각화 해보기
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(xs, ys, zs)
ax.set_xlabel('Weight')
ax.set_ylabel('Age')
ax.set_zlabel('Blood fat')
ax.view_init(15,15)
plt.show()

1.딥러닝 모델 학습 위한 준비 과정
#딥러닝 모델 학습시키기 위한 준비 과정
# raw_data라는 배열에서 특정 열들을 선택하여 새로운 배열을 만드는 과정
x_data = np.array(raw_data[:, 2:4], dtype = np.float32) # 배열의 모든 행과 세번째 ,네번째 열을 선택한다. 결과는 2차원 numpy 배열이 된다.
y_data = np.array(raw_data[:, 4], dtype=np.float32)


2. shape 확인
# 25를 사용할수 없다. 그이유는 강의 10분 부분 확인 
# 영상에서 말하길  b 는 25,1이 나와야한다 (여기서 1의 원래사이즈는 25*1이지만  출력은 1이다.)
y_data.shape


#사용하기위해 y의 shape를 조정한다.
# 배열의 형태를 25,1로 바꾼다. 이는 25개의; 행과 1개의 열을 가진 2차원 배열로 만든다. 형태를 바꾸는 이유는
#뒤에서 모델에 데이터를 제공할 떄 차원이 일치해야 하기 떄문이다.
y_data = y_data.reshape((25,1))
y_data.shape





3. 원래 의도한 모델 만들기
#TensorFlow 라이브러리를 사용하여 간단한 신경망 모델을 생성
#사용된 모델은 순차 모델이며 여러층(layers)을 순서대로 쌓아 올린 형태 모델 의미
import tensorflow as tf

#순차 모델 샹성 순차 모델은 층을 순서대로 쌓아 올릴 수 있는 모델로, 각 층은 이전 층의 출력을 입력으로 받아들인다.
model = tf.keras.models.Sequential([ #강의에서 보여준 그래프 즉  (6분에서 교수님이 설명하는 그래프 의 원리대로 만들기위한 코드)

    #이층은 Dense라고 불리며 모든 입력 노드가 모든 출력 노드와 연결된 형태의 층이다. 
    #이모델은 1개의 출력 2개의 입력 특성

    tf.keras.layers.Dense(1, input_shape=(2,)) #출력이 1개고 입력이 2개다.
])

4. 텐서플로 Kears API 사용
#model.comile()함수는 텐서플로우의 Kears API를 사용하여 구축된 신경망 모델을 학습하기 전에 설정하는 과정
#이 함수는 모델의 학습 과정에서 사용될 옵티마이저 optimizer, 손실함수(loss function),그리고 평가 지표(metrics)등을 지정한다.

#여기서는 모델 학습할때 사용할 옵티마이저를 RMSprop으로 설정하며 학습률을 조정하면서 가중치를 업데이트하는 방법으로, 각 가중치의 업데이트가 일정한
#속도를 유지하도록 도와주는 옵티마이저이다.

#mse 손실 함수를 (Mean Squared Error)로 설정한다. 예측값과 실제값 사이의 차이의 제곱의 평균을 계산하는 방법으로, 회귀 문제에서 흔히 사용
#이 설정 이후 model.fit 사용하여 모델을 실제로 학습시킬 수 있다.
model.compile(optimizer='rmsprop', loss='mse')


5. summary 확인
model.summary() #none은 데이터 개수여서 None이라 뜨고  1개의 ouput이며 찾아야할 파라미터는 3개이다.

#이로써 모델 구성이 다끝났다.
#출력결과
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 1)                 3         

=================================================================
Total params: 3 (12.00 Byte)
Trainable params: 3 (12.00 Byte)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

6. 모델 돌려보기
#x_data: 모델에 입력할 데이터
#y_data 모델이 예측해야하는값
#전체 학습 데이터 세트가 모델을 통과하는 횟수를 의미한다.

hist = model.fit(x_data, y_data, epochs=5000)
---------------------------------------------------

#Predict 해보기
- 데이터를 이용해서
- 모델을 만들고
- 학습했으니
- 예측해보자
- 몸무게 100에 44살 된 사람의 이 데이터에서의 Blood Fat은?




7. pridect
#100 몸무게, 44나이  내가 준데이터에 따르면 얼마인가
#Blood Fat은 398이 나왔다.

#100,44 라는 두 개의 특성을 가진 단일 데이터 포인트를 생성하는데  이배열의 형태는 (2,)로 모델이 예상하는 입력 형탱와 일치하지 않는다.
# reshape(1,2) 배열을형태를 사용하여 이문제를 해결 여기서 1은 배치 크기 2는 입력 특성으 ㅣ수를 의미
#즉 하나의 데이터 포인트가 있고, 이 데이터 포인트는 두개의 특성을 가지는다는 것을 의미한다.

model.predict(np.array([100,44]).reshape(1,2))


8. 가중치와 bias 확인
#편향(bias)값을 가져오는데 사용하는 코드이다.
# 학습된 파라미터, 즉 가중치와 편향 값을 추출하여 분석하기 위해 사용된다. 이렇게 추출된 파라미터를 사용하면
#모델이 학습 데이터에서 어떤 패턴을 학습했는지 이해하고, 모델의 동작을 해석하는데 도움

#W는 가중치 b는 편향값
W_, b_ = model.get_weights()
W_, b_


9. 결과 시각화
x = np.linspace(20, 100, 50).reshape(50,1)
y = np.linspace(10,70, 50).reshape(50,1)

X = np.concatenate((x,y), axis=1)
Z = np.matmul(X, W_) + b_

fig = plt.figure(figsize=(12,5))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(xs, ys, zs)
ax.scatter(x,y, Z)

3. XOR

• 선형 모델로 XOR를 풀수 없다.
• model.compile
  • 옵티마이저를 선정하고, 학습률을 선정한다.
  • loss 함수는 mse로 한다. mean squared error

1. 실습에 사용할 간단한 데이터
#실습에 사용할 간단한 데이터
import numpy as np

X = np.array([[0, 0],
              [1, 0],
              [0, 1],
              [1, 1]])

y = np.array([[0], [1], [1], [0]])



2. XOR은 2개의 레이어를 사용한다.
# XOR은 직선 1개가지고 사용할수 없음으로 레이어를 2개 사용한다.
# XOR 문제는 선형 분리가 불가능한 문제의 대표적인 예시이다. 즉 하나의 직선으로 두 클래스 0,1 구분 불가
#XOR 문제를 해결하기 위해서는 비선형 관계를 학습할 수 있어야한다. 비선형 활성화 함수 시그모이드 함수를 사용한다. S자 형태로 되어 있어서 비선형 변환을 제공

#즉 선형말고 비선형으로 사용했다.
#sigmoid의 그래프가 직선이 아니다. 그점을 이용해서 XOR를 사용할 수있다.
#모델 구성
model = tf.keras.Sequential([
    tf.keras.layers.Dense(2, activation = 'sigmoid',input_shape=(2,)),
    tf.keras.layers.Dense(1, activation = 'sigmoid')
])


3. 신경망 모델 학습 설정
#신경망 모델 학습 설정
#학습에 사용할 옵티마이저 설정 경사 하강법(SGD) 사용하고 있으며 학습률은 0.1로 설정

# 모델 성능을 평가하기 위해 사용할 손실 함수 설정 loss
#mse는 평균 제곱 오차(Mean Squared Error)의미 예측값과 실제값 실제값 사이의 차이의 제곱의 평균 계산



# 요액요약하자면, 이 코드는 모델을 학습시킬 때 확률적 경사 하강법을 사용하고, 
#가중치를 업데이트할 때의 학습률을 0.1로 설정하며, 모델의 성능을 평가할 때 평균 제곱 오차를 사용하도록 설정합니다.
model.compile(optimizer = tf.keras.optimizers.SGD(learning_rate=0.1), loss='mse')


4. 모델 summary()확인하기
Model: "sequential_2"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_3 (Dense)             (None, 2)                 6         

 dense_4 (Dense)             (None, 1)                 3         

=================================================================
Total params: 9 (36.00 Byte)
Trainable params: 9 (36.00 Byte)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________


5. 학습하기
- epochs는 지정된 횟수만큼 학습을 한다.
- batch_size는 한번의 학습에 사용될 데이터의 수 지정
hist = model.fit(X, y, epochs=5000, batch_size = 1)



6. predict 해보기
model.predict(X)
#결과
1/1 [==============================] - 0s 40ms/step
array([[0.06890578],
       [0.92386585],
       [0.92361   ],
       [0.0615157 ]], dtype=float32)


7. 시각화
plt.plot(hist.history['loss'])

4. XOR2 (분류 사용)

1. iris 데이터 불러오기
from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data
y = iris.target


2. OneHotEncoder
from sklearn.preprocessing import OneHotEncoder

#원-핫 인코더 객체 생성 
#sparse=False 는 인코딩된 결과를 밀집된 NumPy 배열 형태로 반환하도록 설정
enc = OneHotEncoder(sparse=False, handle_unknown = 'ignore') 
enc.fit(y.reshape(len(y), 1)) # 인코더를 y 데이터에 맞춰 학습 원핫 인코더는 기본적으로 2차원 입력 기대



3. enc.categories_ #인코더가 학습한 카테고리 확인
#출력
[array([0, 1, 2])]


4. #웟-핫 인코딩 변환 : enc.transform()함수를 사용하여 타켓 변수 y를 원-핫 인코딩된 배열로 변환한다. 변환된 결과는 y_onehot에 저장
y_onehot = enc.transform(y.reshape(len(y),1))
y_onehot[:3]
#출력
array([[1., 0., 0.],
       [1., 0., 0.],
       [1., 0., 0.]])

5.훈련, 테스트 세트로 나눈다. 모델을 훈련할 떄 과적합을 방지하기 위함
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y_onehot, test_size=0.2, random_state=13)

6. 4개의 층 layer 구송된 신경망 모델 정의
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(32, input_shape=(4,), activation='relu'),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(3, activation='softmax')
])

• 하나의 뉴런 끝단에 activation이라는 아이가 붙어 있다.

• 신경망의 각 뉴런은 입력값을 받아서 가중치와 결합하고, 그 합에 활성화 함수를 적용한다. 이활성화 함수는 뉴런 출력을 결정하는 중요한역할

• 비선형성 추가: 활성화 함수가 선형이라면 신경망 층을 아무리 많이 쌓아도 결국 하나의 선형 함수로 표현될 수 있다는 것을 의미

• 활성화 함수의 예

  • ReLU: 가장 널리 사용되는 활성화 함수 중 하나로, 음수 입력에 대해 0을 출력하고, 양수 입력에 대해 입력값을 그대로 출력

  • 시그모이드: 출력값을 0과 1사이로 조정한다.

    

• 역전파의 주요 목적은 신경망의 가중치를 조정하여 예측 오차를 최소화하는 것

• 역전파는 오차를 줄이기 위해 신경망을 통해 오차 신호를 역방향으로 전파하며, 이 과정에서 각 층의 가중치를 조정

• 이때 전달하는것은 현재 내가 틀린정도 '미분(기울기)'한거

• 미분하고, 곱하고, 더하고를 역방향으로 반복하며 업데이트한다.)

• 레이어가 깊을 수록 업데이트가 사라져간다. 그래서 fitting이 잘 안된다.
• 뒤로 전달할수록 입력부분은 레이어가 깊어지면 매우 작은값이 된다.
• 선생님의 말씀이 뒤에있는 학생은 잘안들리는 원리...

• 사그라드는 sigmoid대신 죽지않는 activation func을 쓰자
• 에러 크기를 계속 크게 전달해준다.
• 은닉층은 대부분 ReLU를 사용한다.

• Softmax는 역전파, 그래디언트 소실 문제, ReLU 활성화 함수와 같은 신경망의 학습 과정에 밀접한 관련이 있다,.
• 신경망의 출력층에서 사용되는 활성화 함수로, 클래스 분류 문제에서 각 클래스에 속할 확률을 계산하는 데 사용된다.
• 출력 3개의 값을 1로 관리 가장 높은 값을 정답으로 말한다.
• 신경망을 훈련시키기 위한 최적화 알고리즘 중 하나이다.
• 역전파 알고리즘을 사용하여 가중치를 업데이트하는 과정에서, Adam은 그래디언트의 1차 모멘트(평균), 2차 모멘트(분산)을 모두 계산하여 가중치를 조정
• gradient 소실문제를 완화 한다. 특정 가중치에 대해 그래디언트가 매우 작아지더라도, Adam은 이를 고려하여 학습률을 조정할 수 있다.
• ReLU:ReLU활성화 함수는 그래디언트 소실 문제를 완화하는 데 도움을 줄 수 있으며 Adam과 함께 사용되어 신경망의 성능을 향상시킬 수 있다.
• Softmax: Softmax: 주로 신경망의 출력층에서 사용되며, Adam과 함께 사용되어 다중 클래스 분류 문제에서 좋은 성능을 낸다.
• 결론: Adam은 그래디언트 1,2차 모멘트를 사용하여 가중치를 업데이트하는 고급 최적화 알고리즘이며 신경망 학습 성능을 향상시킬 수 있다.

• Gradient Decent

  • 모든 걸 계산(1시간)후 최적의 한스텝 6스텝 * 1시간 = 6시간 최적인데 너무 느리다.

• Stochastic Gradient Descent

  • 일부만 검토(5분) 틀려도 일단 간다! 빠른 스텝! 11스텝 * 5분 = 55분 < 1시간
  • 조금 헤매도 어쩃든 인근에 아주 빨리 갔다.

7.신경망 모델을 컴파일하고, 모델의 구조를 요약하여 출력하는 데 사용된다.
#adam 최적화 알고리즘과 categorical_crossentropy 손실 함수를 사용하여 모델을 컴파일하고, 모델 정확도를 평가할 지표러
#accuracy를 설정한다. 그후 model.summary()를 호출하여 모델 구조 출력
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()
#출력
Model: "sequential_7"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense_21 (Dense)            (None, 32)                160       

 dense_22 (Dense)            (None, 32)                1056      

 dense_23 (Dense)            (None, 32)                1056      

 dense_24 (Dense)            (None, 3)                 99        

=================================================================
Total params: 2371 (9.26 KB)
Trainable params: 2371 (9.26 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________



8.X_train 입력 데이터를 사용하여 신경망 모델을 훈련시킨다. 오차를 계산하고 역전파(adam) 알고리즘을 통해 모델의 가중치 업데이트
hist = model.fit(X_train, y_train, epochs=100)




9.테스트 데이터를 사용하여 모델의 성능을 평가하고, 손실 및 정확도를 출력
model.evaluate(X_test, y_test, verbose=2)
#출력
1/1 - 0s - loss: 0.0845 - accuracy: 0.9667 - 112ms/epoch - 112ms/step
[0.08453787118196487, 0.9666666388511658]


10. 그래프
plt.plot(hist.history['loss'])
plt.plot(hist.history['accuracy'])

NLP은 언어를 이해하고 처리하는 컴퓨터 프로그램을 개발하는 인공지능 분야

• 개념

1. 텍스트 데이터 처리: NLP는 텍스트 데이터를 기본 단위로 취급
2. 토큰화(Tokenization): 텍스트 데이터를 분할하여 처리하는 과정
3. 텍스트 분류(Text Classification): NLP는 텍스트 데이터를 카테고리로 분류하는 작업에 사용된다. 스팸 이메일 감지, 감정 분석, 토픽 분류 등이 포함
4. 감정 분석(Sentiment Analysis): NLP는 텍스트에 담긴 감정을 분석하고 이해하는 데 사용된다. 제품 리뷰, 소셜 미디어 게시물 등에서 사용자 의견을 추출하고 분석
5. 워드 임베딩(Word Embeddings): NLP는 단어를 벡터로 표현하는 기술 이를 통해 단어 간 유사성을 계산하고, 머신러닝 모델에 텍스트 데이터ㅡㄹㄹ 입력으로 공급

1. KoNLPy 한국어 정보처리 파이썬 패키지

1.
from konlpy.tag import Kkma
kkma = Kkma()  # Kkma 클래스의 인스턴스 생성

2. 형태소 분석
from konlpy.tag import Kkma
kkma = Kkma()  # Kkma 클래스의 인스턴스 생성
#출력
[('한국어', 'NNG'),
 ('분석', 'NNG'),
 ('을', 'JKO'),
 ('시작하', 'VV'),
 ('ㅂ니다', 'EFN'),
 ('.', 'SF')]



 4. 한나눔 엔진 nouns
from konlpy.tag import Hannanum
hannanum = Hannanum()
hannanum.nouns('한국어 분석을 시작합니다 재미있어요~~') #명사분석
#출력 ['한국어', '분석', '시작']



5. 한나눔 morphs
hannanum.morphs('한국어 분석을 시작합니다 재미있어요~~')
#출력 ['한국어', '분석', '을', '시작', '하', 'ㅂ니다', '재미있', '어요', '~~']



6. 한나눔 pos
hannanum.pos('한국어 분석을 시작합니다 재미있어요~~')
#출력
[('한국어', 'N'),
 ('분석', 'N'),
 ('을', 'J'),
 ('시작', 'N'),
 ('하', 'X'),
 ('ㅂ니다', 'E'),
 ('재미있', 'P'),
 ('어요', 'E'),
 ('~~', 'S')]

2.워드 클라우드(Word Cloud)

워드 클라우드: 텍스트 데이터에서 자주 등장하는 단어를 시각적으로 나타내는 기술 텍스트 데이터의 핵심 주제나 키워드를 빠르게 파악하고 시각적으로 표현

• 특징

1. 주어진 텍스트 데이터에서 각 단어의 빈도를 계산한다.
2. 시각적 표현: 워드 클라우드는 단어를 시각적으로 나타낸다. 빈도 높은 단어는 글씨가 크게 표현
3. 색상 및 레이아웃: 워드 클라우드에는 단어의 색상과 배치를 설정한다.

from wordcloud import WordCloud, STOPWORDS
import numpy as np
from PIL import Image


1. 그림 가져오기
text = open(r'C:\Users\edgar\Desktop\제로베이스\머신러닝\자연어\06_alice.txt').read()
print(text)


2. 픽셀 이미지를 출력하면 숫자로 나온다.
alice_mask = np.array(Image.open(r'C:\Users\edgar\Desktop\제로베이스\머신러닝\자연어\06_alice_mask.png'))
alice_mask
#출력
array([[255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255],
       ...,
       [255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255]], dtype=uint8)


3.불용어를 set 집합으로만들기
stopwords = set(STOPWORDS)
stopwords   
#출력
{'a',
 'about',
 'above',
 'after',
 'again',
 'against',


4.  특정 단어 said 제외시키기
stopwords.add('said')



5. array로 변환한 데이터 시각화
array로 변환한 alice_mask를 시각화하기
plt.figure(figsize=(8,8))
plt.imshow(alice_mask, cmap = plt.cm.gray, interpolation= 'bilinear')

2-1 WordCloud 모듈은 자체적으로 단어를 추출해서 빈도수를 조사하고 정규화하는 기능을 가지고 있다.

wc = WordCloud(
    background_color = 'white', max_words=2000, mask = alice_mask, stopwords=stopwords #최대글자 2000   #mask는 현재 array 엘리스
)
wc = wc.generate(text)   #generate는 텍스트 데이터에서 가장 빈번하게 등장하는 단어를 추출하고 워드 클라우드를 생성



wc.words_  #단어들의 발생빈도
{'Alice': 1.0,
 'little': 0.29508196721311475,
 'one': 0.27595628415300544,
 'know': 0.2459016393442623,
 'went': 0.226775956284153,



 # 발생빈도 시각화
 plt.figure(figsize= (12,12))
plt.imshow(wc)
plt.axis('off')

2-2 이미지 색깔 입히기

import random

#워드 클라우드에서 사용될 단어 색상 결정 함수
def grey_color_func(word, font_size, position, orientation, random_state=None, **kwargs): #orientation 단어의 방향, **kwargs 추가 키워드 인수
    return 'hsl(0, 0%%, %d%%)' % random.randint(60, 100)


plt.figure(figsize=(12,12))
plt.imshow(wc.recolor(color_func = grey_color_func, random_state=13))
plt.axis('off')
plt.show() 

3. 영어의 연어(collocation)

import nltk
# 불용어 데이터 다운로드
nltk.download('stopwords')


ko.collocations()
# 초등학교 저학년; 근로자 육아휴직; 육아휴직 대상자; 공무원 육아휴직



data = ko.vocab().most_common(150)

font_path = 'C:/Windows/Fonts/malgun.ttf'  # 'Malgun Gothic' 폰트 경로
relative_scaling = 0.2
background_color = 'white'


wordcloud = WordCloud(
    font_path=font_path,
    relative_scaling=relative_scaling,    #상대적인 크기를 조절하는 매개변수 
    background_color=background_color
).generate_from_frequencies(dict(data)) #빈도 정보를 입력으로 받아 워드 클라우드 이미지 생성

plt.figure(figsize= (12,8))
plt.imshow(wordcloud)
plt.axis('off')
plt.show()

4. 나이브베이즈

• 기계 학습 분야에서 나이브 베이즈 분류 는 특성들 사이 독립을 가정하는 베이즈 정리를 적용한 확률 분류기의 일종
• 텍스트 분류에 사용됨으로 문서를 여러 범주(스팸, 스포츠, 정치)중 하나로 판단하는 문제에 대한 대중적인 방법으로 남아있다.
• 적절한 전처리를 하면 더 진보 된 방법들 서포트 벡터 머신과도 충분한 경잭력을 보임을 알 수 있다.
• skelarn에서는 fit를 사용하지만 나이브베이즈 에서는 train(t)사용

from nltk.tokenize import word_tokenize
import nltk


1.
# Naive Bayes 분류기는 지도학습이라서 정답을 알려주어야 한다.
train = [
    ('i like you', 'pos'),
    ('i hate you', 'neg'),
    ('you like me', 'neg'),
    ('i like her', 'pos'),
]

2.
train[0][0]
'i like you'


3.
# word_tokenize는 띄어쓰기를 기준으로 단어를 분리한다.

sentence = train[0]
word_tokenize(sentence[0])  
['i', 'like', 'you']


4.
#코드설명: train 리스트에 있는 학습 데이터에서 텍스트를 토큰화하고 모든 단어를 소문자로 변환하여 집합(set)에 저장한다.
#결과로 출력되는 집합은 중복 단어를 제거한 모든 단어 집합
#즉 출력된 결과는 중복 단어가 제거되어 나타난 결과가 출력된다.

all_words = set(
    word.lower() for sentence in train for word in word_tokenize(sentence[0])
)
all_words
#출력 {'hate', 'her', 'i', 'like', 'me', 'you'}



5.
t = [({word: (word in word_tokenize(x[0]))for word in all_words}, x[1]) for x in train]
t

#{word: (word in word_tokenize(x[0]))for word in all_words}, x[1] 이부분은 i like you  즉 train데이터의 문장 의미
# x[1]은 pos, neg
# word_tokenize(x[0])는 텍스트를 단어로 토큰화하는 작업 수행
#word in word_tokenize(x[0]) 단어가 해당 문장에 존재하는지 여부를 True ,False로 반환

#출력
[({'me': False,
   'like': True,
   'hate': False,
   'her': False,
   'i': True,
   'you': True},
  'pos'),
 ({'me': False,
   'like': False,
   'hate': True,
   'her': False,
   'i': True,
   'you': True},
  'neg'),....



6. 학습
classifier = nltk.NaiveBayesClassifier.train(t)

7.
classifier.show_most_informative_features() #가장 많은 정보를 가지고 있는 특성 나열

#해석 hate가 없을 확률이 pos가 1.7 확률로 pos
#her가 없을 확률이 1.7 활률로 neg
#출력
                    hate = False             pos : neg    =      1.7 : 1.0
                     her = False             neg : pos    =      1.7 : 1.0
                       i = True              pos : neg    =      1.7 : 1.0






8.
test_sentence = 'i like MeRui'

test_sent_features = {
    word.lower(): (word in word_tokenize(test_sentence.lower())) for word in all_words
}
test_sent_features

#출력
{'me': False,
 'like': True,
 'hate': False,
 'her': False,
 'i': True,
 'you': False}



9. 결과 출력
classifier.classify(test_sent_features)
#만들어낸 말뭉치와 데이터에 의해서 학습 해본 결과 'i like MeRui' pos가 되었다.

최근접이웃(K Nearest Neighber):지도학스(Supervised Learning)의 일종으로, 분류(Classification)와 회귀(Regression) 문제에 사용되는 간단하면서도 강력한 알고리즘이다. 주로 패턴 인식, 데이터 마이닝, 추천 시스템 등 다양한 분야에서 활용된다.

• 동작 원리

1. 학습(Training): 먼저, 알고리즘이 학습 데이터 세트를 사용하여 데이터의 특징을 학습한다. 각 데이터 포인트는 해당 데이터의 특징 벡터와 그에 해당하는 레이블 또는 값을 가지고 있어야 한다.
2. 거리 측정(Measuring Distance): 예측하려는 데이터 포인트와 학습 데이터 포인트 사이의 거리를 측정한다. 주로 유클리드 거리(Eucllidean Distance)가 사용된다.
3. K-최근접 이웃 찾기(Finding k Nearest Neighbors): 거리가 가장 가까운 k개의 학습 데이터 포인트를 찾는다.
4. 다수결 투표(Majority Vote): 분류 문제의 경우, k개의 최근접 이웃 중에서 가장 많은 수의 이웃이 어떤 클래스에 속하는지 투표를 통해 결정한다. 회귀 문제의 경우, k개의 최근접 이웃의 값 평균을 구하여 예측값을 계산한다.

• 요약: 최근접이웃은 학습시키는 과정이 없으며, 예측할 때마다 거리를 계산하기 때문에 실시간 예측이 가능하다는 장점이 있다. 또한, 간단한 구현과 하이퍼파라미터인 k를 조정하여 모델 성능을 조절할 수 있다는 점에서 사용하기 쉽다.

GBM

GBM(Graduebt Biistubg Machine): 앙상블 학습 알고리즘이며 약한 학습기(weak learner)를 결합하여 학습 모델을 만든다. 회귀, 분류에서 사용한다.

• 특징

1. 부스팅(Boosting):약한 학습기(weak learner)들을 순차적으로 훈련하고 예측 오차를 보정하며 진화시킨다. 각 학습기는 이전 학습기가 만든 오차를 보완하도록 훈련된다.
2. 그레디언트: 손실 함수(Loss Function)의 그레디언트(기울기)정보를 활용하여 모델을 학습하는 방식을 의미한다. 즉, 오차의 그레디언트를 이용하여 예측값을 업데이트한다.
3. 약한 학습기: 결정 트리(Decision Tree)를 약한 학습기로 사용한다. 각 결정 트리는 데이터의 일부를 학습하고 예측을 수행한다. 이렇게 각각의 결정 트리는 데이터의 패턴을 학습하고 예측을 수행한다.
4. 과적합 제어: GBM은 오차 보정을 통해 과적합(Overfitting)을 제어하려고 노력한다. 오차를 보정하면서 모델이 데이터에 과도하게 적합되는 것을 방지하며 일반화 성능을 향상시킨다.
5. 하이퍼파라미터 튜닝: GBM 모델은 여러 하이퍼파라미터를 조절할 수 있으며, 이를 튜닝하여 모델 성능 최적화
6. 속도가 매우 느리다.

XGBoost

1. 부스팅 알고리즘: XGBoost는 부스팅 알고리즘이며 약한 학습기를 순차적으로 훈련하여 예측 오차를 보정하고 모델 정확도를 향상한다.
2. 그레디언트 부스팅: 손실 함수의 그레디언트(기울기)정보를 활용하여 예측값을 업데이트한다. 오차를 최소화하기 위해 모델 학습을 한다.
3. 결정 트리 앙상블: 다수의 결정 트리를 조합하여 강력한 앙상블 모델을 형성한다.
4. 속도와 성능: 빠른 속도와 높은 성능을 제공한다. 다양한 최적화 기법과 병렬 처리를 통해 빠른 훈련 및 예측을 가능하게 한다.
5. 튜닝 가능한 하이퍼파라미터: 다양한 하이퍼파라미터를 조절하여 모델을 세밀하게 튜닝할 수 있다. 하이퍼파라미터의 조정을 통해 모델 성능을 최적화한다.
6. 과적합 제어: 과적합 방지
7. 자동 조기 중단(Early Stopping): 교차 검증을 통해 모델 성능을 모니터링하고, 지정된 조기 중단 기준을 충족하면 훈련을 조기 중단 한다.

LGBM

1. 그레디언트 부스팅 알고리즘: LGBM은 그레디언트 부스팅 알고리즘 기반이다. 약한 학습기(weak learner)들을 순차적으로 훈련하고 예측 오차를 보정하여 모델 향상
2. 히스토그램 기반 부스팅:데이터를 빠르게 정렬하고 분할하기 위해 히스토그램 활용하는 방식. 이러한 방식은 훈련 속도를 크게 향상시킨다.
3. 빠른 속도와 메모리 효율성: XGBoost와 비교하여 빠른 속도와 낮은 메모리 사용량을 제공
4. 다양한 데이터 유형 지원: LGBM은 범주형 데이터를 자동으로 처리하고, 다양한 유형의 데이터에 적용

앙상블 기법

• Voging,Bagging,Boosting,
• voting과 bagging은 여러개의 분류기가 투표를 통해 최종 예측 결과를 결정하는 방식
• 보팅과 배깅의 차이점은 보팅은 각각 다른 분류기, 배깅은 같은 분류기를 사용
• 대표적인 배깅 방식이 랜덤 포레스트

• 배킹과 부스팅의 차이

차이점

1. 배깅은 병렬적으로 모델을 학습하고 예측을 결합하는 반면, 부스팅은 순차적으로 모델을 학습하고 이전 모델의 오차를 보완
2. 배깅은 각 모델이 독립적으로 학습하므로 모델 간에 상호 작용이 없다. 부스팅은 모델 간 상호 작용을 고려하여 앙상블을 구축한다.
3. 배깅은 과적합을 줄이고 모델 간의 분산을 감소시키는 데 도움이 되며, 안정적인 예측을 제공한다. 부스팅은 훈련 데이터에 더 잘 맞게 되며 높은 성능을 제공하지만 과적합에 민감하다.

AdaBoost(adaptive Boosting)

에이다부스트: 약한 학습기(weak learner)를 결합하여 강한 학습기(strong learner)를 구축하는 방법 중 하나이다.

• 에이다 부스트는 이전 모델들이 놓친 샘플에 더욱 집중하여 오분류율을 줄이는 방식으로 동작한다. 매우 강력한 앙상블 모델을 만들어내며, 과적합에도 비교적 강한 성능을 가질 수 있다. adaboost는 분류 문제에서 주로 사용되며, 의사 결정 트리,SVM,나이브 베이즈 등 다양한 약한 학습기와 함께 사용

부스팅 기법

Boost

1. GBM(Gradient Boosting Machine)

• GBM은 부스팅 알고리즘 중 가장 기보존적인 형태로 예측 오차를 최소화하기 위해 경사 하강법(Gradient Descent)을 사용한다.
• 이전 모델에서 발생한 오차를 보안화는 새로운 모델을 학습하는 과정을 반복하여 모델을 구축한다.
• GBM은 과적합에 민감하며 모델 파라미터 튜닝이 중요하다.

2. XGBoost(Extreme Gradient Boosting)

• GBM의 확장된 버전으로, 더욱 효율적인 알고리즘과 정규화 기능 제공
• 자동으로 결측값 처리, 카테고리 변수 처리, 조기 중단 기능 등을 제공하여 모델의 성능을 향상

3. LightGBM(Light Gradient Boosting Machine):

• GBM의 경량화된 버전으로, 빠른 학습 속도와 효율적인 메모리 사용 제공
• Leaf-wise Growth 알고리즘과 최대 손실(Gradient)기반 스플릿 방식을 사용하여 빠르게 모델을 학습할 수 있다.
• LightGBM은 대규모 데이터셋에서도 빠르게 처리할 수 있으며, 카테고리 변수를 처리하는 데 용이하다.

Bagging

앙상블(Ensemble): 다양한 학습 알고리즘을 결합 하여 더 강력하고 안정적인 모델을 만드는 방법. 앙상블은 단일 모델보다 더 좋은 예측 성능을 달성하고 모델의 과적합을 줄인다. 분류(Classfication) 및 회귀(Regression)문제에서 사용된다.

• 설명

1. 다양한 알고리즘 사용: 앙상블은 서로 다른 학습 알고리즘을 사용하는 여러 모델을 결합 ex) 결정 트리, 랜덤 포레스트, 그래디언트 부스팅

• 장점

1. 예측 성능 향상: 여러 모델의 예측을 결합하기 때문에 단일 모델보다 높은 예측 성능을 제공할 수 있다.
2. 과적합 감소: 다양한 모델을 결합하면 과적합(Overfitting)을 줄일 수 있다.
3. 안정성 향상: 앙승블은 모델의 안정성을 높인다.

• 종류
• 랜덤 포레스트, 그래디언트 부스팅, 에이다부스트, 배깅

2. voting

앙상블 투표(voting)는 앙상블 학습 기법중 하나이며 다른 모델 예측을 결합하여 최종 예측을 만드는 방법이다. 이 방법은 분류(Classification)문제에서 사용되며 여러 모델로부터 얻은 예측 결과를 투표를 통해 다수결 원칙에 따라 최종예측을 선택

• 투표 종류

1. 하드 투표(Hard Voting): 다수의 모델 중에서 가장 많은 모델이 예측한 클래스 레이블을 최종 예측으로 선택 이 방식은 이진 분류 문제나 다중 클래스 분류 문제에서 사용
2. 소프트 투표(Soft Voting): 다수의 모델로부터 얻은 확률 예측값을 평균하거나 가중 평균하여 가장 높은 확률을 가진 클래스 레이블을 최종 예측으로 선택
3. 가중 투표(Weighted Voting): 다수의 모델의 예측에 각각 가중치를 부여하고, 가중 평균을 통해 최종 예측을 선택 이 방식은 모델의 신뢰도에 따라 가중치를 조절할 때 사용

hard voting

soft voting

3. bagging

bagging(Bootstrap Aggregating)은 앙상블 학습(Ensemble Learning) 기법 중 하나로, 동일한 기계 학습 알고리즘을 사용하는 여러 모델을 훈련시키고, 이들 모델의 예측 결과를 결합하여 좀더 안정적인 모델을 만드는 방법이다. 주로 과적합을 줄이고 예측 성능 향상

• 설명

1. 표본 복원 샘플링(Bootstrap Sampling): 배깅은 원래 데이터셋에서 부트스트랩 샘플(Bootstrap Sample)을 생성하여 각 모델을 훈련한다. 부트스트랩 샘플링은 무작위로 원본 데이터에서 샘플을 선택하고, 선택한 샘플을 다시 원본 데이터셋에 반환하는 방식으로 이루어진다. 이로써 각 모델이 서로 다른 훈련 데이터를 가지게 된다
2. 병렬 처리: 배깅은 병럴 처리에 적합하므로, 다수의 모델을 동시에 훈련시키는 데 효과적이다. 모델은 서로 독립적으로 훈련되기 때문에 병렬 실행 가능
3. 모델 다양성: 각 모델은 부트스트랩 샘플에 따라 다르게 훈련되므로 다양한 관점에서 데이터를 학습한다. 모델 간의 다양성이 높아지며 모델 예측 성능 향상한다.
4. 결합 방법: 각 모델로 얻은 예측 결과를 평균하거나 다수결 원칙에 따라 최종 예측을 결정한다. 분류 문제에선느 하드 투표 방식을 주로 사용하며, 회귀 문제에서는 평균 예측 값을 사용할 수 있다.

4. Random Forest

랜덤 포레스트 :결정 트리(Decision Tree)를 기반으로 하는 앙상블(Ensemble Learning)기법 중 하나이다. 다수의 결정 트리를 생성하고 이들을 조합하여 안정적인 모델을 만든다. 분류(Classification)와 회귀(Regression)문제에 적용

• 설명

1. 부트스트랩 샘플링(Bootstrap Sampling): 랜덤 포레스트는 원본 데이터셋으로부터 복원 샘플(부트스트랩 샘플)을 생성 각 부트스트랩 샘플은 원본 데이터셋에서 무작위로 선택한 샘플로 구성 이로써 각 결정 트리 모델이 다른 훈련 데이터를 가지게 된다.
2. 랜덤 특성 선택(Random Feature Selection): 각 결정 트리를 훈련할 때, 특성(변수)을 무작위로 선택하거나 일부 특성을 제외하여 트리의 다양성을 높인다. 이는 과적합을 줄이고 모델의 안정성을 향상한다.
3. 다수결 투표(Majority Voting): 랜덤 포레스트는 생성된 다수의 결정 트리로부터 예측을 수집하고, 다수결 원칙에 따라 최종 예측을 만든다. 분류 문제에서는 각 트리의 예측 클래스 레이블 중 가장 많이 나온 클래스가 최종 예측 클래스가 된다.
4. 앙상블의 안정성과 일반화 능력 향상: 랜덤 포레스트는 다수의 결정 트리를 결합하여 모델의 예측 성능을 높이고 과적합을 방지한다. 각 트리는 서로 다른 훈련 데이터와 특성을 가지며, 이로 인해 모델의 다양성과 안정성이 증가.

5. HAR(Human Activity Recognition)

HAR: 머신 러닝 패턴 인식 기술을 사용하여 사람의 활동, 동작을 자동으로 감지하고 분류하는 기술 주로 센서 데이터와 머신 러닝 알고리즘을 결합하여 사용된다.

1. 정밀도(Precision): 모델이 양성 클래스로 예측한 샘플 중 실제로 양성 클래스에 속한 샘플의 비율을 나타낸다.
2. 재현율(Recall): 재현율은 실제로 양성 클래스에 속한 샘플 중 모델이 양성 클래스로 올바르게 예측한 샘플의 비율을 나타낸다.
3. 트레이드 오프: 정밀도와 재현율은 서로 상충 관계에 있으며 한 지표를 높이려면 다른 지표가 낮아진다. 이것이 정밀도와 재현율의 트레이드 오프이다.

• 임계값 증가: 임계값을 높이면 정밀도(Precision)증가하고 재현율(Recall)감소
• 임계값 감소: 모델의 임계값을 낮추면 재현율(Recall) 증가하고 정밀도(Precision) 감소한다.

#데이터분리
import pandas as pd
red_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-red.csv'
white_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/winequality-white.csv'


white_wine = pd.read_csv(white_url, sep=';')
red_wine = pd.read_csv(red_url, sep=';')

red_wine['color'] = 1.
white_wine['color'] = 0.


wine = pd.concat([red_wine, white_wine])
wine['taste'] = [1. if grade>5 else 0. for grade in wine['quality']]

X = wine.drop(['taste', 'quality'],axis=1)
y = wine['taste']





from sklearn.model_selection import train_test_split

X_train, X_test, y_train,y_test = train_test_split(X, y, test_size=0.2, random_state=13






#간단한 로지스틱 회귀 적용
from sklearn.linear_model import LogisticRegression

lr = LogisticRegression(solver='liblinear', random_state=13) #solver=liblinear (로지스틱 회귀의 최적화 문제 해결)lr = LogisticRegression(solver='liblinear', random_state=13) #solver=liblinear (로지스틱 회귀의 최적화 문제 해결)
lr.fit(X_train, y_train)

y_pred_tr = lr.predict(X_train) # 위에서  X_train을 학습했는데 왜 또하느냐.... 수치를 확인하기 위함이다!
y_pred_test = lr.predict(X_test)

print('Train Acc :' ,accuracy_score(y_train, y_pred_tr))
print('Test Acc :' ,accuracy_score(y_test, y_pred_test))
#Train Acc : 0.7427361939580527
#Test Acc : 0.7438461538461538




from sklearn.metrics import classification_report
print(classification_report(y_test, lr.predict(X_test)))  #모델 분류 성능 요약 보고서 출력
#출력
#macro avg 평균이라고 생각
              precision    recall  f1-score   support

         0.0       0.68      0.58      0.62       477
         1.0       0.77      0.84      0.81       823

    accuracy                           0.74      1300
   macro avg       0.73      0.71      0.71      1300
weighted avg       0.74      0.74      0.74      1300





from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_test, lr.predict(X_test))
      )

#  [275, 202]  --> 0을 275개  1을 202개   (0 갯수를 제대로 못맞춤)
#  [131, 692]  1을 692개 맞춤
#출력
#[[275 202]
 #[131 692]]

Precision_recall curver

Precision=Recall Curver(정밀도 -재현율 곡선): 분류 모델 성능을 시각적으로 평가하기 위한 그래프이다. 이 곡선은 임계값(threshold)에서 정밀도와 재현율의 값을 나타낸다.

import matplotlib.pyplot as plt
from sklearn.metrics import precision_recall_curve





plt.figure(figsize=(10, 8))
pred = lr.predict_log_proba(X_test)[:, 1]  # 클래스별로 확률 계산
#log_proba 로그(X_test) 확률을 예측한다.
#[:,1] 로그 확률에서 두번째열을 선택하는 부분() 0또는1)

precisions, recalls, thresholds = precision_recall_curve(y_test, pred)
#정밀도, 재현율, 임계값

plt.plot(thresholds, precisions[:len(thresholds)], label='precisions')
#x좌표 thresholds   y좌표 precisions    label은 선또는 점에대한 레이블을 지정한다.

plt.plot(thresholds, recalls[:len(thresholds)], label='recalls')
plt.grid()
plt.legend()

#예측결과 확인
#예측결과 확인 (0또는 1)
pred_proba = lr.predict_proba(X_test)
pred_proba[:3]

#0에속할확률 0.405
#1에속할확률 0.594
#왼쪽은 0에속할확률 오른쪽은 1에속할 확률이다
#출력
#array([[0.40526731, 0.59473269],
#       [0.50957556, 0.49042444],
#       [0.10215001, 0.89784999]])





pred_proba
#array([[0.40526731, 0.59473269],
#       [0.50957556, 0.49042444],
#       [0.10215001, 0.89784999],
#       ...,
#       [0.22540242, 0.77459758],
#       [0.67366935, 0.32633065],
#       [0.31452992, 0.68547008]])






y_pred_test.reshape(-1,1).shape  #reshape를 사용하는이유는  pred_proba 옆에다 추가를 해야하는데 
                          #pred_proba가 리스트가 2개로 구성되어있는 형태라서   예측값(y_pred_test)도 리스트로 만들어주는 작업이다.


#코드해석: -1은 차원의 크기를 자동으로 계산하라는 의미이며 1은 열의개수를 1로 지정한다.(배열의 원래 모양을 유지하되 열 벡터로 재구조화 하라는 의미)
# 위에 y_pred_test.shape를  (1300,1)로 나오게끔 만들기





#pred_proba 옆에다 y_pred_test(예측값) 추가하기

import numpy as np
np.concatenate([pred_proba, y_pred_test.reshape(-1,1)], axis=1)
#array([[0.40526731, 0.59473269, 1.        ],
#       [0.50957556, 0.49042444, 0.        ],
#       [0.10215001, 0.89784999, 1.        ],
#       ...,
#       [0.22540242, 0.77459758, 1.        ],
#       [0.67366935, 0.32633065, 0.        ],
#       [0.31452992, 0.68547008, 1.        ]])

threshold 바꿔보기 Binarizer

Binarizer: 연속형(continuous)데이터를 이진(binary)형식으로 변환하며 Binarizer를 사용하면 특정 임계값(threshold)을 기준으로 입력 데이터를 이진 형태로 변환한다.

#Binarizer 클래스를 사용하여 예측 확률을 이진화하는 작업 수행

from sklearn.preprocessing import Binarizer
binarizer = Binarizer(threshold=0.6).fit(pred_proba) #쓰레스홀드 매개변수를 0.6으로 설정하여 임계값 0.6으로 지정
                                            #proba  --> 예측 확률을 이진화





pred_bin = binarizer.transform(pred_proba)[:,1]#transform 메소드를 사용하여  pred_proba의 예측 확률을 이진화한다.
pred_bin
# 예측 확률을 0또는 1로변환   예측 확률이 임계값(0.6)보다 크면1 작으면 0으로 변
# 출력 array([0., 0., 1., ..., 1., 0., 1.])




#replort 사용
print(classification_report(y_test, lr.predict(X_test)))
#              precision    recall  f1-score   support
#
#        0.0       0.68      0.58      0.62       477
#       1.0       0.77      0.84      0.81       823
#
#   accuracy                           0.74      1300
# macro avg       0.73      0.71      0.71      1300
#weighted avg       0.74      0.74      0.74      1300

로지스틱(Logistic Regression)

• 분류(Classification) 문제를 다루기 위한 통계적 기계 학습 알고리즘이며 분류(classification)알고리즘이다.
• 주로 이진 분류(Binary Classification)문제를 다루며, 샘플을 구 개의 클래스 중 하나로 분류하는 데 사용된다.
• 특징

1.로지스틱 함수: 로지스틱 함수 or 시그모이드 함수 를 사용하여 입력 특성과 가중치의 선형 결합을 변환한다. 0과 1사이의 값을 출력하며 이를 확률로 해석할 수 있다. 2. 이진 분류:이진 분류에서 많이 사용한다. ex) 스팸 메일 여부, 질병 발병 여부 예측 3. 최적화: 로지스틱 회귀 모델을 학습하기 위해 최적화 알고리즘 사용 루고 손실을 최소화하는 방향으로 모델 파라미터(가중치) 조정한다.

시그모이드 사용

import numpy as np
z = np.arange(-10, 10, 0.01)
g = 1 / (1+np.exp(-z))


import matplotlib.pyplot as plt
plt.plot(z, g)
plt.grid()

gca 설정값 변경

GCA(Get Current Axes): 현재 활성화된 그래프(figure)에서 사용되고 있는 축(axes)객체를 가져온다. (선을 가져온다.)

# gca 설정값을 변경한다.
plt.figure(figsize=(12,8))
ax = plt.gca()

ax.plot(z,g)
ax.spines['left'].set_position('zero') #축을 옮긴다.  (zero 0 수치인곳)
ax.spines['bottom'].set_position('center')
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none') #오른쪽과 위쪽 축 제거

plt.show()

Cost Function 그래프

Cost Fubnction(비용 함수or 손실 함수): 모델의 예측값과 실제값 사이의 차이 또는 오차를 측정하는데 사용하며 모델을 학습하고 파라미터를 조정하는 과정에서 최소화하려는 목표로 사용

1. 모델평가: 얼마나 좋은지 예측한다. 예측값과 실제값 사이의 차이를 계산하여 모델의 성능 평가
2. 모델 학습:Cost Function을 최소화하는 방향으로 모델의 파라미터를 조정
3. 과적합(Overfitting)방지 :과적합을 방지하기 위해 Cost Function을 사용하여 모델의 복잡도를 제어

h = np.arange(0.01, 1, 0.01)
C0 = -np.log(1-h)
C1 = -np.log(h)

plt.figure(figsize=(12,8)) 
plt.plot(h, C0, label='y=0')
plt.plot(h, C1, label='y=1')

로지스틱 회귀 실습

import pandas as pd
wine_url = 'https://raw.githubusercontent.com/PinkWink/ML_tutorial/master/dataset/wine.csv'
wine = pd.read_csv(wine_url, index_col=0)  #Unnamed:0 삭제 index_col=0

wine




wine['taste'] = [1. if grade>5 else 0. for grade in wine['quality']]
X = wine.drop(['taste','quality'],axis=1)
y = wine['taste']





from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state= 13)




-------------------------------------------------
#간단 로지스틱 회귀 테스트

from sklearn.linear_model import LogisticRegression
#이진 분류나 다중 클래스 분류문제에서 사용된다. 

from sklearn.metrics import accuracy_score #분류 문제의 정확도 측정





#로지스틱 모델링 및 학습실행
lr = LogisticRegression(solver = 'liblinear', random_state=13) 
#최적화 수행 SOLVER
#solver ='liblinear' 최적화 알고리즘(데이터가 작으면 liblinear사용)
#다른 옵션:  newton-cg, lbfgs, sag, saga

lr.fit(X_train, y_train)





y_pred_tr = lr.predict(X_train)
y_pred_test = lr.predict(X_test)

print('Train Acc:',accuracy_score(y_train, y_pred_tr))
print('Train Acc:',accuracy_score(y_test, y_pred_test))
#Train Acc: 0.7425437752549547
#Train Acc: 0.7438461538461538





from sklearn.pipeline import Pipeline  #파이프라인 가져오기
from sklearn.preprocessing import StandardScaler #데이터 전처리 단계에서 사용할 StandardScaler 가져온다.
                                                 # StandardScaler는 입력 데이터의 평균을 0으로 표준 편차를 1로 만들어 데이터를 표준화한다.

estimators = [ #파이프라인에 사용할 단계 정의
    ('Sclaer', StandardScaler()),  #Scaler는 StandardScaler로 데이터를 표준화 하는 역할
    ('clf', LogisticRegression(solver='liblinear', random_state= 13)) # clf는 로지스틱 회귀 모델을 사용하여 분류 작업 수행


]
pipe = Pipeline(estimators)




#파이프라인 출력
pipe.fit(X_train, y_train)





y_pred_tr = lr.predict(X_train)
y_pred_test = lr.predict(X_test)

print('Train Acc:',accuracy_score(y_train, y_pred_tr))
print('Train Acc:',accuracy_score(y_test, y_pred_test))

#Train Acc: 0.7425437752549547
#Train Acc: 0.7438461538461538

결정 트리 (Decision tree

#트리 생성
from sklearn.tree import DecisionTreeClassifier

wine_tree = DecisionTreeClassifier(max_depth=2, random_state=13)
wine_tree.fit(X_train, y_train)





#결정트리 파이프라인
models = {
    'logistic regression': pipe,
    'decision tree':wine_tree
}






from sklearn.metrics import roc_curve
for model_name, model in models.items():
    #model_name 딕셔너리 key값
    #model 딕셔너리 values
    #딕셔너리 반복을 위한 items()

    print(model_name)
    print('---------------')
    print(model)    

#출력
#logistic regression
#---------------
#Pipeline(steps=[('Sclaer', StandardScaler()),
#                ('clf',
#                 LogisticRegression(random_state=13, #solver='liblinear'))])
#decision tree
#---------------
#DecisionTreeClassifier(max_depth=2, random_state=13)





#그래프출력
plt.figure(figsize=(10,8))
plt.plot([0,1], [0,1])  #  x,y (0,0)(1,1)까지 그래프 범위

for model_name, model in models.items():
    pred = model.predict_proba(X_test)[:, 1]    # predict_proba 1에속할 확률을 반환하기 위해 [:,1]사용 (predict_proba 모델이 예측한 결과의 확률 반환)
    fpr, tpr, thresholds = roc_curve(y_test, pred)#ROC곡선 계산한다.

    plt.plot(fpr, tpr, label=model_name)  

plt.grid()
plt.legend()
plt.show()

• 가격기준 히스토그램

• 상관관계

• 히트맵 (sns.heatmap(data=corr_mat, annot=True, cmap='bwr'))

• 선형회귀

  sns.set_style('darkgrid')
  sns.set(rc={'figure.figsize': (12,6)})
  fig, ax = plt.subplots(ncols=2)
  sns.regplot(x="RM", y="PRICE", data=boston_pd, ax=ax[0])
  sns.regplot(x="LSTAT", y="PRICE", data=boston_pd, ax=ax[1])
  

![](https://velog.velcdn.com/images/vitamin_penguin/post/6181c60c-4918-41ae-957b-573cc18f42c1/image.png)



```python
회귀 모델 사용


1. 모델 선택
#모델 선택
from sklearn.model_selection import train_test_split

X = boston_pd.drop('PRICE', axis=1)
y = boston_pd['PRICE']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=13)




2. 선형 회귀로 모델학습하기
#선형 회귀로 모델학습
from sklearn.linear_model import LinearRegression
#price 컬럼 값이 존재하지 않아 실습불가

reg = LinearRegression()
reg.fit(X_train, y_train)




3. 모델평가

from sklearn.metrics import mean_squared_error

pred_tr = reg.predict(X_train)
pred_test = reg.predict(X_test)

rmse_tr = np.sqrt(mean_squared_error(y_train, pred_tr))

rmse_test = np.sqrt(mean_squared_error(y_test, pred_test))


4. 출력
print("RMSE train: ", rmse_tr)
print("RMSE test: ", rmse_test)
#RMSE train:  4.821041974435382
#RMSE test:  4.256804937894875


5. 테스트 모델 출력
plt.scatter(y_test, pred_test)
plt.xlabel('Real ($1000)')
plt.ylabel('Predicted Prices')
plt.plot([0,50], [0,50])
plt.show()

Cost funtion, Loss function(손실함수) : 머신 러닝, 통계 모델에서 모델의 성능을 측정하고 모델을 최적화하는 데 사용 이 함수는 모델의 예측값과 실제 관측값 간의 차이를 측정하고, 이 차이를 최소화하는 방향으로 모델의 매개 변수(가중치 및 편향)를 조정하는 데 도움을 준다.

• 설명

1. 성능 측정

• Cost함수는 모델 성능을 측정한다. 예측을 수량화 지표를 만든다.
• 예측값과 실제값 사이의 차이를 나타낸다. 높은 차이는 낮은 모델 성능이다.

2. 모델 최적화

• Cost 함수는 모델의 매개 변수(가중치 및 편향)를 조정하여 모델을 최적화하는 데 사용
• 목표는 Cost함수의 값을 최소화하는 모델 파라미터를 찾는 것 이렇게 하면 모델의 예측이 실제 값과 가장 가까워진다.

1.
import numpy as np

#poly1d: 1차 다항식을 나타내는 객체를 생성     ex [2,1] --> [2x+1]

a = np.poly1d([1,1]) # x+1
b = np.poly1d([1, -1]) #x-1


#출력 a,b의 값
#(poly1d([1, 1]), poly1d([ 1, -1]))

#출력 a*b의 값    다항식(x+1) (x-1)  = x^2 -1  -->( 1,0 -1)
#poly1d([ 1,  0, -1])



2.
np.poly1d([2, -1]) **2 + np.poly1d([3, -5])**2 + np.poly1d([5, -6]) **2
# poly1d([ 38, -94,  62])

2. 심볼릭 미분(Symbolic Differentiation)

심볼릭 미분(Symbolic Differentiation): 수학적인 식이나 함수를 기호(Symbol)로 표현하고, 이를 사용하여 미분과 같은 수학적 연산 해결하는 과정 의미

#symbolic 연산
import sympy as sym
diff_th = sym.Symbol('theta')
diff_th = sym.diff(38*theta**2 -94*theta + 62, theta) #diff 미분

diff_th

#출력 76θ−94

3. Gradient Dscent(경사 하강법)

• 한번의 시도로 cost Fucntion 최소값을 구할수없을때...

• 함수의 최소값을 찾기 위해 사용되는 반복적인 최적화 알고리즘이다.
• 최소값은 함수의 기울기가 0인 지점*
• 모델의 손실 함수를 최소화하거나 비용 함수(Cost Function)을 최소화
• 학습률이 너무 크면 안된다. 학습률이 크다면 수렴하지 않고진동

지도학습(Supervised Learning):입력 데이터와 해당 데이터에 대한 정답 또는 레이블(label)이 주어진 상태에서 모델을 학습시키는 방법 ex)스팸메일

• 종류

1. 회귀(Reggression): 연속형 출력 변수 예측한다.
2. 군집화(Clustering): 지도 학습과 달리 데이터를 클러스터 또는 그룹화하는 비지도 학습 알고리즘
3. 차원 축소(Dimensionality Reduction): 차원 축소 알고리즘은 데이터의 특성 수를 줄이는 데 사용된다.
4. 서포트 벡터 머신(Support Vector Machines): 이진 및 다중 클래스 분류와 회귀 작업에 사용되는 강력한 알고리즘
5. 앙상블 학습(Ensemble Learning): 여러 기본 모델을 결합하여 더 강력한 예측 모델을 생성하는 기법

선형회귀

선형회귀(Linear Regression)는 지도 학습의 한 율형으로, 입력 변수와 연속적인 출력 변수 간의 관계를 모델링하는 데 사용되는 간단하고 기본적인 통계적 기술

최소 제곱법

최소 제곱법(Ordinary Least Squares, OLS): 선형 회귀 모델을 학습하고 최적화하는데 사용된다. OLS를 사용하여 데이터와 선형 모델 간 잔차(오차)를 최소화 하여 모델의 가중치와 절편을 추정할 수 있다.

1.데이터 프레임 생성
import pandas as pd
data = {'x': [1,2,3,4,5], 'y':[1,3,4,6,5]}
df = pd.DataFrame(data)


2.선형 회귀 모델 생성
import statsmodels.formula.api as smf
lm_model = smf.ols(formula = 'y ~ x', data=df).fit() #선형회귀 모델 수식 지정  (y는 출력, x는 입력변수)

3. 모델 확인
lm_model.params #y절편 0.5  x기울기 1.1
#Intercept    0.5
#x            1.1



4. 시각화
plt.figure(figsize=(12,10))
sns.lmplot(x='x', y='y', data=df)
plt.xlim([0,5])

잔차분포

잔차분포(Residdual Distribution): 선형 회귀 모델을 통해 예측된 값과 실제 관측된 값 사이의 차이인 잔차(Residuals)들의 확률 분포를 나타낸다. 잔차는 각 데이터 포인트에 대한 모델의 예측 오차를 나타낸다.

• 특징

1. 잔차의 정규성(Normality of Residuals): 선형 회귀 모델에서는 잔차가 정규 분포를 따르는 것이 중요하다. 잔차들이 평균이 0이고 고르게 분포되어 있어야 한다.
2. 잔차의 독립성(Independence of Residuals): 잔차들은 서로 독립적이어야 한다. 즉, 한데이터 포인트의 잔차가 다른 데이터 포인트의 잔차에 영향이 있으면 안된다.
3. 잔차의 등분산성(Homoscedasticity): 잔차들의 분산은 입력 변수와 관계없이 고정되어야 한다.

resid = lm_model.resid
resid

0   -0.6
1    0.3
2    0.2
3    1.1
4   -1.0

결정계수(R2)

결정 계수: 모델이 주어진 데이터에 얼마나 잘 적합하고 주어진 종속변수의 변동성을 얼마나 잘 설명하는지 나타내는 통계적 지표

1.만들어둔 lm_model(선형 회귀) 사용
import numpy as np
mu = np.mean(df['y']) #실제 종속변수 y의 평균을 계산하여 mu 변수에 저장
y = df['y']

y_hat = lm_model.predict() #위에서 만든 학습된 선형 회귀 모델 lm_model을 사용하여 입력변수x에 대한 예측값 y_hat 생성
np.sum((y_hat - mu)**2) / np.sum((y - mu)**2) #결정계수 계산

lm_model.rsquared #선형 회귀 모델 성능 평가를 간단하게 확인
# 출력값 0.8175675675675674

#lm_model.rsquared #선형 회귀 모델 성능 평가를 간단하게 확인


2. 시각화

sns.distplot(resid, color = 'black')

#1. 다항함수1
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-3, 2, 100) #-3부터 2까지의 범위에서 균일한 가격으로 100개의 숫자 생성
y = 3 * x**2 + 2

#출력
#array([-3.        , -2.94949495, -2.8989899 , -2.84848485, -2.7979798 #,
#       -2.74747475, -2.6969697 , -2.64646465, -2.5959596 , #-2.54545455,
#       -2.49494949, -2.44444444, -2.39393939, -2.34343434, #-2.29292929,
#       -2.24242424, -2.19191919, -2.14141414, -2.09090909, #-2.04040404,
#       -1.98989899, -1.93939394, -1.88888889, -1.83838384, -1.78787879,
       ....



2. 시각화
import matplotlib as mpl

mpl.style.use('seaborn-whitegrid')


plt.figure(figsize=(13,9))
plt.plot(x,y)
plt.grid()
#수학 기호 넣어보기
# plt.xlabel('$x$')
plt.xlabel('$x$', fontsize=25)
plt.ylabel('$3x^2 +2$', fontsize=25)
plt.show()

3. 다항함수2
x = np.linspace(-3, 2, 100)
y1 = 3 * x**2 + 2
y2 = 3 * (x+1) **2 + 2



4.시각화

import matplotlib as mpl




plt.figure(figsize=(13,9))
plt.plot(x,y1, lw=2, ls='dashed', label='$y=3x^2 + 2$')
plt.plot(x, y2, label = '$y=3(x+1)^2 + 2$')
plt.legend(fontsize=15)
plt.grid()



plt.xlabel('$x$', fontsize=25)
plt.ylabel('$y$', fontsize=25)
plt.show()

2. 지수함수

1. 지수함수1
a11, a12, a13 = 2,3,4
y11, y12, y13 = a11**x, a12**x, a13**x

a21, a22, a23 = 1/2, 1/3, 1/4
y21, y22, y23 =  a21**x, a22**x, a23**x


2.
fig, ax = plt.subplots(1, 2, figsize=(12,6))
ax[0].plot(x, y11, color = 'k', label='$2^x$')
ax[0].plot(x, y12, '--', color='k', label='$3^x$')
ax[0].plot(x, y13, ':', color = 'k', label = '$4^x$')
ax[0].legend(fontsize=20)




ax[1].plot(x, y21, color = 'k', label='$(1/2)^x$')
ax[1].plot(x, y22, '--', color='k', label='$(1/3)^x$')
ax[1].plot(x, y23, ':', color = 'k', label = '$(1/4)^x$')
ax[1].legend(fontsize=20)

3. 지수함수2

3. 지수 함수 극한 확인

1.
# 지수함수 극한 확인

x = np.array([10, 100, 1000, 10000, 100000, 1000000,10000000])

(1 + 1/x)**x

#출력 결과 어떤 큰 값을 넣어도2.718281828459045에 수렴한다.
# x값이 뭏한히 커질수록  자연상수(e)에 근접하게 된다.
#출력
array([2.59374246, 2.70481383, 2.71692393, 2.71814593, 2.71826824,
       2.71828047, 2.71828169])




2. 로그 그리기
np.log(np.exp(1))
# 출력 1.0



3. 자연상수(e)를 나타내는 값
np.e, np.exp(1)
#출력 (2.718281828459045, 2.718281828459045)


4. 그래프

fig, ax = plt.subplots(1, 2, figsize=(12, 6))

ax[0].plot(x1, y11, label='$\log_{10} x$', color='k')  # 로그 밑이 10인 로그함수 그래프를 그린다.
ax[0].plot(x2, y12, '--', label='$\log_{e} x$', color='k')  # 자연로그 그래프를 점선으로 그린다.

ax[0].set_xlabel('$x$', fontsize=25)
ax[0].set_ylabel('$y$', fontsize=25)
ax[0].legend(fontsize=20, loc='lower right')

ax[1].plot(x1, y21, label='$\log_{1/10} x$', color='k')  # 로그 밑이 1/10인 로그함수 그래프를 그린다.
ax[1].plot(x2, y22, '--', label='$\log_{1/e} x$', color='k')  # 자연로그 그래프를 점선으로 그린다.

ax[1].set_xlabel('$x$', fontsize=25)
ax[1].set_ylabel('$y$', fontsize=25)
ax[1].legend(fontsize=20, loc='upper right')

plt.show()

4. 시그모이드 그래프

시그모이드(Sigmoid) 그래프는 S 모양의 곡선 형태를 가지는 함수 그래프이다. 주로 로지스틱 함수(Logistic function)라고 불리며 실수 입력을 받아 0과 1사이의 출력 값 반환한다.

1. S 모양 곡선

• 시그모이드 함수의 그래프는 S 모양의 곡선으로, 입력 값이 음수로 크게 작아지거나 양수로 커질수록 출력 값이 0 또는 1에 가까워진다.

2. 0과 1 사이의 출력

• 시그모이드 함수는 항상 0과 1 사이의 값을 출력한다.. 이러한 특성 때문에 이를 이진 분류(binary classification) 문제에서 확률 값으로 사용하는 데 매우 적합하다.

3. 미분가능

• 시그모이드 함수는 연속하며 미분 가능한 함수로, 미분 값을 쉽게 계산할 수 있다. 이 특성은 경사 하강법과 같은 최적화 알고리즘에서 유용하게 사용된다.

4. 로지스틱 회귀

• 시그모이드 함수는 로지스틱 회귀 모델에서 활성화 함수로 사용되며 이진 분류 모델에서 확률 값을 예측하는 데 활용

#시그모이드는 0과 1사이를 넘어가지 않는다.  0~1사이의 값을 가진다.*********
z = np.linspace(-10, 10, 100)
sigma = 1/(1+np.exp(-z))

plt.figure(figsize=(12,8))
plt.plot(z, sigma)
plt.xlabel('$z$', fontsize=25)
plt.ylabel('$\sigma(z$)', fontsize=25)
plt.show()

5. 다변수 벡터

다변수 벡터(Multivariate Vector Function): 하나 이상의 입력 변수를 가지며 입력 변수들을 처리하여 하나 이상의 출력 벡터를 생성하는 함수를 나타낸다.

• 용도

1. 머신러닝 및 데이터 분석 작업에서 사용된다.
2. ex) 다차원 입력 데이터를 받고 다차원 출력 데이터를 생성하는 신경망은 벡터함수의 예시이다.
3. 복잡한 입력과 출력 관계를 모델링하고, 예측, 분류, 회귀 등 작업 수행

1. 2차원 그리드 생성
import numpy as np
#입력받은 u와v로(1차원 배열) 2차원 그리드를 생성한다.

u = np.linspace(0, 1, 30)
v = np.linspace(0, 1, 30)
#한꺼번에 계산 meshgrid
U, V = np.meshgrid(u,v)



2. 시각화 (X는 이전 지수 함수 실습에서 만든변수)

fig = plt.figure(figsize=(7, 7))
ax = plt.axes(projection='3d')  # 3차원으로 그릴 때 필요한 projection

ax.xaxis.set_tick_params(labelsize=15)
ax.yaxis.set_tick_params(labelsize=15)  # 수정된 부분
ax.zaxis.set_tick_params(labelsize=15)

ax.set_xlabel('$x$', fontsize=20)
ax.set_ylabel('$y$', fontsize=20)
ax.set_zlabel('$z$', fontsize=20)

ax.scatter3D(U, V, Z, marker ='.', color = 'gray')
plt.show()

6. 데이터 백분위수

1.
samples = [1, 7, 9, 16, 36, 39, 45, 45, 46, 48, 51, 100, 101]
samples

#출력 [1, 7, 9, 16, 36, 39, 45, 45, 46, 48, 51, 100, 101]


2.
tmp_y = [1]*len(samples)  #[1] 단일숫자  --> 출력하면1,1,1,1,1,1,...
tmp_y
# 출력 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]


3. 중간값 구하기
import numpy as np
np.median(samples) #중간값 출력



4. 75% 백분위수
np.percentile(samples, 75)  


5.
q1 = np.percentile(samples, 25)   #백분위수 25찌점 계산
q2 = np.median(samples) #백분위수 중앙값 계산
q3 = np.percentile(samples, 75) #백분위수75% 계산

iqr = q3 - q1 # 사분위 범위 계산 (q3-q1 즉 중간값 50% 범위를 구한다.)

#이상치 검출위한 상단과 하단 경계 계산
upper_fence = q3 + iqr*1.5
lower_fence = q1 - iqr*1.5




6.백분위수 시각화


plt.figure(figsize=(12,4))
plt.scatter(samples, tmp_y)
plt.axvline(x=q1, color='black')
plt.axvline(x=q2, color='red')
plt.axvline(x=q3, color='green')

plt.axvline(x=upper_fence, color='black', ls='dashed')  # 'dashed'로 수정
plt.axvline(x=lower_fence, color='red', ls='dashed')   # 'dashed'로 수정
plt.show()

# 그래프에 제일 우측에 있는점을 아웃라이어이라고 한다.
# 검정색 선 부터 초록색선까지가 iqr이다.
#빨강점선과 검정 점선은   iqr의 막대의 1.5배 구간이다.