Python 기초 및 AI 라이브러리 정리

Berkley·2025년 9월 1일
AIpython인공지능
0

1. Python 기초 문법

1.1 변수와 데이터 타입

# 기본 데이터 타입
age = 25                    # int
height = 175.5             # float
name = "김철수"             # str
is_student = True          # bool

# 컬렉션 타입
numbers = [1, 2, 3, 4, 5]           # list
coordinates = (10, 20)              # tuple
person = {"name": "김철수", "age": 25}  # dict
unique_numbers = {1, 2, 3, 4, 5}    # set

1.2 조건문과 반복문

# 조건문
if age >= 18:
    print("성인입니다")
elif age >= 13:
    print("청소년입니다")
else:
    print("어린이입니다")

# 반복문
for i in range(5):
    print(f"반복 {i}")

while condition:
    # 조건이 True인 동안 실행
    pass

1.3 함수 정의

def calculate_average(numbers):
    """숫자 리스트의 평균을 계산하는 함수"""
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)

# 람다 함수
square = lambda x: x ** 2

1.4 클래스와 객체

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def study(self, subject):
        return f"{self.name}이(가) {subject}를 공부합니다"

# 객체 생성
student = Student("김철수", 20)
print(student.study("Python"))

1.5 예외 처리

try:
    result = 10 / 0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다")
except Exception as e:
    print(f"오류 발생: {e}")
finally:
    print("항상 실행되는 블록")

2. 핵심 AI 라이브러리

2.1 NumPy - 수치 계산의 기초

용도: 다차원 배열 연산, 선형대수, 수치 계산

import numpy as np

# 배열 생성
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2], [3, 4]])

# 기본 연산
print(arr + 10)           # 브로드캐스팅
print(np.mean(arr))       # 평균
print(np.std(arr))        # 표준편차
print(matrix.T)           # 전치행렬

# 유용한 함수들
zeros = np.zeros((3, 3))      # 0으로 채운 배열
ones = np.ones((2, 4))        # 1로 채운 배열
random_data = np.random.rand(5)  # 랜덤 배열

2.2 Pandas - 데이터 조작과 분석

용도: 데이터 프레임, 데이터 전처리, CSV/Excel 파일 처리

import pandas as pd

# 데이터프레임 생성
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['Seoul', 'Busan', 'Daegu']
})

# 데이터 조작
print(df.head())              # 상위 5개 행
print(df.info())              # 데이터 정보
print(df.describe())          # 통계 요약

# 데이터 필터링
adults = df[df['age'] >= 30]
seoul_people = df[df['city'] == 'Seoul']

# 파일 입출력
df.to_csv('data.csv', index=False)
new_df = pd.read_csv('data.csv')

2.3 Matplotlib & Seaborn - 데이터 시각화

용도: 그래프 생성, 데이터 시각화

import matplotlib.pyplot as plt
import seaborn as sns

# 기본 플롯
plt.figure(figsize=(10, 6))
plt.plot([1, 2, 3, 4], [10, 20, 25, 30])
plt.xlabel('X축')
plt.ylabel('Y축')
plt.title('기본 선 그래프')
plt.show()

# 히스토그램
plt.hist(data, bins=20, alpha=0.7)
plt.title('히스토그램')
plt.show()

# Seaborn 스타일
sns.set_style("whitegrid")
sns.scatterplot(x='age', y='income', data=df)
sns.heatmap(correlation_matrix, annot=True)

2.4 Scikit-learn - 전통적 머신러닝

용도: 분류, 회귀, 클러스터링, 전처리

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.preprocessing import StandardScaler

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 데이터 정규화
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 모델 학습
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train_scaled, y_train)

# 예측 및 평가
y_pred = model.predict(X_test_scaled)
print(f"정확도: {accuracy_score(y_test, y_pred):.3f}")
print(classification_report(y_test, y_pred))

2.5 TensorFlow & Keras - 딥러닝

용도: 신경망 구축, 딥러닝 모델 학습

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# 시퀀셜 모델 생성
model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# 모델 컴파일
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# 모델 학습
history = model.fit(
    X_train, y_train,
    epochs=10,
    batch_size=32,
    validation_data=(X_val, y_val)
)

# 모델 저장/로드
model.save('my_model.h5')
loaded_model = keras.models.load_model('my_model.h5')

CNN 예제 (이미지 분류)

model = keras.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

2.6 PyTorch - 연구 친화적 딥러닝

용도: 동적 계산 그래프, 연구용 딥러닝

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

# 신경망 정의
class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

# 모델 생성 및 학습
model = SimpleNN(784, 128, 10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(num_epochs):
    for batch in dataloader:
        optimizer.zero_grad()
        outputs = model(batch['input'])
        loss = criterion(outputs, batch['target'])
        loss.backward()
        optimizer.step()

2.7 OpenCV - 컴퓨터 비전

용도: 이미지/비디오 처리, 객체 인식

import cv2
import numpy as np

# 이미지 읽기/저장
image = cv2.imread('image.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imwrite('gray_image.jpg', gray)

# 이미지 처리
blurred = cv2.GaussianBlur(image, (15, 15), 0)
edges = cv2.Canny(gray, 50, 150)

# 객체 검출 (얼굴 인식 예제)
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

for (x, y, w, h) in faces:
    cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2)

# 웹캠 사용
cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read()
    cv2.imshow('Video', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

3. 실무에서 자주 사용하는 패턴

3.1 데이터 전처리 파이프라인

def preprocess_data(data):
    """데이터 전처리 파이프라인"""
    # 1. 결측치 처리
    data = data.dropna()
    
    # 2. 이상치 제거
    Q1 = data.quantile(0.25)
    Q3 = data.quantile(0.75)
    IQR = Q3 - Q1
    data = data[~((data < (Q1 - 1.5 * IQR)) | (data > (Q3 + 1.5 * IQR))).any(axis=1)]
    
    # 3. 정규화
    scaler = StandardScaler()
    data_scaled = scaler.fit_transform(data)
    
    return data_scaled, scaler

3.2 모델 평가 및 검증

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.metrics import confusion_matrix, roc_auc_score

def evaluate_model(model, X, y):
    """모델 평가 함수"""
    # 교차 검증
    cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
    print(f"CV 평균 정확도: {cv_scores.mean():.3f} (+/- {cv_scores.std() * 2:.3f})")
    
    # 혼동 행렬
    y_pred = model.predict(X)
    cm = confusion_matrix(y, y_pred)
    print("혼동 행렬:")
    print(cm)
    
    return cv_scores.mean()

3.3 하이퍼파라미터 튜닝

def tune_hyperparameters(model, X, y, param_grid):
    """하이퍼파라미터 튜닝"""
    grid_search = GridSearchCV(
        model, param_grid, 
        cv=5, scoring='accuracy', 
        n_jobs=-1, verbose=1
    )
    grid_search.fit(X, y)
    
    print(f"최적 파라미터: {grid_search.best_params_}")
    print(f"최적 점수: {grid_search.best_score_:.3f}")
    
    return grid_search.best_estimator_

# 사용 예시
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 7, None],
    'min_samples_split': [2, 5, 10]
}
best_model = tune_hyperparameters(RandomForestClassifier(), X, y, param_grid)

4. TensorFlow Lite - 모바일/엣지 배포

4.1 모델 변환

import tensorflow as tf

# Keras 모델을 TensorFlow Lite로 변환
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

# 양자화 적용 (모델 크기 축소)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
quantized_model = converter.convert()

# 모델 저장
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

4.2 TensorFlow Lite 모델 추론

import numpy as np
import tensorflow as tf

# TensorFlow Lite 인터프리터 로드
interpreter = tf.lite.Interpreter(model_path='model.tflite')
interpreter.allocate_tensors()

# 입출력 정보 확인
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# 추론 실행
input_data = np.array(input_image, dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()

# 결과 추출
output_data = interpreter.get_tensor(output_details[0]['index'])
prediction = np.argmax(output_data)

5. 프로젝트 구조와 모범 사례

5.1 프로젝트 디렉토리 구조

ai_project/
├── data/
│   ├── raw/
│   ├── processed/
│   └── external/
├── models/
│   ├── trained/
│   └── checkpoints/
├── notebooks/
│   ├── exploratory/
│   └── experiments/
├── src/
│   ├── data/
│   │   ├── __init__.py
│   │   └── data_preprocessing.py
│   ├── models/
│   │   ├── __init__.py
│   │   ├── train_model.py
│   │   └── predict_model.py
│   └── utils/
│       ├── __init__.py
│       └── helpers.py
├── requirements.txt
├── setup.py
└── README.md

5.2 코드 스타일 가이드라인

# 좋은 예시
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

def train_classification_model(X, y, test_size=0.2, random_state=42):
    """
    분류 모델을 학습하는 함수
    
    Args:
        X: 특성 데이터
        y: 타겟 데이터
        test_size: 테스트 데이터 비율
        random_state: 랜덤 시드
    
    Returns:
        tuple: (model, accuracy)
    """
    # 데이터 분할
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=test_size, random_state=random_state
    )
    
    # 모델 학습
    model = RandomForestClassifier(random_state=random_state)
    model.fit(X_train, y_train)
    
    # 평가
    accuracy = model.score(X_test, y_test)
    
    return model, accuracy

5.3 환경 관리 (requirements.txt)

# 실제 프로젝트에서 사용되는 라이브러리들
numpy==1.24.3
pandas==2.0.2
matplotlib==3.7.1
seaborn==0.12.2
scikit-learn==1.2.2
tensorflow==2.12.0
keras==2.12.0
torch==2.0.1
torchvision==0.15.2
opencv-python==4.7.1
pillow==9.5.0
tqdm==4.65.0
jupyter==1.0.0

6. 디버깅과 최적화 팁

6.1 일반적인 디버깅 패턴

# 디버깅용 출력
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def debug_data_shape(data, name="data"):
    """데이터 형태 확인용 함수"""
    logger.info(f"{name} shape: {data.shape}")
    logger.info(f"{name} dtype: {data.dtype}")
    logger.info(f"{name} min/max: {data.min():.3f}/{data.max():.3f}")

# 메모리 사용량 확인
import psutil
import os

def get_memory_usage():
    """현재 메모리 사용량 확인"""
    process = psutil.Process(os.getpid())
    return process.memory_info().rss / 1024 / 1024  # MB

6.2 성능 측정

import time
from functools import wraps

def timing_decorator(func):
    """함수 실행 시간 측정 데코레이터"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 실행 시간: {end_time - start_time:.3f}초")
        return result
    return wrapper

@timing_decorator
def slow_function():
    # 시간이 오래 걸리는 작업
    time.sleep(2)
    return "완료"

7. 실무 체크리스트

데이터 분석 프로젝트 시작 전

  • 문제 정의가 명확한가?
  • 데이터를 충분히 탐색했는가?
  • 적절한 평가 지표를 선택했는가?
  • 베이스라인 모델을 구현했는가?

모델 개발 중

  • 과적합을 모니터링하고 있는가?
  • 검증 데이터를 적절히 분리했는가?
  • 하이퍼파라미터 튜닝을 체계적으로 하고 있는가?
  • 코드를 모듈화하고 문서화했는가?

프로젝트 완료 후

  • 결과를 재현할 수 있는가?
  • 모델의 한계를 파악했는가?
  • 실서비스 배포를 고려했는가?
  • 지속적인 모니터링 방안이 있는가?

8. 추가 학습 자료

공식 문서

추천 학습 경로

  1. Python 기초 → NumPy/Pandas → Matplotlib
  2. Scikit-learn으로 전통적 ML → 통계와 수학 기초
  3. TensorFlow/Keras로 딥러닝 입문 → PyTorch로 고급 기법
  4. 컴퓨터 비전(OpenCV) 또는 자연어 처리 전문화

실습 아이디어

  • 집값 예측 (회귀)
  • 이미지 분류 (CNN)
  • 감정 분석 (NLP)
  • 추천 시스템 (협업 필터링)
  • 시계열 예측 (LSTM)
profile
Berkley
성장하는 개발자 Berkley 입니다.
이전 포스트

AI 개념 정리

0개의 댓글