[딥러닝] 3주차 - 파이썬, 딥러닝 라이브러리, 넘파이 Numpy, 행렬 연산

파이썬 Python

• 간결한 문법 - 직관적인 코드, 높은 가독성
• 플랫폼 독립성 - 다양한 운영체제에서 동일하게 실행
• 풍부한 라이브러리
• 인터프리터 언어 - 코드 컴파일 없이 실행 가능
• 동적 타이핑 - 변수 타입을 명시하지 않아도 됨
• 확장성 - C, C++ 등 언어와 결합 가능

---

AI에서 파이썬을 많이 사용하는 이유

• 방대한 AI/ML 라이브러리 - TensorFlow, PyTorch, Keras, Scikit-learn 등
• 데이터 분석 도구 - Numpy, Pandas, Matplolib 등
• 커뮤니티 지원
• 학습 용이성 - 문법이 간결하여 빠르게 알고리즘을 구현하고 실험 가능
• 플랫폼 독립성 - 다양한 환경에서 동일한 코드로 실행 가능
• 오픈 소스

---

딥러닝을 위한 라이브러리

텐서플로 TensorFlow

• 구글이 개발한 딥러닝 라이브러리
• 다양한 플랫폼에서 실행 가능
• 대규모 모델 훈련을 지원
• 병렬 처리를 위한 강력한 GPU/TPU를 지원하여 빠른 모델 훈련이 가능
• 텐서보드: 모델의 학습 과정, 손실 함수, 가중치 변화 등을 실시간으로 시각화 할 수 있는 도구
• 모바일 디바이스, 클라우드 서버 등 다양한 환경에서 실행 가능
• Python, Java, C++, JavaScript 등 지원

파이토치 Pytorch

• 페이스북이 주도적으로 개발하는 딥러닝 라이브러리
• 직관적이고 유연한 API로 빠르게 모델을 프로토타이핑하고 연구에 적용 가능
• 다중 GPU를 지원하여 간단한 코드 수정만으로 병렬 훈련이 가능
• TorchScript: 학습 모델을 추출하여 프로덕션 환경에서 사용할 수 있게 하며, 효율적 배포 지원
• Pythonic 문법으로 배우기 쉽고 직관적인

그  외에도 Keras, Theano, Caffe, ONNX 등 존재

---

넘파이 Numpy

• 강력한 다차원 배열 처리
  • 이미지, 음성, 텍스트 등 다양한 데이터가 주로 다차원 배열로 표현됨
  • 넘파이는 배열을 효율적으로 처리하는 기능을 제공
  • ndarray는 고정된 타입의 다차원 배열을 효율적으로 관리
  • 메모리 상에서 연속적으로 저장되며, 다양한 축으로 데이터에 접근할 수 있음
  • 데이터의 변형, 슬라이싱, 인덱싱, 복잡한 데이터 변환 등을 효율적으로 처리
• 빠른 수학적 연산 속도
  • 딥러닝 모델은 수많은 행렬 연산을 수행
  • 넘파이는 빠르고 효율적인 행렬 연산 기능을 제공하여 선형 대수 계산이 쉽게 수행 가능
  • 내부적으로 C 언어로 구현되어 파이썬의 기본 리스트 구조보다 훨씬 빠름
  • 최적화된 저수준의 코드로 처리 + CPU의 벡터화 명령어 사용으로 병렬 연산 지원
  • 벡터 연산을 통해 대규모 데이터 처리 속도가 크게 향상
• 데이터 전처리
  • 딥러닝에 사용되는 데이터는 모델에 입력되기 전에 전처리 작업이 필요
  • 데이터의 크기를 변경하거나, 정규화를 하거나, 특정 부분을 편집하는 작업에 유용
• 딥러닝 프레임워크의 기반
  • 텐서플로, 파이토치와 같은 딥러닝 프레임워크들은 넘파이와 유사한 자료구조를 사용
• 브로드캐스팅
  • 크기가 다른 배열 간에도 연산을 가능하게 하는 기능
  • 자동으로 작은 배열이 큰 배열의 크기에 맞춰진 후 연산이 수행
• 라이브러리 호환성
  • pandas, matplotlib, scikit-learn, tensorflow 등 주요 라이브러리가 넘파이 기반으로 배열 연산을 수행
  • 메모리 복사 없이 다른 라이브러리들과 데이터를 공유할 수 있어, 데이터 처리 및 분석 과정에서 효율적

---

기본

pip install numpy

import numpy as np

a = np.array([2,3,4])
print(a, f"{a.ndim}차원 배열 {a.shape}")
print("---------------------------")

b = np.array([[2, 3, 4], [6, 7, 8]])
print(b, f"{b.ndim}차원 배열 {b.shape}")
print("---------------------------")

c = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(c, f"{c.ndim}차원 배열 {c.shape}")

[2 3 4] 1차원 배열 (3,)
---------------------------
[[2 3 4]
 [6 7 8]] 2차원 배열 (2, 3)
---------------------------
[[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]] 3차원 배열 (2, 2, 3)

 

구분	내용	예
a.shape	배열의 형상(차원별 크기)를 튜플로 표현	(3, )
a.ndim	배열의 차원 수	2
a.dtype	배열 요소의 데이터 타입	dtype('int64') 또는 dtype('int32')
a.itemsize	배열 각 요소의 바이트 크기	8 (정수형)
a.size	배열의 전체 요소 수	3

---

 

import numpy as np

# -------------------------------
# 1. 파이썬 리스트를 이용한 배열 연산
# -------------------------------

score_list = [70, 82, 45, 78]
# [70, 82, 45, 78]

# 리스트의 덧셈 연산 → 리스트 연결 (원소별 합이 아님)
mid_score = [70, 82, 45, 78]
fin_score = [90, 48, 71, 100]
sum_score = mid_score + fin_score  
# [70, 82, 45, 78, 90, 48, 71, 100]

# 파이썬 리스트는 요소별 연산이 아니라 리스트를 연결함  
# 리스트는 나누기 연산을 지원하지 않음


# -------------------------------
# 2. Numpy를 이용한 배열 연산 (벡터화 연산)
# -------------------------------

mid_score = np.array([70, 82, 45, 78])
fin_score = np.array([90, 48, 71, 100])

# 벡터화 연산 (배열의 원소끼리 더하기)
sum_score = mid_score + fin_score  
# [160 130 116 178]

# 벡터화 연산 (배열 요소별 나누기)
print("\n평균 점수 (NumPy): ", sum_score / 2)  
# [80. 65. 58. 89.]

# NumPy 배열은 벡터 연산을 수행하여 원소별 연산이 가능함

# -------------------------------
# 3. 브로드캐스팅 연산
# -------------------------------

# 1차원 배열 (벡터)와 스칼라 연산
a = np.array([1, 2, 3])
b = 10
print(a + b)  
# [11 12 13]

# 2차원 배열과 1차원 배열의 브로드캐스팅
A = np.array([[1, 2, 3], [4, 5, 6]])
B = np.array([10, 20, 30])  # (3,) 형태의 1차원 배열
print(A + B)  
# [[11 22 33]
#  [14 25 36]]

# NumPy는 브로드캐스팅을 통해 배열 크기가 다를 때 자동 확장하여 연산 수행 가능

# -------------------------------
# 4. 다차원 배열 생성
# -------------------------------

# np.arange() - 연속된 숫자로 배열 생성
arr1 = np.arange(1, 10, 2)
# [1 3 5 7 9]

# np.zeros() - 모든 요소가 0인 배열 생성
arr2 = np.zeros((2, 3))
# [[0. 0. 0.]
#  [0. 0. 0.]]

# np.ones() - 모든 요소가 1인 배열 생성
arr3 = np.ones((3, 2))
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]

# np.full() - 모든 요소가 특정 값인 배열 생성
arr4 = np.full((2, 2), 7)
# [[7 7]
#  [7 7]]

# np.eye() - 단위 행렬 (Identity Matrix) 생성
arr5 = np.eye(3)
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

# -------------------------------
# 5. 다차원 배열 연산 (append)
# -------------------------------

arr6 = np.array([[1, 2, 3], [4, 5, 6]])
arr7 = np.append(arr6, [[7, 8, 9]], axis=0)  # 행 추가
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

arr8 = np.append(arr6, [[7], [8]], axis=1)  # 열 추가
# [[1 2 3 7]
#  [4 5 6 8]]

# -------------------------------
# 6. 인덱싱, 슬라이싱
# -------------------------------

arr9 = np.array([[10, 20, 30], [40, 50, 60]])

# 단일 요소 인덱싱
print(arr9[1, 2])  
# 60

# 슬라이싱 (첫 번째 행 가져오기)
print(arr9[0, :])  
# [10 20 30]

# 슬라이싱 (두 번째 열 가져오기)
print(arr9[:, 1])  
# [20 50]

# -------------------------------
# 7. 불리언 인덱싱
# -------------------------------

arr10 = np.array([1, 2, 3, 4, 5, 6])
bool_idx = arr10 > 3  # 3보다 큰 값만 선택
print(arr10[bool_idx])  
# [4 5 6]

# -------------------------------
# 8. 논리 인덱싱 (조건을 조합해서 사용)
# -------------------------------

arr11 = np.array([10, 15, 20, 25, 30])
print(arr11[(arr11 >= 20) & (arr11 <= 30)])  
# [20 25 30]

# -------------------------------
# 9. 난수 생성
# -------------------------------

# 균등 분포 난수 생성 (0~1)
rand1 = np.random.rand(3, 3)

# 정규 분포 난수 생성 (평균 0, 표준편차 1)
rand2 = np.random.randn(3, 3)

# 정수 난수 생성 (1~100 사이)
rand3 = np.random.randint(1, 100, (2, 3))

# -------------------------------
# 10. reshape (배열 형태 변경)
# -------------------------------

arr12 = np.arange(1, 10)  # 1D 배열
arr13 = arr12.reshape(3, 3)  # 2D 배열로 변환
print(arr13)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]