1.이론

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

• 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'])