Ver3.0 ๐ DeepSeek-Coder๋ก ์ฝ๋ ์์ฑํ๊ธฐ: AI๊ฐ ๋ด ์ฝ๋ฉ ์น๊ตฌ๊ฐ ๋๋ ์๊ฐ

๐ DeepSeek-Coder๋ก ์ฝ๋ ์์ฑํ๊ธฐ: AI๊ฐ ๋ด ์ฝ๋ฉ ์น๊ตฌ๊ฐ ๋๋ ์๊ฐ
ํ๋ก๊ทธ๋๋ฐ, ์ด์ AI์ ํจ๊ป ๋ ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ!
์๋ ! ๐ ํน์ ์ฝ๋ ์ง๋ค๊ฐ ๋งํ์ ๊ตฌ๊ธ๋ง 10๋ฒ์งธ ํ๊ณ ์๊ฑฐ๋, "์ด๊ฑฐ ์ด๋ป๊ฒ ๊ตฌํํ์ง?" ํ๋ฉด์ ๋จธ๋ฆฌ ์ธ๋งค๊ณ ์์ง ์์? ๊ทธ๋ด ๋๋ง๋ค ์์ ์ฒ์ฌ ๊ฐ๋ฐ์ ์น๊ตฌ๊ฐ ์์ผ๋ฉด ์ผ๋ง๋ ์ข์๊น ์์ํด๋ณธ ์ ์์ ๊ฑฐ์ผ. ๊ทธ๋ฐ๋ฐ ๋ง์ด์ผ, ์ด์ ๊ทธ๊ฒ ํ์ค์ด ๋์ด! ๋ฐ๋ก DeepSeek-Coder๋ผ๋ AI ์ฝ๋ฉ ์ด์์คํดํธ ๋๋ถ์ด์ง. ๐
DeepSeek-Coder๋ ์ต๊ทผ ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์์ ์์ฒญ๋ ์ฃผ๋ชฉ์ ๋ฐ๊ณ ์๋ ์คํ์์ค AI ๋ชจ๋ธ์ด์ผ. ChatGPT๋ GitHub Copilot์ฒ๋ผ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ๋๋ฐ, ํนํ ์ฝ๋ฉ์ ํนํ๋์ด ์์ด์ ์ค๋ฌด์์๋ ๋ฐ๋ก ์ธ ์ ์๋ ์์ค์ ์ฝ๋๋ฅผ ๋๋ฑ ๋ง๋ค์ด๋ด๊ฑฐ๋ . ๊ฒ๋ค๊ฐ ์คํ์์ค๋ผ์ ๋ฌด๋ฃ๋ก ์ฌ์ฉํ ์ ์๋ค๋ ๊ฒ ์ต๊ณ ์ ์ฅ์ ์ด์ผ! ๐ฐ
์ค๋์ ์ด DeepSeek-Coder๋ฅผ ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉํ๋์ง, ์ฒ์๋ถํฐ ๋๊น์ง ์น๊ตฌํํ ์ค๋ช ํ๋ฏ์ด ์ฝ๊ฒ ์๋ ค์ค๊ฒ. ์ค์น๋ถํฐ ์ค์ ์ฝ๋ ์์ฑ๊น์ง, ํ๋๋ ์ด๋ ต์ง ์์ผ๋๊น ํธํ๊ฒ ๋ฐ๋ผ์! ๐ฏ
๋ณธ๊ฒฉ์ ์ผ๋ก ์ค์ต์ ๋ค์ด๊ฐ๊ธฐ ์ ์, DeepSeek-Coder๊ฐ ์ ํํ ๋ญ์ง๋ถํฐ ์์๋ณผ๊น? ๊ฐ๋จํ ๋งํ๋ฉด ์ฝ๋ ์์ฑ์ ํนํ๋ ๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ(LLM)์ด์ผ. ์ค๊ตญ์ DeepSeek AI๋ผ๋ ํ์ฌ์์ ๋ง๋ค์๋๋ฐ, 2023๋ ๋ง์ ๊ณต๊ฐ๋์๋ง์ ๊ฐ๋ฐ์๋ค ์ฌ์ด์์ ์ ์๋ฌธ์ด ์ซ ํผ์ก์ง. ๐ฅ
์ด ์น๊ตฌ์ ํน๋ณํ ์ ์ ๋ญ๋๋ฉด:
โจ ์ฒซ ๋ฒ์งธ, ์ฝ๋ฉ ์ ๋ฌธ๊ฐ์ผ๋ฐ์ ์ธ ๋ํํ AI์ ๋ฌ๋ฆฌ, ์ฒ์๋ถํฐ ์ฝ๋ ์์ฑ์ ๋ชฉ์ ์ผ๋ก ํ์ตํ์ด. ๊ทธ๋์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ฌธ๋ฒ, ํจํด, ๋ฒ ์คํธ ํ๋ํฐ์ค๋ฅผ ์ ๋ง ์ ์ดํดํ๊ณ ์์ง. Python, JavaScript, Java, C++, Go ๋ฑ 80๊ฐ ์ด์์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์ง์ํด!
๐ ๋ ๋ฒ์งธ, ์คํ์์ค์ ํ์์ ์ฉ AI ๋๊ตฌ๋ค์ ์ ๊ตฌ๋ ๋ฃ๊ฐ ๋ง๋ง์น ์์์? ๊ทผ๋ฐ DeepSeek-Coder๋ ์์ ์คํ์์ค์ผ. GitHub์์ ๋ชจ๋ธ ๊ฐ์ค์น๋ฅผ ๋ค์ด๋ฐ์์ ๋ก์ปฌ์์ ๋๋ฆด ์๋ ์๊ณ , API๋ก๋ ์ฌ์ฉํ ์ ์์ด. ๊ฐ์ธ ํ๋ก์ ํธ๋ ์์ ํ๋ก์ ํธ๋ ์์ ๋กญ๊ฒ ์ธ ์ ์๋ค๋ ๊ฒ ์์ฒญ๋ ์ฅ์ ์ด์ง! ๐ช
๐ ์ธ ๋ฒ์งธ, ์ค์ ์ฑ๋ฅ๋ฒค์น๋งํฌ ํ ์คํธ์์ GPT-3.5๋ Claude ๊ฐ์ ์ ๋ช ๋ชจ๋ธ๋ค๊ณผ ๋น์ทํ๊ฑฐ๋ ๋ ๋์ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ์ด. ํนํ HumanEval(์ฝ๋ ์์ฑ ๋ฅ๋ ฅ ํ๊ฐ ์งํ)์์ ๋์ ์ ์๋ฅผ ๊ธฐ๋กํ๋๋ฐ, ์ด๊ฑด ์ค์ ๋ก ์ฌ๋์ด ์์ฑํ ๊ฒ ๊ฐ์ ํ์ง์ ์ฝ๋๋ฅผ ๋ง๋ค์ด๋ธ๋ค๋ ๋ป์ด์ผ. ๐
DeepSeek-Coder๋ ์ฌ๋ฌ ๋ฒ์ ์ด ์๋๋ฐ, ํ๋ผ๋ฏธํฐ ์์ ๋ฐ๋ผ 1.3B(13์ต), 6.7B(67์ต), 33B(330์ต) ๋ชจ๋ธ๋ก ๋๋์ด. ์ซ์๊ฐ ํด์๋ก ์ฑ๋ฅ์ด ์ข์ง๋ง ๊ทธ๋งํผ ์ปดํจํ ๋ฆฌ์์ค๋ ๋ง์ด ํ์ํด. ๊ฐ์ธ PC์์๋ ๋ณดํต 6.7B ๋ชจ๋ธ์ ๋ง์ด ์ฌ์ฉํ๊ณ , ํด๋ผ์ฐ๋ ํ๊ฒฝ์ด๋ผ๋ฉด 33B ๋ชจ๋ธ๋ ์ถฉ๋ถํ ๋๋ฆด ์ ์์ด. ๐ฅ๏ธ
๊ทธ๋ฆฌ๊ณ ์ฌ๋ฐ๋ ๊ฑด, ์ด ๋ชจ๋ธ์ด ๋จ์ํ ์ฝ๋๋ง ์์ฑํ๋ ๊ฒ ์๋๋ผ ์ฝ๋ ์ค๋ช , ๋ฒ๊ทธ ์์ , ๋ฆฌํฉํ ๋ง, ํ ์คํธ ์ฝ๋ ์์ฑ๊น์ง ๋ค์ํ ์์ ์ ํ ์ ์๋ค๋ ๊ฑฐ์ผ. ๋ง์น ์์์ ํ์ด ํ๋ก๊ทธ๋๋ฐ ํด์ฃผ๋ ์๋์ด ๊ฐ๋ฐ์ ๊ฐ์ ๋๋์ด๋๊น? ๐
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก DeepSeek-Coder๋ฅผ ์ฌ์ฉํด๋ณผ ์ค๋น๋ฅผ ํด๋ณด์! ํฌ๊ฒ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ด. ํ๋๋ ๋ก์ปฌ ํ๊ฒฝ์ ์ง์ ์ค์นํ๋ ๊ฑฐ๊ณ , ๋ค๋ฅธ ํ๋๋ ํด๋ผ์ฐ๋ API๋ฅผ ์ฌ์ฉํ๋ ๊ฑฐ์ผ. ๊ฐ๊ฐ์ ์ฅ๋จ์ ์ ์ดํด๋ณด๊ณ ๋ํํ ๋ง๋ ๋ฐฉ๋ฒ์ ์ ํํ๋ฉด ๋ผ! ๐ฏ
๋ฐฉ๋ฒ 1๏ธโฃ: ๋ก์ปฌ ์ค์น (์ถ์ฒ: ํ์ต ๋ชฉ์ , ๊ฐ์ธ ํ๋ก์ ํธ)
์ฅ์ : ์์ ๋ฌด๋ฃ, ๋ฐ์ดํฐ ํ๋ผ์ด๋ฒ์ ๋ณด์ฅ, ์ธํฐ๋ท ์์ด๋ ์ฌ์ฉ ๊ฐ๋ฅ
๋จ์ : ์ด๊ธฐ ์ค์ ์ด ์กฐ๊ธ ๋ณต์ก, GPU ๋ฉ๋ชจ๋ฆฌ ํ์ (์ต์ 8GB ๊ถ์ฅ)
๋ฐฉ๋ฒ 2๏ธโฃ: API ์ฌ์ฉ (์ถ์ฒ: ๋น ๋ฅธ ํ๋กํ ํ์ดํ, ํ ํ๋ก์ ํธ)
์ฅ์ : ์ค์น ๊ณผ์ ์์ด ๋ฐ๋ก ์ฌ์ฉ, ๊ฐ๋ ฅํ ์๋ฒ ์ฑ๋ฅ ํ์ฉ
๋จ์ : ์ฌ์ฉ๋์ ๋ฐ๋ผ ๋น์ฉ ๋ฐ์ ๊ฐ๋ฅ, ์ธํฐ๋ท ์ฐ๊ฒฐ ํ์
์ค๋์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋ชจ๋ ๋ค๋ค๋ณผ ๊ฑด๋ฐ, ๋จผ์ ๋ก์ปฌ ์ค์น๋ถํฐ ์์ํด๋ณด์! ๐ป
๐ ์ฌ์ ์ค๋น๋ฌผ ์ฒดํฌ๋ฆฌ์คํธ
โ
Python 3.8 ์ด์ (3.10 ๊ถ์ฅ)
โ
pip (Python ํจํค์ง ๊ด๋ฆฌ์)
โ
Git (๋ชจ๋ธ ๋ค์ด๋ก๋์ฉ)
โ
CUDA ์ง์ GPU (์ ํ์ฌํญ, ํ์ง๋ง ๊ฐ๋ ฅ ์ถ์ฒ)
โ
์ต์ 16GB RAM (32GB ๊ถ์ฅ)
โ
20GB ์ด์์ ์ฌ์ ๋์คํฌ ๊ณต๊ฐ
GPU๊ฐ ์์ด๋ CPU๋ก ๋๋ฆด ์๋ ์๋๋ฐ, ์์งํ ๋งํ๋ฉด ์์ฒญ ๋๋ ค. ๊ฐ๋จํ ํ ์คํธ ์ ๋๋ ๊ด์ฐฎ์ง๋ง, ์ค์ ๋ก ์์ ํ๋ ค๋ฉด GPU๊ฐ ๊ฑฐ์ ํ์๋ผ๊ณ ๋ณด๋ฉด ๋ผ. NVIDIA GPU๊ฐ ์๋ค๋ฉด CUDA๋ฅผ ๊ผญ ์ค์นํด์ฃผ์! ๐ฎ
๐ง Step 1: ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
ํฐ๋ฏธ๋์ด๋ ๋ช ๋ น ํ๋กฌํํธ๋ฅผ ์ด๊ณ ๋ค์ ๋ช ๋ น์ด๋ค์ ์ฐจ๋ก๋๋ก ์ ๋ ฅํด์ค:
# ๊ฐ์ํ๊ฒฝ ์์ฑ (์ ํ์ฌํญ์ด์ง๋ง ๊ฐ๋ ฅ ์ถ์ฒ!)
python -m venv deepseek_env
# ๊ฐ์ํ๊ฒฝ ํ์ฑํ
# Windows:
deepseek_env\Scripts\activate
# Mac/Linux:
source deepseek_env/bin/activate
# ํ์ ํจํค์ง ์ค์น
pip install torch transformers accelerate
pip install sentencepiece protobuf
pip install bitsandbytes # GPU ๋ฉ๋ชจ๋ฆฌ ์ต์ ํ์ฉ
์ค์นํ๋ ๋ฐ ์๊ฐ์ด ์ข ๊ฑธ๋ฆด ์ ์์ด. ์ปคํผ ํ ์ ํ์ ๋ง์๋ฉด์ ๊ธฐ๋ค๋ ค๋ ์ข์! โ
๐ก ๊ฟํ: ๊ฐ์ํ๊ฒฝ์ ์ฌ์ฉํ๋ ์ด์ ๋ ํ๋ก์ ํธ๋ณ๋ก ํจํค์ง ๋ฒ์ ์ ๋ ๋ฆฝ์ ์ผ๋ก ๊ด๋ฆฌํ๊ธฐ ์ํด์์ผ. ๋์ค์ ๋ค๋ฅธ ํ๋ก์ ํธ์ ์ถฉ๋์ด ๋ ์ผ์ด ์์ด์ ์ ๋ง ํธํด! ์ฒ์์ ๊ท์ฐฎ์ ๋ณด์ฌ๋ ์ต๊ด ๋ค์ด๋ฉด ๊ฐ๋ฐ ์ธ์์ด ํจ์ฌ ํธ์ํด์ง๋ค๋๊น? ๐
๐ง Step 2: DeepSeek-Coder ๋ชจ๋ธ ๋ถ๋ฌ์ค๊ธฐ
์ด์ ์ค์ ๋ก ๋ชจ๋ธ์ ์ฌ์ฉํ Python ์ฝ๋๋ฅผ ์์ฑํด๋ณด์. ์๋ก์ด ํ์ผ์ ๋ง๋ค๊ณ (์: deepseek_test.py) ๋ค์ ์ฝ๋๋ฅผ ์ ๋ ฅํด์ค:
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
# ๋ชจ๋ธ ์ด๋ฆ ์ง์ (6.7B ๋ชจ๋ธ ์ฌ์ฉ)
model_name = "deepseek-ai/deepseek-coder-6.7b-instruct"
print("๐ ๋ชจ๋ธ ๋ก๋ฉ ์ค... ์กฐ๊ธ๋ง ๊ธฐ๋ค๋ ค์ค!")
# ํ ํฌ๋์ด์ ๋ก๋
tokenizer = AutoTokenizer.from_pretrained(model_name)
# ๋ชจ๋ธ ๋ก๋ (GPU ์ฌ์ฉ ๊ฐ๋ฅํ๋ฉด ์๋์ผ๋ก GPU์ ์ฌ๋ผ๊ฐ)
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.float16, # ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ
device_map="auto", # ์๋์ผ๋ก ์ต์ ๋๋ฐ์ด์ค ์ ํ
trust_remote_code=True
)
print("โ
๋ชจ๋ธ ๋ก๋ฉ ์๋ฃ! ์ด์ ์ฝ๋๋ฅผ ์์ฑํ ์ค๋น๊ฐ ๋์ด!")
์ด ์ฝ๋๋ฅผ ์ฒ์ ์คํํ๋ฉด ๋ชจ๋ธ ํ์ผ์ ๋ค์ด๋ก๋ํ๋๋ฐ, ํฌ๊ธฐ๊ฐ ์ฝ 13GB ์ ๋ ๋ผ. ์ธํฐ๋ท ์๋์ ๋ฐ๋ผ 10~30๋ถ ์ ๋ ๊ฑธ๋ฆด ์ ์์ผ๋ ์ธ๋ด์ฌ์ ๊ฐ์ง๊ณ ๊ธฐ๋ค๋ ค์ค! ํ ๋ฒ ๋ค์ด๋ก๋ํ๋ฉด ๋ค์๋ถํด ๋ฐ๋ก ๋ก๋๋๋๊น ๊ฑฑ์ ๋ง. ๐ฅ
โ ๏ธ ์ฃผ์์ฌํญ: GPU ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ๋ฉด ์๋ฌ๊ฐ ๋ ์ ์์ด. ๊ทธ๋ด ๋ ๋ ์์ ๋ชจ๋ธ(1.3B)์ ์ฌ์ฉํ๊ฑฐ๋, load_in_8bit=True ์ต์ ์ ์ถ๊ฐํด์ 8๋นํธ ์์ํ๋ฅผ ์ ์ฉํด๋ด. ์ฑ๋ฅ์ ์กฐ๊ธ ๋จ์ด์ง์ง๋ง ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๋ฐ์ผ๋ก ์ค์ผ ์ ์์ด!
๋๋์ด ์ค์ ์ด์ผ! ์ด์ DeepSeek-Coder์๊ฒ ์ค์ ๋ก ์ฝ๋๋ฅผ ์์ฑํด๋ฌ๋ผ๊ณ ์์ฒญํด๋ณด์. ๊ฐ๋จํ ์์ ๋ถํฐ ์์ํด์ ์ ์ ๋ณต์กํ ๊ฑธ๋ก ๋์ด๊ฐ ๊ฑฐ์ผ. ์ค๋น๋์ด? ๐ฌ
๐ฏ ์์ 1: ๊ฐ๋จํ ํจ์ ์์ฑ
๋จผ์ ๊ธฐ๋ณธ์ ์ธ ํจ์๋ฅผ ๋ง๋ค์ด๋ฌ๋ผ๊ณ ํด๋ณด์. ๋ค์ ์ฝ๋๋ฅผ ์ถ๊ฐํด์ค:
def generate_code(prompt):
"""
ํ๋กฌํํธ๋ฅผ ๋ฐ์์ ์ฝ๋๋ฅผ ์์ฑํ๋ ํจ์
"""
# ํ๋กฌํํธ ํฌ๋งทํ
(Instruct ๋ชจ๋ธ์ฉ)
formatted_prompt = f"""### Instruction:
{prompt}
### Response:
"""
# ํ ํฐํ
inputs = tokenizer(formatted_prompt, return_tensors="pt").to(model.device)
# ์ฝ๋ ์์ฑ
outputs = model.generate(
**inputs,
max_new_tokens=512, # ์์ฑํ ์ต๋ ํ ํฐ ์
temperature=0.2, # ๋ฎ์์๋ก ๋ ๊ฒฐ์ ์ , ๋์์๋ก ๋ ์ฐฝ์์
top_p=0.95,
do_sample=True,
pad_token_id=tokenizer.eos_token_id
)
# ๊ฒฐ๊ณผ ๋์ฝ๋ฉ
generated_code = tokenizer.decode(outputs[0], skip_special_tokens=True)
# Response ๋ถ๋ถ๋ง ์ถ์ถ
response = generated_code.split("### Response:")[-1].strip()
return response
# ํ
์คํธํด๋ณด์!
prompt = "Python์ผ๋ก ๋ ์๋ฅผ ๋ํ๋ ํจ์๋ฅผ ์์ฑํด์ค."
result = generate_code(prompt)
print("๐ ์์ฑ๋ ์ฝ๋:")
print(result)
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด DeepSeek-Coder๊ฐ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ฅผ ์์ฑํด์ค ๊ฑฐ์ผ:
def add_numbers(a, b):
"""
๋ ์๋ฅผ ๋ํ๋ ํจ์
Args:
a: ์ฒซ ๋ฒ์งธ ์ซ์
b: ๋ ๋ฒ์งธ ์ซ์
Returns:
๋ ์์ ํฉ
"""
return a + b
# ์ฌ์ฉ ์์
result = add_numbers(5, 3)
print(f"5 + 3 = {result}") # ์ถ๋ ฅ: 5 + 3 = 8
์ค์ค! ๐ ๋จ์ํ ํจ์๋ง ๋ง๋ ๊ฒ ์๋๋ผ docstring(๋ฌธ์ํ ์ฃผ์)๊น์ง ์น์ ํ๊ฒ ๋ฌ์์คฌ์ง? ์ฌ์ง์ด ์ฌ์ฉ ์์๊น์ง! ์ด๊ฒ ๋ฐ๋ก DeepSeek-Coder์ ๋งค๋ ฅ์ด์ผ. ์ค๋ฌด์์ ๋ฐ๋ก ์ธ ์ ์๋ ์์ค์ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ๊ฑฐ๋ .
๐ฏ ์์ 2: ์ข ๋ ๋ณต์กํ ์์ฒญ
์ด๋ฒ์ ์กฐ๊ธ ๋ ์ค์ฉ์ ์ธ ๊ฑธ ๋ง๋ค์ด๋ณด์. ํ์ผ ์ฒ๋ฆฌ ๊ด๋ จ ํจ์๋ฅผ ์์ฒญํด๋ณผ๊ฒ:
prompt = """
CSV ํ์ผ์ ์ฝ์ด์ ํน์ ์ปฌ๋ผ์ ํ๊ท ๊ฐ์ ๊ณ์ฐํ๋ Python ํจ์๋ฅผ ์์ฑํด์ค.
pandas ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ณ , ์๋ฌ ์ฒ๋ฆฌ๋ ํฌํจํด์ค.
"""
result = generate_code(prompt)
print("๐ ์์ฑ๋ ์ฝ๋:")
print(result)
DeepSeek-Coder๊ฐ ์์ฑํ ๊ฒฐ๊ณผ:
import pandas as pd
def calculate_column_average(file_path, column_name):
"""
CSV ํ์ผ์์ ํน์ ์ปฌ๋ผ์ ํ๊ท ๊ฐ์ ๊ณ์ฐํ๋ ํจ์
Args:
file_path (str): CSV ํ์ผ ๊ฒฝ๋ก
column_name (str): ํ๊ท ์ ๊ณ์ฐํ ์ปฌ๋ผ ์ด๋ฆ
Returns:
float: ์ปฌ๋ผ์ ํ๊ท ๊ฐ
Raises:
FileNotFoundError: ํ์ผ์ด ์กด์ฌํ์ง ์์ ๋
KeyError: ์ปฌ๋ผ์ด ์กด์ฌํ์ง ์์ ๋
ValueError: ์ซ์๊ฐ ์๋ ๋ฐ์ดํฐ๊ฐ ํฌํจ๋์ด ์์ ๋
"""
try:
# CSV ํ์ผ ์ฝ๊ธฐ
df = pd.read_csv(file_path)
# ์ปฌ๋ผ ์กด์ฌ ์ฌ๋ถ ํ์ธ
if column_name not in df.columns:
raise KeyError(f"์ปฌ๋ผ '{column_name}'์ด ์กด์ฌํ์ง ์์ต๋๋ค.")
# ํ๊ท ๊ณ์ฐ
average = df[column_name].mean()
# NaN ์ฒดํฌ
if pd.isna(average):
raise ValueError(f"์ปฌ๋ผ '{column_name}'์ ์ ํจํ ์ซ์ ๋ฐ์ดํฐ๊ฐ ์์ต๋๋ค.")
return average
except FileNotFoundError:
print(f"์ค๋ฅ: ํ์ผ '{file_path}'๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.")
raise
except Exception as e:
print(f"์ค๋ฅ ๋ฐ์: {str(e)}")
raise
# ์ฌ์ฉ ์์
if __name__ == "__main__":
try:
avg = calculate_column_average("data.csv", "price")
print(f"ํ๊ท ๊ฐ๊ฒฉ: {avg:.2f}")
except Exception as e:
print(f"์ฒ๋ฆฌ ์คํจ: {e}")
์์ฐ! ๐ฒ ์ด๊ฑด ์ง์ง ํ๋ก๋์ ๋ ๋ฒจ ์ฝ๋์ผ. ์๋ฌ ์ฒ๋ฆฌ๋ ๊ผผ๊ผผํ๊ฒ ๋์ด ์๊ณ , docstring๋ ์๋ฒฝํ๊ณ , ์ฌ์ง์ด ์ฌ์ฉ ์์๊น์ง ํฌํจ๋์ด ์์ด. ์ด ์ ๋๋ฉด ์ค์ ํ๋ก์ ํธ์ ๋ฐ๋ก ๋ฃ์ด๋ ๋ ์์ค์ด์ง!
๐จ ํ๋กฌํํธ ์์ฑ ํDeepSeek-Coder์๊ฒ ๋ ์ข์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ผ๋ ค๋ฉด ํ๋กฌํํธ๋ฅผ ์ ์์ฑํ๋ ๊ฒ ์ค์ํด. ๋ช ๊ฐ์ง ํ์ ์๋ ค์ค๊ฒ:
1๏ธโฃ ๊ตฌ์ฒด์ ์ผ๋ก ์์ฒญํ๊ธฐ: "ํจ์ ๋ง๋ค์ด์ค" ๋ณด๋ค๋ "์
๋ ฅ๊ฐ ๊ฒ์ฆ์ ํฌํจํ ํจ์๋ฅผ ๋ง๋ค์ด์ค"๊ฐ ํจ์ฌ ์ข์.
2๏ธโฃ ์ฌ์ฉํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ช
์: "pandas๋ฅผ ์ฌ์ฉํด์" ๊ฐ์ ์์ผ๋ก ๊ตฌ์ฒด์ ์ธ ๋๊ตฌ๋ฅผ ์ง์ ํ๋ฉด ๋ ์ ํํ ์ฝ๋๋ฅผ ๋ฐ์ ์ ์์ด.
3๏ธโฃ ์ฝ๋ ์คํ์ผ ์์ฒญ: "ํ์
ํํธ๋ฅผ ํฌํจํด์ค", "์ฃผ์์ ์์ธํ ๋ฌ์์ค" ๊ฐ์ ์์ฒญ๋ ๊ฐ๋ฅํด.
4๏ธโฃ ์์ ์ ๊ณต: ์ํ๋ ์
์ถ๋ ฅ ํํ๋ฅผ ์์๋ก ๋ณด์ฌ์ฃผ๋ฉด ๋ ์ ํํ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด!
์ด์ ๊ธฐ๋ณธ์ ๋ง์คํฐํ์ผ๋, ์ค์ ๊ฐ๋ฐ ์ํฉ์์ ์ด๋ป๊ฒ ํ์ฉํ ์ ์๋์ง ๋ค์ํ ์์ ๋ฅผ ์ดํด๋ณด์! ๊ฐ ์๋๋ฆฌ์ค๋ง๋ค ์ค์ฉ์ ์ธ ํ๋ ํจ๊ป ์๋ ค์ค๊ฒ. ๐
๐ฑ ์๋๋ฆฌ์ค 1: REST API ์๋ํฌ์ธํธ ์์ฑ
์น ๊ฐ๋ฐํ ๋ ๊ฐ์ฅ ๋ง์ด ๋ง๋๋ ๊ฒ API ์๋ํฌ์ธํธ์์? DeepSeek-Coderํํ ๋งก๊ฒจ๋ณด์:
prompt = """
Flask๋ฅผ ์ฌ์ฉํด์ ์ฌ์ฉ์ ์ ๋ณด๋ฅผ ๊ด๋ฆฌํ๋ REST API๋ฅผ ๋ง๋ค์ด์ค.
๋ค์ ๊ธฐ๋ฅ์ด ํ์ํด:
- GET /users: ๋ชจ๋ ์ฌ์ฉ์ ์กฐํ
- GET /users/<id>: ํน์ ์ฌ์ฉ์ ์กฐํ
- POST /users: ์ ์ฌ์ฉ์ ์์ฑ
- PUT /users/<id>: ์ฌ์ฉ์ ์ ๋ณด ์์
- DELETE /users/<id>: ์ฌ์ฉ์ ์ญ์
๋ฐ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๊ณ , ์๋ฌ ์ฒ๋ฆฌ์ ์
๋ ฅ ๊ฒ์ฆ๋ ํฌํจํด์ค.
"""
result = generate_code(prompt)
print(result)
์์ฑ๋ ์ฝ๋๋ ์ด๋ฐ ์์ผ๋ก ๋์ฌ ๊ฑฐ์ผ:
from flask import Flask, request, jsonify
from datetime import datetime
app = Flask(__name__)
# ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์ (์ค์ ๋ก๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฌ์ฉ)
users = {}
user_id_counter = 1
def validate_user_data(data):
"""์ฌ์ฉ์ ๋ฐ์ดํฐ ์ ํจ์ฑ ๊ฒ์ฆ"""
required_fields = ['name', 'email']
for field in required_fields:
if field not in data:
return False, f"'{field}' ํ๋๊ฐ ํ์ํฉ๋๋ค."
if not isinstance(data['name'], str) or len(data['name']) < 2:
return False, "์ด๋ฆ์ 2์ ์ด์์ด์ด์ผ ํฉ๋๋ค."
if '@' not in data['email']:
return False, "์ ํจํ ์ด๋ฉ์ผ ์ฃผ์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์."
return True, None
@app.route('/users', methods=['GET'])
def get_users():
"""๋ชจ๋ ์ฌ์ฉ์ ์กฐํ"""
return jsonify(list(users.values())), 200
@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
"""ํน์ ์ฌ์ฉ์ ์กฐํ"""
user = users.get(user_id)
if not user:
return jsonify({'error': '์ฌ์ฉ์๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.'}), 404
return jsonify(user), 200
@app.route('/users', methods=['POST'])
def create_user():
"""์ ์ฌ์ฉ์ ์์ฑ"""
global user_id_counter
data = request.get_json()
if not data:
return jsonify({'error': '์์ฒญ ๋ณธ๋ฌธ์ด ๋น์ด์์ต๋๋ค.'}), 400
is_valid, error_msg = validate_user_data(data)
if not is_valid:
return jsonify({'error': error_msg}), 400
user = {
'id': user_id_counter,
'name': data['name'],
'email': data['email'],
'created_at': datetime.now().isoformat()
}
users[user_id_counter] = user
user_id_counter += 1
return jsonify(user), 201
@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
"""์ฌ์ฉ์ ์ ๋ณด ์์ """
if user_id not in users:
return jsonify({'error': '์ฌ์ฉ์๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.'}), 404
data = request.get_json()
if not data:
return jsonify({'error': '์์ฒญ ๋ณธ๋ฌธ์ด ๋น์ด์์ต๋๋ค.'}), 400
is_valid, error_msg = validate_user_data(data)
if not is_valid:
return jsonify({'error': error_msg}), 400
users[user_id].update({
'name': data['name'],
'email': data['email'],
'updated_at': datetime.now().isoformat()
})
return jsonify(users[user_id]), 200
@app.route('/users/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
"""์ฌ์ฉ์ ์ญ์ """
if user_id not in users:
return jsonify({'error': '์ฌ์ฉ์๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.'}), 404
deleted_user = users.pop(user_id)
return jsonify({'message': '์ฌ์ฉ์๊ฐ ์ญ์ ๋์์ต๋๋ค.', 'user': deleted_user}), 200
if __name__ == '__main__':
app.run(debug=True)
์๋ฒฝํ์ง ์์? ๐ RESTful ์์น๋ ์ ์ง์ผฐ๊ณ , HTTP ์ํ ์ฝ๋๋ ์ ์ ํ๊ฒ ์ฌ์ฉํ์ด. ์ด ์ฝ๋๋ฅผ ๊ทธ๋๋ก ์คํํ๋ฉด ๋ฐ๋ก ๋์ํ๋ API ์๋ฒ๊ฐ ์์ฑ๋ผ!
๐งช ์๋๋ฆฌ์ค 2: ํ ์คํธ ์ฝ๋ ์๋ ์์ฑ
ํ ์คํธ ์ฝ๋ ์์ฑ, ์์งํ ๊ท์ฐฎ์ง? ๊ทผ๋ฐ ์ค์ํ์์. DeepSeek-Coderํํ ๋งก๊ฒจ๋ณด์:
prompt = """
๋ค์ ํจ์์ ๋ํ pytest ํ
์คํธ ์ฝ๋๋ฅผ ์์ฑํด์ค:
def calculate_discount(price, discount_rate, min_price=0):
if price < min_price:
raise ValueError("๊ฐ๊ฒฉ์ด ์ต์ ๊ธ์ก๋ณด๋ค ์์ต๋๋ค.")
if discount_rate < 0 or discount_rate > 100:
raise ValueError("ํ ์ธ์จ์ 0~100 ์ฌ์ด์ฌ์ผ ํฉ๋๋ค.")
return price * (1 - discount_rate / 100)
์ฃ์ง ์ผ์ด์ค์ ์์ธ ์ํฉ์ ๋ชจ๋ ํ
์คํธํด์ค.
"""
result = generate_code(prompt)
print(result)
์์ฑ๋ ํ ์คํธ ์ฝ๋:
import pytest
def calculate_discount(price, discount_rate, min_price=0):
if price < min_price:
raise ValueError("๊ฐ๊ฒฉ์ด ์ต์ ๊ธ์ก๋ณด๋ค ์์ต๋๋ค.")
if discount_rate < 0 or discount_rate > 100:
raise ValueError("ํ ์ธ์จ์ 0~100 ์ฌ์ด์ฌ์ผ ํฉ๋๋ค.")
return price * (1 - discount_rate / 100)
class TestCalculateDiscount:
"""calculate_discount ํจ์ ํ
์คํธ"""
def test_normal_discount(self):
"""์ ์์ ์ธ ํ ์ธ ๊ณ์ฐ"""
assert calculate_discount(100, 10) == 90.0
assert calculate_discount(1000, 20) == 800.0
assert calculate_discount(50, 50) == 25.0
def test_zero_discount(self):
"""ํ ์ธ์จ 0%"""
assert calculate_discount(100, 0) == 100.0
def test_full_discount(self):
"""ํ ์ธ์จ 100%"""
assert calculate_discount(100, 100) == 0.0
def test_with_min_price(self):
"""์ต์ ๊ธ์ก ์ค์ """
assert calculate_discount(100, 10, min_price=50) == 90.0
def test_price_below_minimum(self):
"""๊ฐ๊ฒฉ์ด ์ต์ ๊ธ์ก๋ณด๋ค ์์ ๊ฒฝ์ฐ"""
with pytest.raises(ValueError, match="๊ฐ๊ฒฉ์ด ์ต์ ๊ธ์ก๋ณด๋ค ์์ต๋๋ค"):
calculate_discount(50, 10, min_price=100)
def test_negative_discount_rate(self):
"""์์ ํ ์ธ์จ"""
with pytest.raises(ValueError, match="ํ ์ธ์จ์ 0~100 ์ฌ์ด์ฌ์ผ ํฉ๋๋ค"):
calculate_discount(100, -10)
def test_discount_rate_over_100(self):
"""100% ์ด๊ณผ ํ ์ธ์จ"""
with pytest.raises(ValueError, match="ํ ์ธ์จ์ 0~100 ์ฌ์ด์ฌ์ผ ํฉ๋๋ค"):
calculate_discount(100, 150)
def test_float_values(self):
"""์์์ ๊ฐ ์ฒ๋ฆฌ"""
result = calculate_discount(99.99, 15.5)
assert abs(result - 84.4916) < 0.001
def test_zero_price(self):
"""๊ฐ๊ฒฉ์ด 0์ธ ๊ฒฝ์ฐ"""
assert calculate_discount(0, 10) == 0.0
if __name__ == "__main__":
pytest.main([__file__, "-v"])
์! ๐ ์ฃ์ง ์ผ์ด์ค๊น์ง ์๋ฒฝํ๊ฒ ์ปค๋ฒํ์ด. ์์ ํ ์คํธ, ๊ฒฝ๊ณ๊ฐ ํ ์คํธ, ์์ธ ์ฒ๋ฆฌ ํ ์คํธ๊น์ง ๋ค ํฌํจ๋์ด ์์ง. ์ด ์ ๋๋ฉด ์ฝ๋ ์ปค๋ฒ๋ฆฌ์ง 100% ๋ฌ์ฑ์ด์ผ!
๐ก ์ค์ ํ: ํ ์คํธ ์ฝ๋๋ฅผ ์์ฑํ ๋๋ ์๋ณธ ํจ์์ ์ฝ๋๋ฅผ ํ๋กฌํํธ์ ํฌํจ์ํค๋ ๊ฒ ์ข์. ๊ทธ๋์ผ ํจ์์ ๋ก์ง์ ์ ํํ ์ดํดํ๊ณ ์ ์ ํ ํ ์คํธ๋ฅผ ๋ง๋ค์ด์ฃผ๊ฑฐ๋ . ๊ทธ๋ฆฌ๊ณ "์ฃ์ง ์ผ์ด์ค๋ฅผ ํฌํจํด์ค", "์์ธ ์ํฉ์ ํ ์คํธํด์ค" ๊ฐ์ ๊ตฌ์ฒด์ ์ธ ์์ฒญ์ ํ๋ฉด ๋ ์๋ฒฝํ ํ ์คํธ ์ฝ๋๋ฅผ ๋ฐ์ ์ ์์ด!
๐ ์๋๋ฆฌ์ค 3: ์ฝ๋ ๋ฆฌํฉํ ๋ง
๋ ๊ฑฐ์ ์ฝ๋๋ฅผ ๊ฐ์ ํ๊ณ ์ถ์ ๋๋ DeepSeek-Coder๊ฐ ๋์์ ์ค ์ ์์ด:
prompt = """
๋ค์ ์ฝ๋๋ฅผ ๋ฆฌํฉํ ๋งํด์ค. ๊ฐ๋
์ฑ์ ๋์ด๊ณ , ์ค๋ณต์ ์ ๊ฑฐํ๊ณ ,
๋ pythonicํ๊ฒ ๋ง๋ค์ด์ค:
def process_data(data):
result = []
for i in range(len(data)):
if data[i] > 0:
if data[i] % 2 == 0:
result.append(data[i] * 2)
else:
result.append(data[i] * 3)
return result
def process_data2(data):
result = []
for i in range(len(data)):
if data[i] > 0:
if data[i] % 2 == 1:
result.append(data[i] * 3)
else:
result.append(data[i] * 2)
return result
"""
result = generate_code(prompt)
print(result)
๋ฆฌํฉํ ๋ง๋ ์ฝ๋:
def process_data(data, odd_multiplier=3, even_multiplier=2):
"""
์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ์ฌ ํ์/์ง์์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ฐฐ์๋ฅผ ์ ์ฉ
Args:
data: ์ฒ๋ฆฌํ ์ซ์ ๋ฆฌ์คํธ
odd_multiplier: ํ์์ ์ ์ฉํ ๋ฐฐ์ (๊ธฐ๋ณธ๊ฐ: 3)
even_multiplier: ์ง์์ ์ ์ฉํ ๋ฐฐ์ (๊ธฐ๋ณธ๊ฐ: 2)
Returns:
์ฒ๋ฆฌ๋ ์ซ์ ๋ฆฌ์คํธ
"""
return [
num * (odd_multiplier if num % 2 else even_multiplier)
for num in data
if num > 0
]
# ์ฌ์ฉ ์์
data = [1, 2, 3, 4, -5, 6, 0, 7]
result = process_data(data)
print(result) # [3, 4, 9, 8, 12, 21]
# ๊ธฐ์กด process_data2์ ๋์ผํ ๋์ (ํ๋ผ๋ฏธํฐ๋ง ๋ค๋ฆ)
# process_data2๋ ์ฌ์ค process_data์ ๋ก์ง์ด ๊ฐ์ผ๋ฏ๋ก ํตํฉ ๊ฐ๋ฅ
์์ ๊น๋ํด์ก์ง? ๐ ๋ฆฌ์คํธ ์ปดํ๋ฆฌํจ์ ์ ์ฌ์ฉํด์ ์ฝ๋๊ฐ ํจ์ฌ ๊ฐ๊ฒฐํด์ก๊ณ , ์ค๋ณต๋ ํจ์๋ฅผ ํ๋๋ก ํตํฉํ์ด. ๊ฒ๋ค๊ฐ ํ๋ผ๋ฏธํฐ๋ฅผ ์ถ๊ฐํด์ ์ ์ฐ์ฑ๊น์ง ๋์์ง!
๋ก์ปฌ ์ค์น๊ฐ ๋ถ๋ด์ค๋ฝ๊ฑฐ๋, ๋ ๊ฐ๋ ฅํ ์๋ฒ ์ฑ๋ฅ์ ํ์ฉํ๊ณ ์ถ๋ค๋ฉด API ๋ฐฉ์์ ์ฌ์ฉํ ์ ์์ด. DeepSeek์ ๊ณต์ API๋ฅผ ์ ๊ณตํ๋๋ฐ, OpenAI API์ ํธํ๋๋ ํ์์ด๋ผ ์ฌ์ฉํ๊ธฐ ์ ๋ง ํธํด! ๐
๐ API ํค ๋ฐ๊ธ๋ฐ๊ธฐ
1. DeepSeek ๊ณต์ ์น์ฌ์ดํธ(https://platform.deepseek.com)์ ์ ์
2. ํ์๊ฐ์
ํ ๋ก๊ทธ์ธ
3. API Keys ๋ฉ๋ด์์ ์ ํค ์์ฑ
4. ์์ฑ๋ ํค๋ฅผ ์์ ํ ๊ณณ์ ๋ณด๊ด (์ ๋ ๊ณต๊ฐํ์ง ๋ง ๊ฒ!)
API ํค๋ฅผ ๋ฐ์๋ค๋ฉด ์ด์ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์:
import requests
import json
# API ์ค์
API_KEY = "your-api-key-here" # ์ฌ๊ธฐ์ ๋ฐ๊ธ๋ฐ์ ํค ์
๋ ฅ
API_URL = "https://api.deepseek.com/v1/chat/completions"
def generate_code_via_api(prompt, max_tokens=1000):
"""
DeepSeek API๋ฅผ ํตํด ์ฝ๋ ์์ฑ
"""
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
data = {
"model": "deepseek-coder",
"messages": [
{
"role": "system",
"content": "๋น์ ์ ์ ๋ฌธ ํ๋ก๊ทธ๋๋จธ์
๋๋ค. ๊น๋ํ๊ณ ํจ์จ์ ์ธ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์."
},
{
"role": "user",
"content": prompt
}
],
"max_tokens": max_tokens,
"temperature": 0.2,
"stream": False
}
try:
response = requests.post(API_URL, headers=headers, json=data)
response.raise_for_status()
result = response.json()
generated_code = result['choices'][0]['message']['content']
return generated_code
except requests.exceptions.RequestException as e:
print(f"API ์์ฒญ ์คํจ: {e}")
return None
# ์ฌ์ฉ ์์
prompt = "Python์ผ๋ก ์ด์ง ํ์ ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌํํด์ค. ์ฌ๊ท์ ๋ฐ๋ณต ๋ ๊ฐ์ง ๋ฒ์ ๋ชจ๋ ์์ฑํด์ค."
result = generate_code_via_api(prompt)
if result:
print("๐ ์์ฑ๋ ์ฝ๋:")
print(result)
API ๋ฐฉ์์ ์ฅ์ ์ ๋ญ๋๋ญ๋ํด๋ ์ค์น ๊ณผ์ ์ด ์๋ค๋ ๊ฑฐ์ผ. ๊ทธ๋ฅ requests ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ง ์์ผ๋ฉด ๋ฐ๋ก ์ฌ์ฉํ ์ ์์ด. ๊ฒ๋ค๊ฐ ์๋ฒ ์ฑ๋ฅ์ด ์ข์์ ์๋ต ์๋๋ ๋น ๋ฅด๊ณ ! ๐จ
๐ฐ ๋น์ฉ ๊ด๋ จ ํDeepSeek API๋ ์ฌ์ฉ๋์ ๋ฐ๋ผ ๊ณผ๊ธ๋๋๋ฐ, ๊ฐ๊ฒฉ์ด ์๋นํ ํฉ๋ฆฌ์ ์ธ ํธ์ด์ผ. ๋๋ต์ ์ธ ๊ฐ๊ฒฉ์:
โข ์
๋ ฅ ํ ํฐ: $0.14 / 1M ํ ํฐ
โข ์ถ๋ ฅ ํ ํฐ: $0.28 / 1M ํ ํฐ
์ฐธ๊ณ ๋ก 1M ํ ํฐ์ ๋๋ต 75๋ง ๋จ์ด ์ ๋์ผ. ๊ฐ์ธ ํ๋ก์ ํธ๋ก ์ฌ์ฉํ๋ฉด ํ ๋ฌ์ ๋ช ๋ฌ๋ฌ ์ ๋๋ฐ์ ์ ๋์ฌ ๊ฑฐ์ผ. ๋ฌด๋ฃ ํฌ๋ ๋ง๋ ์ ๊ณตํ๋๊น ์ฒ์์ ๋ถ๋ด ์์ด ํ
์คํธํด๋ณผ ์ ์์ด! ๐
๐ ์คํธ๋ฆฌ๋ฐ ๋ชจ๋ ํ์ฉํ๊ธฐ
๊ธด ์ฝ๋๋ฅผ ์์ฑํ ๋๋ ์คํธ๋ฆฌ๋ฐ ๋ชจ๋๋ฅผ ์ฌ์ฉํ๋ฉด ์ค์๊ฐ์ผ๋ก ๊ฒฐ๊ณผ๋ฅผ ๋ณผ ์ ์์ด. ๋ง์น ChatGPT์ฒ๋ผ ํ์ดํํ๋ ๊ฒ์ฒ๋ผ ๋ณด์ด๋ ๊ฑฐ์ง:
def generate_code_streaming(prompt):
"""
์คํธ๋ฆฌ๋ฐ ๋ฐฉ์์ผ๋ก ์ฝ๋ ์์ฑ
"""
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
data = {
"model": "deepseek-coder",
"messages": [
{"role": "user", "content": prompt}
],
"stream": True # ์คํธ๋ฆฌ๋ฐ ํ์ฑํ
}
response = requests.post(API_URL, headers=headers, json=data, stream=True)
print("๐ฌ ์ฝ๋ ์์ฑ ์ค...\n")
for line in response.iter_lines():
if line:
line = line.decode('utf-8')
if line.startswith('data: '):
line = line[6:] # 'data: ' ์ ๊ฑฐ
if line == '[DONE]':
break
try:
chunk = json.loads(line)
content = chunk['choices'][0]['delta'].get('content', '')
if content:
print(content, end='', flush=True)
except json.JSONDecodeError:
continue
print("\n\nโ
์์ฑ ์๋ฃ!")
# ์ฌ์ฉ ์์
generate_code_streaming("Python์ผ๋ก ๊ฐ๋จํ ์น ํฌ๋กค๋ฌ๋ฅผ ๋ง๋ค์ด์ค. BeautifulSoup์ ์ฌ์ฉํด์.")
์คํธ๋ฆฌ๋ฐ ๋ชจ๋๋ ์ฌ์ฉ์ ๊ฒฝํ์ด ํจ์ฌ ์ข์. ๊ธฐ๋ค๋ฆฌ๋ ๋์ ์ง๋ฃจํ์ง ์๊ณ , ์์ฑ๋๋ ๊ณผ์ ์ ์ค์๊ฐ์ผ๋ก ๋ณผ ์ ์๊ฑฐ๋ ! ๐
๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ๋ฒ์ ๋ง์คํฐํ์ผ๋, ์ด์ ์ข ๋ ๊ณ ๊ธ ๊ธฐ๋ฒ๋ค์ ์์๋ณด์. ์ด๋ฐ ํ๋ค์ ์๋ฉด DeepSeek-Coder๋ฅผ ํจ์ฌ ๋ ํจ๊ณผ์ ์ผ๋ก ํ์ฉํ ์ ์์ด! ๐
๐ฏ Few-Shot Learning ํ์ฉ
Few-Shot Learning์ ๋ช ๊ฐ์ง ์์๋ฅผ ์ ๊ณตํด์ AI๊ฐ ํจํด์ ํ์ตํ๊ฒ ํ๋ ๊ธฐ๋ฒ์ด์ผ. ํน์ ์ฝ๋ฉ ์คํ์ผ์ด๋ ํจํด์ ๋ฐ๋ฅด๊ฒ ํ๊ณ ์ถ์ ๋ ์ ์ฉํด:
prompt = """
๋ค์ ์์๋ฅผ ์ฐธ๊ณ ํด์ ๋น์ทํ ์คํ์ผ๋ก ์ฝ๋๋ฅผ ์์ฑํด์ค:
์์ 1:
์
๋ ฅ: "๋ฆฌ์คํธ์ ์ต๋๊ฐ ์ฐพ๊ธฐ"
์ถ๋ ฅ:
def find_max(numbers: list[int]) -> int:
'''๋ฆฌ์คํธ์์ ์ต๋๊ฐ์ ์ฐพ๋ ํจ์'''
if not numbers:
raise ValueError("๋น ๋ฆฌ์คํธ์
๋๋ค")
return max(numbers)
์์ 2:
์
๋ ฅ: "๋ฆฌ์คํธ์ ์ต์๊ฐ ์ฐพ๊ธฐ"
์ถ๋ ฅ:
def find_min(numbers: list[int]) -> int:
'''๋ฆฌ์คํธ์์ ์ต์๊ฐ์ ์ฐพ๋ ํจ์'''
if not numbers:
raise ValueError("๋น ๋ฆฌ์คํธ์
๋๋ค")
return min(numbers)
์ด์ ๋ค์์ ์์ฑํด์ค:
์
๋ ฅ: "๋ฆฌ์คํธ์ ํ๊ท ๊ฐ ๊ณ์ฐํ๊ธฐ"
"""
result = generate_code(prompt)
print(result)
์ด๋ ๊ฒ ํ๋ฉด DeepSeek-Coder๊ฐ ์์์ ์คํ์ผ(ํ์ ํํธ, docstring, ์๋ฌ ์ฒ๋ฆฌ ๋ฑ)์ ๊ทธ๋๋ก ๋ฐ๋ผ์ ์ฝ๋๋ฅผ ์์ฑํด์ค. ํ ํ๋ก์ ํธ์์ ์ฝ๋ฉ ์ปจ๋ฒค์ ์ ๋ง์ถ ๋ ์ ๋ง ์ ์ฉํ์ง! ๐ฅ
๐ง ํ๋ผ๋ฏธํฐ ํ๋
์ฝ๋ ์์ฑ ํ์ง์ ๋์ด๋ ค๋ฉด ํ๋ผ๋ฏธํฐ๋ฅผ ์ ์ ํ ์กฐ์ ํ๋ ๊ฒ ์ค์ํด. ์ฃผ์ ํ๋ผ๋ฏธํฐ๋ค์ ์ดํด๋ณด์:
| ํ๋ผ๋ฏธํฐ | ์ค๋ช | ์ถ์ฒ๊ฐ |
|---|---|---|
| temperature | ์ฐฝ์์ฑ ์กฐ์ (0~2) | 0.1~0.3 (์ ํํ ์ฝ๋) 0.7~1.0 (์ฐฝ์์ ํด๊ฒฐ์ฑ ) |
| top_p | ๋ค์์ฑ ์กฐ์ (0~1) | 0.9~0.95 |
| max_tokens | ์ต๋ ์์ฑ ๊ธธ์ด | 512 (์งง์ ํจ์) 2048 (๋ณต์กํ ํด๋์ค) |
| frequency_penalty | ๋ฐ๋ณต ์ต์ (0~2) | 0.1~0.3 |
# ์ ํํ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ์ด ํ์ํ ๋
outputs = model.generate(
**inputs,
max_new_tokens=1024,
temperature=0.1, # ๋ฎ์ ์จ๋๋ก ๊ฒฐ์ ์ ์ถ๋ ฅ
top_p=0.9,
do_sample=True
)
# ์ฐฝ์์ ์ธ ํด๊ฒฐ์ฑ
์ด ํ์ํ ๋
outputs = model.generate(
**inputs,
max_new_tokens=1024,
temperature=0.8, # ๋์ ์จ๋๋ก ๋ค์ํ ์๋
top_p=0.95,
do_sample=True
)
๐จ ํ๋กฌํํธ ์์ง๋์ด๋ง ๊ณ ๊ธ ๊ธฐ๋ฒ
ํ๋กฌํํธ๋ฅผ ์ด๋ป๊ฒ ์์ฑํ๋๋์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๋ฌผ์ ํ์ง์ด ์ฒ์ฐจ๋ง๋ณ์ด์ผ. ๋ช ๊ฐ์ง ๊ณ ๊ธ ๊ธฐ๋ฒ์ ์๊ฐํ ๊ฒ:
1๏ธโฃ ์ญํ ๋ถ์ฌ (Role Playing)AI์๊ฒ ํน์ ์ญํ ์ ๋ถ์ฌํ๋ฉด ๋ ์ ๋ฌธ์ ์ธ ๋ต๋ณ์ ๋ฐ์ ์ ์์ด:
prompt = """
๋น์ ์ 10๋
๊ฒฝ๋ ฅ์ ์๋์ด ๋ฐฑ์๋ ๊ฐ๋ฐ์์
๋๋ค.
์ฑ๋ฅ๊ณผ ๋ณด์์ ์ต์ฐ์ ์ผ๋ก ๊ณ ๋ คํ๋ฉฐ, ํด๋ฆฐ ์ฝ๋ ์์น์ ๋ฐ๋ฆ
๋๋ค.
๋ค์ ์๊ตฌ์ฌํญ์ ๋ง๋ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์:
- ์ฌ์ฉ์ ์ธ์ฆ ์์คํ
(JWT ํ ํฐ ๊ธฐ๋ฐ)
- ๋น๋ฐ๋ฒํธ ํด์ฑ (bcrypt ์ฌ์ฉ)
- Rate limiting ์ ์ฉ
- ์๋ฌ ๋ก๊น
ํฌํจ
"""
2๏ธโฃ ๋จ๊ณ๋ณ ์ฌ๊ณ ์ ๋ (Chain of Thought)๋ณต์กํ ๋ฌธ์ ๋ ๋จ๊ณ๋ณ๋ก ์๊ฐํ๊ฒ ํ๋ฉด ๋ ์ข์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ด:
prompt = """
๋ค์ ๋ฌธ์ ๋ฅผ ๋จ๊ณ๋ณ๋ก ํด๊ฒฐํด์ฃผ์ธ์:
๋ฌธ์ : ๋์ฉ๋ ๋ก๊ทธ ํ์ผ(์ GB)์ ํจ์จ์ ์ผ๋ก ๋ถ์ํ๋ Python ํ๋ก๊ทธ๋จ
1๋จ๊ณ: ๋ฌธ์ ๋ถ์
- ์ด๋ค ๋์ ๊ณผ์ ๊ฐ ์๋์?
- ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ ์ด๋ป๊ฒ ํด๊ฒฐํ ๊น์?
2๋จ๊ณ: ์ค๊ณ
- ์ด๋ค ์๊ณ ๋ฆฌ์ฆ/์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ ๊น์?
- ๋ณ๋ ฌ ์ฒ๋ฆฌ๊ฐ ํ์ํ๊ฐ์?
3๋จ๊ณ: ๊ตฌํ
- ์ค์ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์
4๋จ๊ณ: ์ต์ ํ
- ์ฑ๋ฅ ๊ฐ์ ํฌ์ธํธ๋ฅผ ์ ์ํด์ฃผ์ธ์
"""
3๏ธโฃ ์ ์ฝ ์กฐ๊ฑด ๋ช ์๊ตฌ์ฒด์ ์ธ ์ ์ฝ ์กฐ๊ฑด์ ๋ช ์ํ๋ฉด ๋ ์ ํํ ์ฝ๋๋ฅผ ๋ฐ์ ์ ์์ด:
prompt = """
๋ค์ ์ ์ฝ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์ฝ๋๋ฅผ ์์ฑํด์ฃผ์ธ์:
์๊ตฌ์ฌํญ: ํ์ผ ์
๋ก๋ API
์ ์ฝ ์กฐ๊ฑด:
- ํ์ผ ํฌ๊ธฐ: ์ต๋ 10MB
- ํ์ฉ ํ์ฅ์: jpg, png, pdf๋ง
- ๋์ ์
๋ก๋: ์ต๋ 5๊ฐ
- ํ์์์: 30์ด
- Python 3.9+, FastAPI ์ฌ์ฉ
- ํ์
ํํธ ํ์
- ์๋ฌ ์ฒ๋ฆฌ ์๋ฒฝํ๊ฒ
"""
๐ ์ฝ๋ ๋ฆฌ๋ทฐ ์๋ํ
DeepSeek-Coder๋ฅผ ์ฝ๋ ๋ฆฌ๋ทฐ์ด๋ก ํ์ฉํ ์๋ ์์ด. ์ด๊ฑด ์ง์ง ์ ์ฉํด! ๐
def review_code(code_to_review):
"""
์์ฑํ ์ฝ๋๋ฅผ AI๊ฐ ๋ฆฌ๋ทฐํ๊ฒ ํ๋ ํจ์
"""
prompt = f"""
๋ค์ ์ฝ๋๋ฅผ ๋ฆฌ๋ทฐํด์ฃผ์ธ์. ๋ค์ ๊ด์ ์์ ๋ถ์ํด์ฃผ์ธ์:
1. ๋ฒ๊ทธ๋ ์ ์ฌ์ ์ค๋ฅ
2. ์ฑ๋ฅ ๊ฐ์ ํฌ์ธํธ
3. ๋ณด์ ์ทจ์ฝ์
4. ์ฝ๋ ๊ฐ๋
์ฑ
5. ๋ฒ ์คํธ ํ๋ํฐ์ค ์ค์ ์ฌ๋ถ
์ฝ๋:
```python
{code_to_review}
```
๊ฐ ํญ๋ชฉ๋ณ๋ก ๊ตฌ์ฒด์ ์ธ ํผ๋๋ฐฑ๊ณผ ๊ฐ์ ์ ์์ ํด์ฃผ์ธ์.
"""
return generate_code(prompt)
# ์ฌ์ฉ ์์
my_code = """
def get_user(user_id):
conn = sqlite3.connect('users.db')
cursor = conn.cursor()
cursor.execute(f"SELECT * FROM users WHERE id = {user_id}")
result = cursor.fetchone()
return result
"""
review = review_code(my_code)
print("๐ ์ฝ๋ ๋ฆฌ๋ทฐ ๊ฒฐ๊ณผ:")
print(review)
์ด๋ ๊ฒ ํ๋ฉด SQL ์ธ์ ์ ์ทจ์ฝ์ , ๋ฆฌ์์ค ๋์(์ฐ๊ฒฐ ๋ฏธ์ข ๋ฃ), ์๋ฌ ์ฒ๋ฆฌ ๋ถ์ฌ ๋ฑ์ ์ง์ ํด์ค ๊ฑฐ์ผ. ํผ์ ๊ฐ๋ฐํ ๋ ์ ๋ง ๋ ๋ ํ ์กฐ๋ ฅ์์ง! ๐ช
DeepSeek-Coder๊ฐ ์๋ฌด๋ฆฌ ๋๋ํด๋ ์๋ฒฝํ์ง ์์. ์ฌ์ฉํ ๋ ์ฃผ์ํด์ผ ํ ์ ๋ค์ ์์๋์! โ ๏ธ
1. ์์ฑ๋ ์ฝ๋๋ฅผ ๋งน์ ํ์ง ๋ง ๊ฒAI๊ฐ ๋ง๋ ์ฝ๋๋ผ๊ณ ํด์ ๋ฌด์กฐ๊ฑด ์ ํํ ๊ฑด ์๋์ผ. ํนํ ๋ณต์กํ ๋ก์ง์ด๋ ์ฃ์ง ์ผ์ด์ค ์ฒ๋ฆฌ์์ ์ค์ํ ์ ์์ด. ๋ฐ๋์ ์ฝ๋๋ฅผ ๊ฒํ ํ๊ณ ํ ์คํธํด์ผ ํด!
2. ๋ณด์์ ๋ฏผ๊ฐํ ์ฝ๋๋ ์ฃผ์์ธ์ฆ, ์ํธํ, ๊ฒฐ์ ์ฒ๋ฆฌ ๊ฐ์ ๋ณด์์ด ์ค์ํ ๋ถ๋ถ์ AI๊ฐ ์์ฑํ ์ฝ๋๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด ์ํํด. ๋ณด์ ์ ๋ฌธ๊ฐ์ ๊ฒํ ๋ฅผ ๋ฐ๊ฑฐ๋, ๊ฒ์ฆ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ ์์ ํด. ๐
3. ๋ผ์ด์ ์ค ๋ฌธ์ AI๊ฐ ํ์ตํ ์ฝ๋ ์ค์๋ ํน์ ๋ผ์ด์ ์ค๊ฐ ์ ์ฉ๋ ๊ฒ๋ค๋ ์์ด. ์์ ์ ์ผ๋ก ์ฌ์ฉํ ๋๋ ์์ฑ๋ ์ฝ๋์ ๋ผ์ด์ ์ค๋ฅผ ํ์ธํ๋ ๊ฒ ์ข์. ํนํ GPL ๊ฐ์ ์นดํผ๋ ํํธ ๋ผ์ด์ ์ค๋ ์ฃผ์ํด์ผ ํด!
4. ์ต์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ฒ์ AI ๋ชจ๋ธ์ ํ์ต ๋ฐ์ดํฐ๋ ํน์ ์์ ๊น์ง์ ๊ฒ์ด์ผ. ์ต์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ฒ์ ์ด๋ ์๋ก์ด ๊ธฐ๋ฅ์ ๋ชจ๋ฅผ ์ ์์ด. ๊ณต์ ๋ฌธ์๋ฅผ ํจ๊ป ์ฐธ๊ณ ํ๋ ๊ฒ ์ข์! ๐
๐ฏ ํจ๊ณผ์ ์ธ ์ฌ์ฉ์ ์ํ ์ฒดํฌ๋ฆฌ์คํธ
โ
์์ฑ๋ ์ฝ๋๋ฅผ ์คํํ๊ธฐ ์ ์ ๊ผผ๊ผผํ ์ฝ์ด๋ณด๊ธฐ
โ
๋จ์ ํ
์คํธ ์์ฑํด์ ๊ฒ์ฆํ๊ธฐ
โ
๋ณด์ ์ทจ์ฝ์ ์ค์บ ๋๊ตฌ ํ์ฉํ๊ธฐ
โ
์ฝ๋ ๋ฆฌ๋ทฐ ํ๋ก์ธ์ค์ ํฌํจ์ํค๊ธฐ
โ
ํ๋ก๋์
๋ฐฐํฌ ์ ์ถฉ๋ถํ ํ
์คํธํ๊ธฐ
โ
์๋ฌ ์ฒ๋ฆฌ์ ๋ก๊น
์ถ๊ฐํ๊ธฐ
โ
์ฑ๋ฅ ํ
์คํธ ์ํํ๊ธฐ
๐ซ ์ด๋ฐ ์ฉ๋๋ก๋ ์ฌ์ฉํ์ง ๋ง์
โ ์ดํดํ์ง ๋ชปํ๋ ์ฝ๋๋ฅผ ๋ณต์ฌ-๋ถ์ฌ๋ฃ๊ธฐ๋ง ํ๊ธฐ
โ ๋ณด์์ด ์ค์ํ ์์คํ
์ AI์๊ฒ๋ง ๋งก๊ธฐ๊ธฐ
โ ์ฝ๋ ๋ฆฌ๋ทฐ๋ ํ
์คํธ ์์ด ๋ฐ๋ก ๋ฐฐํฌํ๊ธฐ
โ ํ์ต ๋ชฉ์ ์ผ๋ก AI ์ฝ๋๋ง ๋ณด๊ณ ์๋ฆฌ๋ ๊ณต๋ถ ์ ํ๊ธฐ
โ ์ ์๊ถ์ด ์๋ ์ฝ๋๋ฅผ ๋ฌด๋จ์ผ๋ก ์ฌ์ฉํ๊ธฐ
์ด์ DeepSeek-Coder๋ฅผ ์ค์ ๊ฐ๋ฐ ์ํฌํ๋ก์ฐ์ ํตํฉํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์. ํผ์ ์ฐ๋ ๊ฒ๋ ์ข์ง๋ง, ํ ์ ์ฒด๊ฐ ํ์ฉํ๋ฉด ์์ฐ์ฑ์ด ๋ฐฐ๋ก ์ฌ๋ผ๊ฐ๊ฑฐ๋ ! ๐
๐ VS Code ํ์ฅ ํ๋ก๊ทธ๋จ ๋ง๋ค๊ธฐ
๋งค๋ฒ ํฐ๋ฏธ๋์์ ์คํฌ๋ฆฝํธ ์คํํ๊ธฐ ๊ท์ฐฎ์ง? VS Code ํ์ฅ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด์ ์๋ํฐ ์์์ ๋ฐ๋ก ์ฌ์ฉํ ์ ์์ด:
# vscode_extension.py
import subprocess
import sys
def generate_in_vscode(prompt):
"""
VS Code์์ ์ ํํ ํ
์คํธ๋ฅผ ํ๋กฌํํธ๋ก ์ฌ์ฉ
"""
# ์ฌ๊ธฐ์๋ ๊ฐ๋จํ ์์๋ง ๋ณด์ฌ์ค๊ฒ
# ์ค์ ๋ก๋ VS Code Extension API๋ฅผ ์ฌ์ฉํด์ผ ํด
result = generate_code(prompt)
# ๊ฒฐ๊ณผ๋ฅผ ํด๋ฆฝ๋ณด๋์ ๋ณต์ฌ
import pyperclip
pyperclip.copy(result)
print("โ
์์ฑ๋ ์ฝ๋๊ฐ ํด๋ฆฝ๋ณด๋์ ๋ณต์ฌ๋์์ต๋๋ค!")
print("Ctrl+V๋ก ๋ถ์ฌ๋ฃ๊ธฐ ํ์ธ์.")
# ์ฌ์ฉ ์์
if __name__ == "__main__":
if len(sys.argv) > 1:
prompt = " ".join(sys.argv[1:])
generate_in_vscode(prompt)
์ด๊ฑธ VS Code์ tasks.json์ ๋ฑ๋กํ๋ฉด ๋จ์ถํค๋ก ๋ฐ๋ก ์คํํ ์ ์์ด! ๊ฐ๋ฐ ์๋๊ฐ ์์ฒญ ๋นจ๋ผ์ง์ง. โก
๐ค GitHub Actions์ ์ฐ๋
CI/CD ํ์ดํ๋ผ์ธ์ DeepSeek-Coder๋ฅผ ํตํฉํ๋ฉด ์๋์ผ๋ก ์ฝ๋ ๋ฆฌ๋ทฐ๋ ํ ์คํธ ์์ฑ์ ํ ์ ์์ด:
# .github/workflows/ai-review.yml
name: AI Code Review
on:
pull_request:
types: [opened, synchronize]
jobs:
ai-review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Setup Python
uses: actions/setup-python@v2
with:
python-version: '3.10'
- name: Install dependencies
run: |
pip install requests
- name: Run AI Review
env:
DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
run: |
python scripts/ai_review.py
- name: Comment PR
uses: actions/github-script@v6
with:
script: |
const fs = require('fs');
const review = fs.readFileSync('review_result.txt', 'utf8');
github.rest.issues.createComment({
issue_number: context.issue.number,
owner: context.repo.owner,
repo: context.repo.repo,
body: `## ๐ค AI Code Review\n\n${review}`
});
์ด๋ ๊ฒ ํ๋ฉด PR์ ์ฌ๋ฆด ๋๋ง๋ค ์๋์ผ๋ก AI๊ฐ ์ฝ๋๋ฅผ ๋ฆฌ๋ทฐํด์ ์ฝ๋ฉํธ๋ฅผ ๋ฌ์์ค. ํ์๋ค์ด ๋์น ์ ์๋ ๋ถ๋ถ์ ์ก์๋ผ ์ ์์ด์ ์ ๋ง ์ ์ฉํด! ๐
๐ ๊ฐ๋ฐ ์์ฐ์ฑ ์ธก์
DeepSeek-Coder๋ฅผ ์ฌ์ฉํ๋ฉด์ ์ผ๋ง๋ ์๊ฐ์ ์ ์ฝํ๋์ง ์ธก์ ํด๋ณด๋ ๊ฒ๋ ์ข์:
import time
import json
from datetime import datetime
class ProductivityTracker:
"""AI ์ฝ๋ ์์ฑ ์์ฐ์ฑ ์ถ์ ๊ธฐ"""
def __init__(self, log_file="productivity.json"):
self.log_file = log_file
self.logs = self.load_logs()
def load_logs(self):
try:
with open(self.log_file, 'r') as f:
return json.load(f)
except FileNotFoundError:
return []
def save_logs(self):
with open(self.log_file, 'w') as f:
json.dump(self.logs, f, indent=2)
def track_generation(self, prompt, estimated_manual_time):
"""
์ฝ๋ ์์ฑ ์ถ์
Args:
prompt: ์ฌ์ฉํ ํ๋กฌํํธ
estimated_manual_time: ์๋์ผ๋ก ์์ฑํ์ ๋ ์์ ์๊ฐ(๋ถ)
"""
start_time = time.time()
# ์ฝ๋ ์์ฑ
result = generate_code(prompt)
generation_time = (time.time() - start_time) / 60 # ๋ถ ๋จ์
time_saved = estimated_manual_time - generation_time
log_entry = {
"timestamp": datetime.now().isoformat(),
"prompt_length": len(prompt),
"generation_time": round(generation_time, 2),
"estimated_manual_time": estimated_manual_time,
"time_saved": round(time_saved, 2),
"efficiency": round((time_saved / estimated_manual_time) * 100, 1)
}
self.logs.append(log_entry)
self.save_logs()
print(f"โฑ๏ธ ์์ฑ ์๊ฐ: {generation_time:.1f}๋ถ")
print(f"๐ฐ ์ ์ฝ ์๊ฐ: {time_saved:.1f}๋ถ ({log_entry['efficiency']}%)")
return result
def get_statistics(self):
"""์ ์ฒด ํต๊ณ ์กฐํ"""
if not self.logs:
return "์์ง ๊ธฐ๋ก์ด ์์ต๋๋ค."
total_saved = sum(log['time_saved'] for log in self.logs)
avg_efficiency = sum(log['efficiency'] for log in self.logs) / len(self.logs)
return f"""
๐ ์์ฐ์ฑ ํต๊ณ
โโโโโโโโโโโโโโโโโโโโโโ
์ด ์ฌ์ฉ ํ์: {len(self.logs)}ํ
์ด ์ ์ฝ ์๊ฐ: {total_saved:.1f}๋ถ ({total_saved/60:.1f}์๊ฐ)
ํ๊ท ํจ์จ์ฑ: {avg_efficiency:.1f}%
"""
# ์ฌ์ฉ ์์
tracker = ProductivityTracker()
prompt = "FastAPI๋ก CRUD API ๋ง๋ค์ด์ค"
result = tracker.track_generation(prompt, estimated_manual_time=30)
print(tracker.get_statistics())
์ด๋ ๊ฒ ๋ฐ์ดํฐ๋ฅผ ๋ชจ์ผ๋ฉด "AI ๋๋ถ์ ์ด๋ฒ ๋ฌ์ 20์๊ฐ ์ ์ฝํ์ด์!" ๊ฐ์ ๊ตฌ์ฒด์ ์ธ ์์น๋ฅผ ๋ณด๊ณ ํ ์ ์์ด. ์์ฌํํ ๋ณด๊ณ ํ ๋ ๋ฑ์ด์ง! ๐
DeepSeek-Coder ๊ฐ์ AI ๋๊ตฌ๋ฅผ ์ ๋ค๋ฃจ๊ฒ ๋๋ฉด, ์ด์ ๋๋ ๋ค๋ฅธ ์ฌ๋๋ค์ ๋์ธ ์ ์์ด! ์ฌ๋ฅ๋ท(https://www.jaenung.net)์์๋ ์ด๋ฐ AI ๊ฐ๋ฐ ๊ด๋ จ ์ฌ๋ฅ์ ๊ณต์ ํ๊ณ ๊ฑฐ๋ํ ์ ์๊ฑฐ๋ . ๐
์๋ฅผ ๋ค๋ฉด ์ด๋ฐ ์๋น์ค๋ฅผ ์ ๊ณตํ ์ ์์ด:
๐ก AI ์ฝ๋ ์์ฑ ์ปจ์คํ
โข DeepSeek-Coder ์ค์น ๋ฐ ์ค์ ๋์
โข ํ๋กฌํํธ ์์ง๋์ด๋ง ๊ต์ก
โข ํ ์ํฌํ๋ก์ฐ ํตํฉ ์ง์
โข ๋ง์ถคํ AI ์ฝ๋ฉ ์ด์์คํดํธ ๊ตฌ์ถ
๐ง AI ๊ธฐ๋ฐ ์ฝ๋ ๋ฆฌ๋ทฐ ์๋น์คโข ํ๋ก์ ํธ ์ฝ๋๋ฅผ AI๋ก ๋ถ์
โข ๋ฒ๊ทธ์ ๋ณด์ ์ทจ์ฝ์ ํ์ง
โข ์ฑ๋ฅ ์ต์ ํ ์ ์
โข ๋ฆฌํฉํ ๋ง ๊ฐ์ด๋ ์ ๊ณต
๐ AI ํ์ฉ ํ๋ก๊ทธ๋๋ฐ ๊ต์กโข ์ด๋ณด์๋ฅผ ์ํ AI ์ฝ๋ฉ ์
๋ฌธ
โข ์ค์ ํ๋ก์ ํธ ๋ฉํ ๋ง
โข ์์ฐ์ฑ ํฅ์ ๋
ธํ์ฐ ๊ณต์
โข 1:1 ๋ง์ถค ์ฝ์นญ
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์ ํ์ฉํ๋ฉด ๋ค๊ฐ ๋ฐฐ์ด ์ง์์ ๋๋๋ฉด์ ์์ต๋ ์ฐฝ์ถํ ์ ์์ด. ๊ฒ๋ค๊ฐ ๋ค๋ฅธ ์ฌ๋์ ๊ฐ๋ฅด์น๋ค ๋ณด๋ฉด ๋ ์์ ๋ ๋ ๊น์ด ์ดํดํ๊ฒ ๋๊ฑฐ๋ ! ์ผ์์ด์กฐ์ง? ๐
๐ฏ ์ฑ๊ณต์ ์ธ ์ฌ๋ฅ ๊ณต์ ํ
1. ํฌํธํด๋ฆฌ์ค ์ค๋น: DeepSeek-Coder๋ก ๋ง๋ ํ๋ก์ ํธ๋ค์ GitHub์ ์ฌ๋ ค๋๊ธฐ
2. ์ค์ ์์ ์ ๊ณต: ๋ธ๋ก๊ทธ๋ ์ ํ๋ธ์ ํํ ๋ฆฌ์ผ ์ฌ๋ฆฌ๊ธฐ
3. ์ปค๋ฎค๋ํฐ ํ๋: ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์์ ์ง๋ฌธ์ ๋ต๋ณํ๋ฉฐ ์ ๋ฌธ์ฑ ์๊ธฐ
4. ํผ๋๋ฐฑ ์์ง: ์๋น์ค๋ฅผ ์ด์ฉํ ์ฌ๋๋ค์ ํ๊ธฐ ๋ชจ์ผ๊ธฐ
5. ์ง์์ ํ์ต: AI ๊ธฐ์ ์ ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๋ ๊ณ์ ๊ณต๋ถํ๊ธฐ
์! ์ฌ๊ธฐ๊น์ง ์ฝ์๋ค๋ฉด ์ ๋ง ๋๋จํด! ๐ ์ฐ๋ฆฌ ํจ๊ป DeepSeek-Coder์ ์ค์น๋ถํฐ ๊ณ ๊ธ ํ์ฉ๋ฒ๊น์ง ๋ชจ๋ ๊ฑธ ์ดํด๋ดค์ด. ์ด์ ๋๋ AI ์ฝ๋ฉ ์ด์์คํดํธ๋ฅผ ์์ ์์ฌ๋ก ๋ค๋ฃฐ ์ ์์ ๊ฑฐ์ผ!
์ ๋ฆฌํ์๋ฉด:
โจ DeepSeek-Coder์ ํต์ฌ ์ฅ์ โข ์คํ์์ค๋ผ์ ๋ฌด๋ฃ๋ก ์ฌ์ฉ ๊ฐ๋ฅ
โข 80๊ฐ ์ด์์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ์ง์
โข ์ค๋ฌด์ ๋ฐ๋ก ์ธ ์ ์๋ ํ์ง์ ์ฝ๋ ์์ฑ
โข ๋ก์ปฌ ๋๋ API ๋ฐฉ์์ผ๋ก ์ ์ฐํ๊ฒ ํ์ฉ
โข ์ฝ๋ ์์ฑ, ๋ฆฌ๋ทฐ, ํ
์คํธ, ๋ฌธ์ํ ๋ฑ ๋ค์ํ ์ฉ๋
ํ์ง๋ง ๊ธฐ์ตํด! AI๋ ๋๊ตฌ์ผ ๋ฟ์ด์ผ. ์ง์ง ์ค์ํ ๊ฑด ๋ฌธ์ ๋ฅผ ์ดํดํ๊ณ ํด๊ฒฐํ๋ ๋์ ๋ฅ๋ ฅ์ด์ผ. AI๊ฐ ์์ฑํ ์ฝ๋๋ฅผ ์ดํดํ๊ณ , ํ์์ ๋ง๊ฒ ์์ ํ๊ณ , ๋ ๋์ ๋ฐฉํฅ์ผ๋ก ๊ฐ์ ํ ์ ์๋ ๋ฅ๋ ฅ์ด ์ง์ง ๊ฐ๋ฐ์์ ์ค๋ ฅ์ด๊ฑฐ๋ . ๐ช
DeepSeek-Coder๋ ๋ค๊ฐ ๋ ๋น ๋ฅด๊ฒ, ๋ ํจ์จ์ ์ผ๋ก ๊ฐ๋ฐํ ์ ์๊ฒ ๋์์ฃผ๋ ํ๋ฅญํ ํํธ๋์ผ. ํ์ง๋ง ์ต์ข ๊ฒฐ์ ์ ํญ์ ๋์ ๋ชซ์ด๊ณ , ์ฝ๋์ ํ์ง์ ๋ํ ์ฑ ์๋ ๋์๊ฒ ์์ด. AI๋ฅผ ํ๋ช ํ๊ฒ ํ์ฉํ๋, ๋งน์ ํ์ง๋ ๋ง์! ๐ฏ
๐ ๋ค์ ๋จ๊ณ๋ก ๋์๊ฐ๊ธฐ
์ด์ ๋ญ ํด์ผ ํ ๊น? ๋ช ๊ฐ์ง ์ ์์ ํด๋ณผ๊ฒ:
1. ์์ ํ๋ก์ ํธ๋ถํฐ ์์: ๊ฐ๋จํ ์ ํธ๋ฆฌํฐ๋ ์คํฌ๋ฆฝํธ๋ฅผ ๋ง๋ค์ด๋ณด๋ฉด์ ๊ฐ์ ์ตํ๋ด
2. ์ค์ ํ๋ก์ ํธ์ ์ ์ฉ: ์ค์ ์
๋ฌด๋ ์ฌ์ด๋ ํ๋ก์ ํธ์์ ํ์ฉํด๋ด
3. ์ปค๋ฎค๋ํฐ ์ฐธ์ฌ: GitHub, Reddit, Discord ๋ฑ์์ ๋ค๋ฅธ ์ฌ์ฉ์๋ค๊ณผ ๊ฒฝํ ๊ณต์
4. ์ง์์ ํ์ต: AI ๊ธฐ์ ์ ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๋ ์ต์ ํธ๋ ๋๋ฅผ ๊ณ์ ํ๋ก์ฐ
5. ์ง์ ๋๋๊ธฐ: ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ๋ค๊ฐ ๋ฐฐ์ด ๊ฑธ ๋ค๋ฅธ ์ฌ๋๋ค๊ณผ ๊ณต์
ํ๋ก๊ทธ๋๋ฐ์ ๊ฒฐ๊ตญ ๋ฌธ์ ํด๊ฒฐ์ ์์ ์ด์ผ. AI๋ ๊ทธ ๊ณผ์ ์ ๋ ์ฆ๊ฒ๊ณ ํจ์จ์ ์ผ๋ก ๋ง๋ค์ด์ฃผ๋ ๋ฉ์ง ๋๊ตฌ๊ณ . DeepSeek-Coder์ ํจ๊ป๋ผ๋ฉด ๋ค๊ฐ ์์ํ๋ ๋ชจ๋ ๊ฑธ ์ฝ๋๋ก ๋ง๋ค์ด๋ผ ์ ์์ ๊ฑฐ์ผ! ๐
ํน์ ๋งํ๋ ๋ถ๋ถ์ด ์๊ฑฐ๋ ๋ ๊ถ๊ธํ ๊ฒ ์๋ค๋ฉด, ๊ฐ๋ฐ์ ์ปค๋ฎค๋ํฐ์ ์ง๋ฌธํ๊ฑฐ๋ ์ฌ๋ฅ๋ท์์ ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ์๋ด. ํผ์ ๊ณ ๋ฏผํ์ง ๋ง๊ณ ํจ๊ป ์ฑ์ฅํ์! ๐
์, ์ด์ ํฐ๋ฏธ๋์ ์ด๊ณ DeepSeek-Coder๋ฅผ ์คํํด๋ด. ๋ค ์ฒซ ๋ฒ์งธ AI ์์ฑ ์ฝ๋๊ฐ ์ด๋ป๊ฒ ๋์ฌ์ง ์ ๋ง ๊ธฐ๋๋์ง ์์? ํ์ด์ ๋น์ด! ํ์ดํ ! ๐โจ
๐ Happy Coding with AI! ๐ค
AI์ ํจ๊ปํ๋ ์ฝ๋ฉ, ์ด์ ์์์ด์ผ!
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.