ai-engineering-from-scratch: 0부터 AI 엔지니어링을 배우는 32K 스타 커리큘럼 (32K Stars)

# 파이썬 3.11+ 필요
python3 --버전

# 가상 환경 생성
python3 - m venv venv
소스 정맥/빈/activate

# 레포지토리 클론
git 클론 https://github.com/rohitg00/ai-engineering-from-scratch.git
scratch의 AI 엔지니어링 CD
pip 설치 -r 요구 사항.txt

# 클로드 코드
# 커리큘럼 스킬을 에이전트에 로드

# 커서
git 클론 https://github.com/rohitg00/ai-engineering-from-scratch.git

도커 빌드 - 타이 엔지니어링 .
도커 런 - 인공지능 공학

# 모델/predictor.py 
joblib 가져오기 
numpy를 np로 가져오기 
fastapi import FastAPI, HTTPException에서 
pydantic import BaseModel에서 

app = FastAPI(title="AI 예측 서비스") 

#모델로드 
모델 = joblib.load("models/trained_model.pkl") 
tokenizer = joblib.load("models/tokenizer.pkl") 

클래스 PredictionRequest(BaseModel): 
텍스트: str 
온도: 플로트 = 0.7 
top_k: 정수 = 50 

클래스 PredictionResponse(BaseModel): 
예측: str 
자신감: 플로트 
토큰: 목록[str] 

@app.post("/predict", response_model=PredictionResponse) 
def 예측(요청: PredictionRequest): 
"""단일선택 예측 포인트""" 
시도해 보세요: 
인코딩 = tokenizer.encode_plus( 
요청.텍스트, 
return_tensors="np", 
패딩="최대_길이", 
최대 길이=512, 
잘림=참 
) 

input_ids = np.array(encoded["input_ids"]) 
attention_mask = np.array(encoded["attention_mask"]) 

예측 = model.predict(input_ids, attention_mask) 
신뢰도 = float(np.max(예측)) 
예측_클래스 = int(np.argmax(예측)) 

예측응답( 
예측=str(예측_클래스), 
자신감=자신감, 
토큰=[request.text[:20]] 
) 
e와 같은 예외를 제외하고: 
HTTPException 발생(status_code=500, 세부정보=str(e)) 

@app.get("/건강") 
def health_check(): 
"""서비스 상태 확인 종료포인트""" 
반환 {"status": "healthy", "model_version": "1.0.0"}

# 도커파일
출처: 파이썬:3.12-슬림

WorkDIR / 앱

# 의존성 설치
복사 요구 사항 .txt.
RUN pip 설치 --no-cache-dir -r 요구 사항.txt

# 애플리케이션 복사
복사 . .

# 모델 파일 복사
복사 모델/ ./모델/

노출 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

도커 빌드 - t ai-service: v1 .
도커 실행 -p 8000:8000 -v $(pwd)/models:/앱/models AI 서비스:v1

# k8s/deployment.yaml 
api버전: 앱/v1 
종류: 배포 
메타데이터: 
이름: ai-prediction-service 
라벨: 
앱: AI 예측 
사양: 
복제본: 3 
선택기: 
일치 라벨: 
앱: AI 예측 
템플릿: 
메타데이터: 
라벨: 
앱: AI 예측 
사양: 
컨테이너: 
- 이름 : ai-service 
이미지: ai-service:v1 
포트: 
- 컨테이너 포트: 8000 
자원: 
요청: 
메모리: "512Mi" 
CPU: "250m" 
한도: 
메모리: "1Gi" 
CPU: "500m" 
활성 프로브: 
httpGet: 
경로: /건강 
포트: 8000 
초기 지연초: 30 
기간초: 10 
준비 상태프로브: 
httpGet: 
경로: /건강 
포트: 8000 
초기 지연초: 5 
기간초: 5 
--- 
api버전: v1 
종류: 서비스 
메타데이터: 
이름: ai-prediction-service 
사양: 
선택기: 
앱: AI 예측 
포트: 
- 프로토콜: TCP 
포트: 80 
타겟 포트: 8000 
유형: LoadBalancer

# .github/workflows/mlops.yml 
이름: MLOps 파이프라인 

에: 
푸시: 
가지: [메인] 
풀 요청: 
가지: [메인] 

직업: 
테스트: 
실행: 우분투 최신 
단계: 
- 용도: actions/checkout@v4 

- 이름: Python 설정 
용도: actions/setup-python@v5 
와: 
파이썬 버전: '3.12' 

- 이름: 설치 종속성 
실행: pip install -r 요구 사항.txt 

- 이름: 테스트 실행 
실행: pytest 테스트/ -v --cov=models --cov-report=xml 

- 이름 : 업로드 취재 
용도: codecov/codecov-action@v4 

기차: 
요구사항: 테스트 
실행: 우분투 최신 
단계: 
- 용도: actions/checkout@v4 

- 이름: 열차 모델 
실행: python scripts/train.py 

- 이름: 모델 아티팩트 저장 
용도: actions/upload-artifact@v4 
와: 
이름: 훈련된 모델 
경로: 모델/ 

배포: 
필요: 기차 
실행: 우분투 최신 
if: github.ref == '참조/헤드/메인' 
단계: 
- 용도: actions/checkout@v4 

- 이름 : 다운로드 모델 
용도: actions/download-artifact@v4 
와: 
이름: 훈련된 모델 
경로: 모델/ 

- 이름: Docker 이미지 빌드 및 푸시 
실행: | 
docker build -t ghcr.io/${{ github.repository }}/ai-service:${{ github.sha }} . 
echo "${{ 비밀.GITHUB_TOKEN }}" | 도커 로그인 ghcr.io -u ${{ github.actor }} --password-stdin 
docker push ghcr.io/${{ github.repository }}/ai-service:${{ github.sha }} 

- 이름: Kubernetes에 배포 
실행: | 
kubectl 이미지 배포/ai-prediction-service 설정 \ 
ai-service=ghcr.io/${{ github.repository }}/ai-service:${{ github.sha }}

수입 토치 
torch.nn을 nn으로 가져오기 
수학 가져오기 

클래스 MultiHeadAttention(nn.Module): 
"""다중 헤드 어텐션 구현""" 

def __init__(self, d_model=512, n_heads=8): 
슈퍼().__init__() 
self.d_model = d_model 
self.n_heads = n_heads 
self.d_k = d_model // n_heads 

self.W_q = nn.Linear(d_model, d_model) 
self.W_k = nn.Linear(d_model, d_model) 
self.W_v = nn.Linear(d_model, d_model) 
self.W_o = nn.Linear(d_model, d_model) 

def scaled_dot_product_attention(self, Q, K, V, 마스크=없음): 
"""스케일된 닷프로덕트 어텐션""" 
점수 = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) 

마스크가 None이 아닌 경우: 
점수 = 점수.masked_fill(마스크 == 0, -1e9) 

주의 = torch.softmax(점수, 희미함=-1) 
torch.matmul(attention, V), 주의 반환 

def 앞으로(self, Q, K, V, 마스크=없음): 
배치_크기 = Q.크기(0) 

# 미래의 멀티헤드로 파티 
Q = self.W_q(Q).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2) 
K = self.W_k(K).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2) 
V = self.W_v(V).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2) 

#어텐션작업 
attn_output, attention_weights = self.scaled_dot_product_attention(Q, K, V, 마스크) 

# 머리를 다시 뽑다 
attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model) 

self.W_o(attn_output), attention_weights를 반환합니다.

클래스 위치 인코딩(n.Module):
    """사인/코사인 위치 인코딩"""
    
    def __init__(자기, d_model, max_len=5000, dropout=0.1):
        슈퍼 ()._init_()
        자기 dropout = nn.드롭아웃(드롭아웃)
        
        pe = torch.zeros(max_len, d_model)
        위치 = torch.arange(0, max_len, dtype=torch), float 해제(1)
        div_term = torch.exp(torch.range(0, d_model, 2). float() * (-math.log(10000.0) / d_model)
        
        pe[:, 0:2] = torch.sin(위치 * div_term)
        pe[:, 1:2] = torch.cos(위치 * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)
    
    앞으로(자기, x):
        x = x + self.pe [:, :x.size(1), :]
        자아를 되찾다. dropout(x)

# 벤치마킹/model_benchmark.py 
수입 시간 
numpy를 np로 가져오기 
sklearn.metrics에서 Classification_report, Confusion_matrix 가져오기 
수입 토치 

클래스 ModelBenchmark: 
"""모델 성능 벤치마킹 클래스""" 

def __init__(self, 모델, 토크나이저, 장치="cuda"): 
self.model = 모델 
self.tokenizer = 토크나이저 
self.device = 장치 

def benchmark_accuracy(self, test_dataset): 
"""정확도 벤치마크""" 
self.model.eval() 
정확함 = 0 
총계 = 0 
예측 = [] 
true_labels = [] 

torch.no_grad()를 사용하여: 
텍스트의 경우 test_dataset의 라벨: 
입력 = self.tokenizer( 
텍스트, return_tensors="pt", 
패딩=True, 잘림=True, max_length=512 
).to(self.device) 

출력 = self.model(**입력) 
preds = torch.argmax(outputs.logits, 희미한 = 1) 

올바른 += (preds == labels.to(self.device)).sum().item() 
전체 += labels.size(0) 
예측.확장(preds.cpu().numpy()) 
true_labels.extend(labels.numpy()) 

정확도 = 정확함 / 전체 
보고서 = 분류_보고서(true_labels, 예측, 출력_dict=True) 

반환 { 
"정확도": 정확도, 
"분류_보고": 보고, 
"confusion_matrix": 혼동_매트릭스(true_labels, 예측).tolist() 
} 

def benchmark_latency(self, test_dataset, num_runs=100): 
"""레이턴시 벤치마킹""" 
self.model.eval() 
대기 시간 = [] 

torch.no_grad()를 사용하여: 
텍스트의 경우 _ test_dataset에 있음: 
입력 = self.tokenizer( 
텍스트, return_tensors="pt", 
패딩=True, 잘림=True, max_length=512 
).to(self.device) 

# 워밍업 
_ = self.model(**입력) 

# 타이밍 
시작 = time.perf_counter() 
_ 범위 내(num_runs): 
_ = self.model(**입력) 
끝 = time.perf_counter() 

avg_latency = (끝 - 시작) / num_runs 
대기 시간.추가(avg_latency) 

반환 { 
"avg_latency_ms": np.mean(대기 시간) * 1000, 
"p50_latency_ms": np.percentile(대기 시간, 50) * 1000, 
"p99_latency_ms": np.percentile(대기 시간, 99) * 1000, 
"throughput_rps": 1.0 / np.mean(대기 시간) 
} 

def full_report(self, test_dataset): 
"""종합 벤치마크 기자""" 
Accuracy_report = self.benchmark_accuracy(test_dataset) 
Latency_report = self.benchmark_latency(test_dataset) 

반환 { 
"정확도": 정확도_보고, 
"대기 시간": 대기 시간_보고, 
"요약": { 
"accuracy_pct": f"{accuracy_report['accuracy']*100:.2f}%", 
"avg_latency": f"{latency_report['avg_latency_ms']:.2f}ms", 
"처리량": f"{latency_report['throughput_rps']:.1f} 요청/초" 
} 
}

# 미세 조정/lora_finetune.py 
peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training에서 
변환기에서 AutoModelForCausalLM, BitsAndBytesConfig 가져오기 
수입 토치 

def setup_lora_finetuning(model_name="meta-llama/Llama-3-8B"): 
"""LoRA 파인튜닝 설정""" 

# 4 비트 복잡하게 설정 
퀀트_config = BitsAndBytesConfig( 
load_in_4bit=참, 
bnb_4bit_Quant_type="nf4", 
bnb_4bit_compute_dtype=torch.float16, 
bnb_4bit_use_double_Quant=참 
) 

#모델로드 (양자화) 
모델 = AutoModelForCausalLM.from_pretrained( 
모델_이름, 
양자화_구성=퀀트_구성, 
device_map="자동" 
) 

#모델준비 
모델 = prepare_model_for_kbit_training(모델) 

# LoRA 설정 
lora_config = LoraConfig( 
r=16, 
lora_alpha=32, 
target_modules=["q_proj", "k_proj", "v_proj", "o_proj"], 
lora_dropout=0.05, 
편견="없음", 
task_type="CAUSAL_LM" 
) 

# LoRA적용 
모델 = get_peft_model(모델, lora_config) 
model.print_trainable_parameters() 

반환 모델 

def train_with_trainer(모델, train_dataset, output_dir="./lora_output"): 
"""Trainer로 파인튜닝 달리기""" 
Transformers에서 TrainingArguments, Trainer 가져오기 

training_args = TrainingArguments( 
출력_디렉터리=출력_디렉터리, 
per_device_train_batch_size=4, 
그래디언트_축적_단계=4, 
학습률=2e-4, 
fp16=맞습니다, 
로깅_단계=10, 
save_strategy="에포크", 
eval_strategy="시대", 
num_train_epochs=3, 
Warmup_ratio=0.1, 
optim="paged_adamw_8bit" 
) 

트레이너 = 트레이너( 
모델=모델, 
args=training_args, 
train_dataset=train_dataset 
) 

트레이너.기차() 
트레이너.저장_모델(output_dir) 
리턴 트레이너